UFT License Management Guide

Installing and Setting Up UFT - Advanced License Management and Concurrent User Allocation

Unified Functional Testing (UFT) is a powerful testing solution that enables organizations to automate functional and regression testing for various applications. Proper license management is crucial for maximizing the return on investment in UFT, especially when dealing with concurrent user allocation in large testing environments. This comprehensive guide will walk you through the installation process and advanced license management techniques to ensure your testing team can efficiently utilize UFT licenses without unnecessary bottlenecks.

Understanding UFT License Models

UFT offers two primary licensing models that organizations can choose from based on their testing needs: seat licenses and concurrent licenses. Seat licenses are machine-specific and tied to a particular computer's locking code, meaning each licensed machine can run UFT independently without needing to connect to a license server. This model is ideal for small teams with dedicated workstations or for organizations where testers work primarily from a single location.

Concurrent licenses, on the other hand, operate on a "floating" model where licenses are managed by a central license server. Multiple users can share a pool of licenses, accessing them as needed. This model provides greater flexibility for distributed teams and can be more cost-effective for organizations with fluctuating testing demands. When using concurrent licenses, UFT client machines need to connect to the license server during the launch sequence, either by specifying the server's name/IP address or allowing UFT to automatically locate it on the network.

The choice between these models depends on factors such as team size, testing patterns, infrastructure, and budget considerations. While seat licenses offer simplicity and direct control, concurrent licenses provide scalability and resource optimization for larger organizations.

• Seat Licenses: Machine-specific, fixed allocation
• Concurrent Licenses: Floating allocation across the organization
• Hybrid Approach: Combining both models for maximum flexibility

Installing UFT: Step-by-Step Guide

The installation process for UFT is straightforward but requires attention to detail to ensure proper license configuration. Begin by downloading the installation package from the official Micro Focus portal or your organization's software repository. Run the installer as an administrator to ensure proper permissions for system modifications during installation.

During the installation process, you'll be prompted to select components. Depending on your testing needs, you may choose to install additional features like UFT Developer, which requires specific license IDs (10594 for UFT One Concurrent User or 23078 for UFT Ultimate Concurrent User). Make sure to note the installation directory, as this will be important for license configuration later.

After installation completes, you'll need to activate your licenses. For seat licenses, use the FT License Installation Wizard utility, which can be accessed from the Start menu or directly from the installation directory at <installdir>\bin\HP.UFT.LicenseInstallationWizard.exe. For concurrent licenses, the installation involves setting up an AutoPass License Server, which provides a web-based interface for managing licenses across your organization.

• Key installation considerations:
• Run installer as administrator
• Select appropriate components based on testing needs
• Note installation directory for later reference
• Prepare license information before activation

Setting Up License Servers for Concurrent Access

Setting up a license server for concurrent UFT licenses requires careful planning to ensure reliable access for all authorized users. The AutoPass License Server is the central component for managing concurrent licenses, providing a web-based interface for installation, administration, and tracking of license usage. Begin by installing the AutoPass License Server on a dedicated machine that remains accessible to all UFT clients.

Configure the server with the appropriate number of concurrent licenses based on your team's requirements. During setup, you'll need to specify the server's name or IP address, which UFT clients will use to connect. It's recommended to use a static IP address or a reliable DNS name to ensure consistent connectivity. Consider placing the license server in a network segment with minimal latency to all client machines to prevent connection issues.

# Example script to configure AutoPass License Server
# This script should be run on the license server machine
sudo systemctl start autolicense
sudo systemctl enable autolicense
sudo /opt/microfocus/autolicense/bin/configure_server --host=license-server.example.com --port=27000

For security, implement proper access controls to prevent unauthorized access to the license server. Configure firewall rules to allow connections only from authorized UFT client machines and restrict external access. Additionally, consider implementing redundancy measures such as a backup license server to ensure continuous availability in case of primary server failure.

The license server's web interface allows administrators to monitor license usage patterns, set allocation policies, and manage license assignments. Regularly review usage statistics to identify potential bottlenecks or underutilization that might require adjustments to license allocation.

Configuring Concurrent User Allocation

Configuring concurrent user allocation is a critical step in setting up UFT for optimal license utilization. The AutoPass License Server provides a comprehensive web-based interface where administrators can define how many concurrent users are permitted to access UFT simultaneously. This configuration directly impacts how many team members can run tests concurrently without encountering license shortages.

To set up concurrent licenses, administrators must first install the appropriate license keys on the license server. These keys specify the number of concurrent users allowed and may include different license types for various UFT features or editions. Once installed, the license server can be configured with specific rules and policies governing how licenses are allocated and reclaimed when no longer in use.

The configuration process also involves setting up license timeouts, which define how long a license remains checked out to a user before it's automatically returned to the pool. This prevents licenses from being held indefinitely by idle users. Additionally, administrators can implement priority-based allocation, ensuring that critical testing tasks receive license priority during high-demand periods. These configurations help maximize the efficiency of the license pool while ensuring that testing operations proceed smoothly.

Managing Advanced License Allocation

Advanced license allocation in UFT involves implementing strategies to optimize license utilization across your testing organization. When managing concurrent licenses, you can implement allocation policies that prioritize certain users or projects based on business requirements. The AutoPass License Server's web interface provides tools to create these policies and monitor their effectiveness.

One effective strategy is to implement license borrowing, which allows users to temporarily "check out" licenses for offline use. This feature is particularly valuable for remote workers or those who need to continue testing during network outages. Configure borrowing policies with appropriate time limits to ensure licenses are returned to the pool when no longer needed.

For organizations with multiple testing teams, consider implementing license pools that are dedicated to specific projects or departments. This approach prevents any single team from monopolizing licenses and ensures fair resource distribution across the organization. The license server allows you to create these pools and set usage limits based on each team's requirements.

• License allocation best practices:
• Implement usage policies based on priority levels
• Enable license borrowing for remote workers
• Create dedicated license pools for different teams
• Set usage limits to prevent monopolization
• Regularly review and adjust allocation policies

Monitoring license usage through the AutoPass web interface provides valuable insights into utilization patterns. Identify peak usage times and consider implementing time-based allocation strategies to distribute demand more evenly throughout the day. Additionally, track license checkout durations to identify potential inefficiencies or users who may be holding onto licenses longer than necessary.

// Example JavaScript code for checking license availability
function checkLicenseAvailability() {
    const url = 'http://license-server.example.com:8080/api/licenses';
    const projectId = 'project123';
    
    fetch(url)
        .then(response => response.json())
        .then(data => {
            const availableLicenses = data.conLicenses.filter(lic => 
                lic.projectId === projectId && lic.status === 'available'
            ).length;
            
            console.log(`Available licenses for project ${projectId}: ${availableLicenses}`);
            
            if (availableLicenses > 0) {
                requestLicense(projectId);
            } else {
                console.log('No licenses available at the moment');
            }
        })
        .catch(error => {
            console.error('Error checking license availability:', error);
        });
}

Managing Seat Licenses with the License Installation Wizard

For organizations utilizing seat licenses, the UFT License Installation Wizard provides a streamlined process for deploying licenses across multiple machines. This wizard can be accessed through the Start menu or directly from the UFT installation directory, offering a guided approach to license installation that minimizes errors and ensures proper configuration.

The wizard begins by detecting the current license status of the machine and then guides users through the selection of license types to be installed. For seat licenses, users must provide the appropriate license keys or select from previously imported licenses. The wizard then configures the license settings based on the machine's locking code, ensuring the license is properly bound to the specific computer.

• Easy License Import: Import multiple license files at once
• License Validation: Verify license compatibility before installation
• Configuration Options: Customize license settings based on organizational needs

The License Installation Wizard also allows for the management of both seat and concurrent licenses on client machines, providing flexibility for organizations that utilize a hybrid approach. After installation, the wizard provides confirmation that the licenses are properly configured and accessible to UFT, with options to launch the application immediately to verify functionality.

Monitoring and Optimizing License Usage

Effective monitoring of UFT license usage is essential for maintaining optimal performance and cost efficiency in your testing environment. The AutoPass License Server provides comprehensive tools for tracking license utilization, including real-time dashboards and historical reports. Regularly review these metrics to identify trends, potential bottlenecks, and opportunities for optimization.

One key metric to monitor is the license utilization rate, which indicates what percentage of your licensed seats are actively in use at any given time. A consistently high utilization rate (above 80%) may indicate that you need additional licenses to meet demand, while a consistently low rate (below 50%) might suggest that you have more licenses than necessary. Aim for a utilization rate between 60-80% to balance availability with cost efficiency.

Another important aspect of monitoring is tracking license checkout durations and patterns. Identify users who frequently hold onto licenses for extended periods without active use, as this can limit availability for others. Implement policies that encourage timely license returns, such as automatic check-in after periods of inactivity or warnings when approaching license expiration.

For organizations with fluctuating testing demands, consider implementing dynamic license allocation strategies. This could involve temporarily reallocating licenses from less active projects to those experiencing peak demand, or adjusting license limits based on project timelines and priorities.

# Example Python script for analyzing license usage patterns
import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime, timedelta

def analyze_license_usage(log_file):
    # Read license log data
    df = pd.read_csv(log_file, parse_dates=['timestamp'])
    
    # Calculate daily usage
    daily_usage = df.groupby(df['timestamp'].dt.date).size()
    
    # Identify peak usage hours
    df['hour'] = df['timestamp'].dt.hour
    hourly_usage = df.groupby('hour').size()
    
    # Plot usage patterns
    plt.figure(figsize=(12, 6))
    
    plt.subplot(1, 2, 1)
    daily_usage.plot(kind='bar')
    plt.title('Daily License Usage')
    plt.xlabel('Date')
    plt.ylabel('Number of Licenses Used')
    
    plt.subplot(1, 2, 2)
    hourly_usage.plot(kind='bar')
    plt.title('Hourly License Usage Pattern')
    plt.xlabel('Hour of Day')
    plt.ylabel('Number of Licenses Used')
    
    plt.tight_layout()
    plt.savefig('license_usage_analysis.png')
    plt.close()
    
    return daily_usage, hourly_usage

# Example usage
daily, hourly = analyze_license_usage('license_usage_log.csv')
print(f"Peak usage day: {daily.idxmax()} with {daily.max()} licenses")
print(f"Peak usage hour: {hourly.idxmax()}:00 with {hourly.max()} licenses")

Troubleshooting Common License Issues

Despite careful planning and configuration, license-related issues can occasionally arise in UFT environments. Understanding common problems and their solutions can help minimize downtime and maintain smooth testing operations. One frequent issue is license server connectivity problems, which can prevent UFT clients from accessing available licenses.

When encountering connectivity issues, first verify that the license server is running and accessible from the client machine. Check firewall settings to ensure that the required ports are open between clients and the server. For client machines, confirm that the correct server name or IP address has been specified in the UFT configuration. If no address is specified, UFT will attempt to locate a server automatically during launch, but this may not always work in complex network environments.

Another common issue is license exhaustion, where all available licenses are in use, preventing legitimate users from accessing UFT. To address this, you can temporarily increase license limits if your licensing agreement allows, or implement borrowing policies to free up licenses for critical tasks. Long-term solutions may involve negotiating additional licenses or optimizing usage patterns to reduce peak demand.

License corruption or expiration can also cause problems. Regularly check license expiration dates and renew before they lapse. If licenses become corrupted, you may need to reinstall them using the FT License Installation Wizard. For persistent issues, Micro Focus support resources can provide additional guidance and troubleshooting assistance.

License validation errors often occur when attempting to use features that require specific license types. For example, UFT Developer features require license ID 10594 (UFT One Concurrent User) or 23078 (UFT Ultimate Concurrent User). Ensuring that the appropriate licenses are installed and accessible on the client machines can prevent these errors. When troubleshooting, it's also important to check for license expiration dates and renewal requirements.

Conclusion

Installing and setting up UFT with advanced license management and concurrent user allocation requires careful planning and configuration, but the investment pays dividends in operational efficiency and cost optimization. By understanding the different license models, properly installing the license server, configuring concurrent allocations, and implementing robust monitoring practices, organizations can create a flexible testing environment that scales with their needs.

Regular license management ensures compliance, maximizes utilization, and prevents disruptions to testing schedules, ultimately contributing to more efficient software development cycles. With the strategies outlined in this guide, you can create a flexible, scalable license management system that supports your organization's testing objectives while controlling costs and maximizing resource utilization.

Frequently Asked Questions

• What are the two primary UFT license models?
  UFT offers seat licenses which are machine-specific and tied to a particular computer's locking code, and concurrent licenses which operate on a floating model managed by a central license server.
• How do I set up a license server for concurrent UFT licenses?
  Install the AutoPass License Server on a dedicated machine, configure it with the appropriate number of concurrent licenses, specify the server's name or IP address, and implement proper access controls and firewall rules.
• What is license borrowing and how does it benefit remote workers?
  License borrowing allows users to temporarily check out licenses for offline use, which is particularly valuable for remote workers or those who need to continue testing during network outages.
• How can I optimize UFT license usage in my organization?
  Monitor license utilization rates, implement priority-based allocation, create dedicated license pools for different teams, set usage limits, and consider time-based allocation strategies to distribute demand evenly.
• What should I do if I encounter license connectivity issues?
  Verify that the license server is running and accessible, check firewall settings, confirm the correct server name or IP address is specified in UFT configuration, and ensure required ports are open between clients and the server.