License your software with a heartbeat

Step 1: Add Maven Dependency

Add the dependency to your pom.xml:

<dependency>
    <groupId>com.evoleap.licensing</groupId>
    <artifactId>com.evoleap.licensing</artifactId>
    <version>1.1.0</version>
</dependency>

Or for Gradle in build.gradle:

Step 2: Import Classes

Import the necessary licensing classes (note the capitalized sub-packages):

import com.evoleap.licensing.*;                           // identities, results, PublicKeyFile
import com.evoleap.licensing.Utilities.Version;
import com.evoleap.licensing.Desktop.ControlManager;      // For desktop apps
// or
import com.evoleap.licensing.Server.ServerControlManager; // For servers / web apps

Step 3: Initialize Control Manager

Set up your licensing control manager:

// For Desktop Applications
UUID productId = UUID.fromString("your-product-guid");
// Public key file downloaded from the elm portal for your product
PublicKeyFile publicKey = PublicKeyFile.readFrom("path/to/public-key-file");

UserIdentity userIdentity = ActiveDirectoryBasedUserIdentity.getCurrent();
InstanceIdentity instanceIdentity =
    HardwareBasedInstanceIdentity.addAllHardwareKeys(new InstanceIdentity());

ControlManager controlManager = new ControlManager(
    productId,
    new Version("1.0.0"),
    publicKey,
    userIdentity,
    instanceIdentity,
    null,  // controlStrategy (default)
    null,  // savedState from a previous launch
    null   // sessionState from a previous launch
);

Step 4: Register Application

Register with the elm licensing server. The ...Async methods return a com.evoleap.licensing.Utilities.Task<T>, which implements Future<T>:

UserInfo userInfo = new UserInfo("User Name", "user@company.com");
RegistrationResult result = controlManager.registerAsync("YOUR-LICENSE-KEY", userInfo).get();

if (!result.getSuccess()) {
    throw new RuntimeException("Registration failed: " + result.getErrorMessage());
}

Step 5: Implement Session Validation

Add licensing validation to your application flow:

SessionValidity sessionValidity = controlManager.validateSessionAsync(null).get();

if (!sessionValidity.getIsValid()) {
    throw new SecurityException("License invalid: " + sessionValidity.getInvalidReason());
}

// Features enabled on the license: controlManager.getValidationState().getFeatures()

// Run your application
runYourApplication();

// Clean up session
controlManager.endSessionAsync().get();

Step 1: Install the Package

Install the elm licensing package (Python 3; depends on pycryptodome and pytz):

Or add to requirements.txt:

Step 2: Import Modules

Import the necessary licensing modules:

from evoleap_licensing.desktop.ControlManager import ControlManager  # Desktop apps only

from evoleap_licensing.UserInfo import UserInfo
from evoleap_licensing.UserIdentity import UserIdentity
from evoleap_licensing.InstanceIdentity import InstanceIdentity, InstanceIdentityValue
from uuid import UUID, getnode
import os
import socket

Step 3: Setup Control Manager

Initialize your licensing control manager. The Python SDK has no built-in hardware fingerprinting, so you build the instance identity from values you choose:

# For Desktop Applications
product_id = UUID('your-product-guid')
with open('public-key.pem') as f:
    public_key = f.read()  # PEM text of your product's public key

# POSIX example; see "Creating User Identities" below for Windows
user_identity = UserIdentity({'uid': str(os.getuid())})
instance_identity = InstanceIdentity({
    'mac': InstanceIdentityValue(format(getnode(), '012x')),
    'hostname': InstanceIdentityValue(socket.gethostname(), case_sensitive=False),
})

control_manager = ControlManager(
    product_id,
    "1.0.0",
    public_key,
    user_identity,
    instance_identity
    # optional: strategy=..., saved_state=..., session_state=...
)

Step 4: Register Your Application

Register the application instance:

if not control_manager.State.Registered:
    user_info = UserInfo("User Name", "user@company.com")
    registration_result = control_manager.Register("YOUR-LICENSE-KEY", user_info)

    if not registration_result.Success:
        raise Exception(f"Registration failed: {registration_result.ErrorMessage}")

# Persist control_manager.State securely (encrypted) and pass it back as saved_state next time

Step 5: Add Session Validation

Implement licensing validation in your application:

session_validity = control_manager.ValidateSession()

if not session_validity.IsValid:
    raise PermissionError(f"License invalid: {session_validity.InvalidReason}")

features = control_manager.State.Features

# Your application logic
run_your_application()

# Clean up session
control_manager.EndSession()

Step 1: Install the Package

Install via npm:

Or add to package.json:

{
  "dependencies": {
    "evoleap-licensing": "^0.7.108"
  }
}

Step 2: Import the Module

The package exports the server, user, hardware, instance and state namespaces:

// ES Modules / TypeScript
import * as elm from 'evoleap-licensing';

// CommonJS
const elm = require('evoleap-licensing');

Step 3: Initialize Control Manager

Set up the server control manager and the server's instance identity:

const fs = require('fs');

const productId = 'your-product-guid';
const version = '1.0.0';
const publicKey = fs.readFileSync('public-key.pem', 'utf8');

// Initial server state; afterwards, persist scm.state and restore it here
const initialServerState = {
    registered: false,
    registeredAt: '',
    failedRegistrationTimes: [],
    failedValidationTimes: [],
    featureGroups: [],
    features: [],
    firstLaunchTime: '',
    gracePeriodForValidationFailures: 0,
    instanceId: '',
    lastSuccessfulValidationTime: '',
    lastValidationStatus: 0,
};

let scm = elm.server.getServerControlManager(productId, version, publicKey, initialServerState);

// Host name, CPU id, volume hash and network info (Node.js)
const instanceIdentity = await elm.hardware.addAllHardwareKeys({
    Version: 1,
    MaximumMismatchCount: 1,
    Values: new Map(),
});

Step 4: Register Server Instance

Register your server with elm:

const registration = await elm.server.registerServer('YOUR-LICENSE-KEY', scm, instanceIdentity);

if (!registration.success) {
    throw new Error(`Registration failed: ${registration.message}`);
}
scm = registration.state; // persist scm.state

const instanceValidity = await elm.server.validateInstance(scm, instanceIdentity);
if (!instanceValidity.isValid) {
    throw new Error(`Instance invalid: ${elm.state.InvalidReason[instanceValidity.InvalidReason]}`);
}
scm = instanceValidity.state;

Step 5: Implement Session Validation

Register each user once, then validate a session for them:

// Identity of the signed-in user, from your own authentication system
const userIdentity = { version: 1, data: new Map([['accountId', String(account.id)]]) };

let ucm = elm.user.getUserControlManager(scm.state.instanceId, scm);
// For a returning user, restore their saved state:
// elm.user.getUserControlManager(scm.state.instanceId, scm, savedUserState, savedSessionState)

const userRegistration = await elm.user.register(
    ucm,
    { name: account.name, email: account.email, additionalData: new Map() },
    userIdentity
);
ucm = userRegistration.state;

const sessionValidity = await elm.user.validateSession(ucm, userIdentity);
if (!sessionValidity.isValid) {
    throw new Error(`License invalid: ${elm.state.InvalidReason[sessionValidity.InvalidReason]}`);
}
ucm = sessionValidity.state; // persist ucm.state and ucm.sessionState for this user

const features = ucm.state.features;

// End the session when the user signs out
ucm = await elm.user.endSession(ucm);

Step 1: Install via vcpkg

The evoleap-licensing port (Windows x64, MSBuild) is published in evoleap's own vcpkg registry, not the public vcpkg catalog. Add the registry to vcpkg-configuration.json:

{
  "registries": [
    {
      "kind": "git",
      "repository": "https://github.com/evoleap/vcpkg-registry",
      "baseline": "<latest commit of evoleap/vcpkg-registry>",
      "packages": [ "evoleap-licensing" ]
    }
  ]
}

Then add the dependency to your vcpkg.json manifest:

The port installs the headers and the evoleap.licensing library; with Visual Studio's vcpkg manifest integration they are picked up automatically.

Step 2: Include Headers

Include the necessary licensing headers:

#include "ControlManager.h"
#include "UserInfo.h"
#include "UserIdentity.h"
#include "ActiveDirectoryBasedUserIdentity.h"
#include "InstanceIdentity.h"
#include "HardwareBasedInstanceIdentity.h"
#include "PublicKeyFile.h"
#include "Version.h"

#include <iostream>
#include <string>

Step 3: Initialize Control Manager

Set up your licensing control manager:

// For Desktop Applications
uuids::uuid productId = uuids::uuid::from_string("your-product-guid").value();
Version version("1.0.0");

// Contents of the public key file downloaded from the elm portal
PublicKeyFile* publicKey = PublicKeyFile::Create(publicKeyText);

// Current Windows / Active Directory user
UserIdentity userIdentity = ActiveDirectoryBasedUserIdentity::GetCurrent();

// Host name, CPU id, volume hash and network info
InstanceIdentity instanceIdentity;
HardwareBasedInstanceIdentity::AddAllHardwareKeys(instanceIdentity);

// Create control manager (optional: ControlStrategy*, saved IValidationState*, IValidatedSessionState*)
ControlManager controlManager(
    productId,
    version,
    publicKey,
    userIdentity,
    instanceIdentity
);

Step 4: Register Application

Register your application with elm:

UserInfo userInfo("User Name", "user@company.com");
auto registrationResult = controlManager.Register("YOUR-LICENSE-KEY", userInfo);

if (!registrationResult.get_Success()) {
    std::cerr << "Registration failed: " << registrationResult.get_ErrorMessage() << std::endl;
    return -1;
}

std::cout << "Registration successful!" << std::endl;

Step 5: Implement Session Validation

Add licensing validation to your application:

SessionValidity sessionValidity = controlManager.ValidateSession();

if (!sessionValidity.IsValid) {
    std::cerr << "License invalid: " << sessionValidity.InvalidReason << std::endl;
    return -1;
}

std::cout << "License is valid!" << std::endl;

// Your application logic here
runYourApplication();

// End session
bool endResult = controlManager.EndSession();
if (endResult) {
    std::cout << "Session ended successfully" << std::endl;
}

Step 1: Install the Gem

Add the gem to your Gemfile (the library file is evoleap_licensing, so tell Bundler what to require):

gem "evoleap-licensing", require: "evoleap_licensing"

Or install it directly:

Step 2: Require and Configure

For example in config/initializers/evoleap_licensing.rb:

require "evoleap_licensing"

EvoleapLicensing.configure do |config|
  config.host = "https://elm.evoleap.com"  # default
  config.timeout = 60                       # HTTP timeout in seconds
end

Step 3: Register the Server Instance

Do this once per deployment and persist the server state:

public_key = File.read(Rails.root.join("config", "elm_public_key.pem"))

scm = EvoleapLicensing::ServerControlManager.new(
  product_id: "your-product-guid",
  version: "1.0.0",
  public_key: public_key
)

identity = EvoleapLicensing::InstanceIdentity.from_hardware
result = scm.register(license_key: "YOUR-LICENSE-KEY", instance_identity: identity)

if result.success?
  File.write("config/server_state.json", scm.server_state.to_h.to_json)
else
  raise "Registration failed: #{result.error_message}"
end

Step 4: Register Users

When a user first uses your application:

server_state = EvoleapLicensing::ServerState.new(JSON.parse(File.read("config/server_state.json")))

ucm = EvoleapLicensing::UserControlManager.new(
  product_id: "your-product-guid",
  version: "1.0.0",
  instance_id: server_state.instance_guid,
  public_key: public_key
)

user_identity = EvoleapLicensing::UserIdentity.new("uid" => current_user.id.to_s)
result = ucm.register(
  user_info: { name: current_user.name, email: current_user.email },
  user_identity: user_identity
)
current_user.update!(elm_user_state: ucm.user_state.to_h.to_json) if result.success?

Step 5: Validate Sessions

On each request (for example in a before_action), restore the user's state and validate:

ucm = EvoleapLicensing::UserControlManager.new(
  product_id: "your-product-guid",
  version: "1.0.0",
  instance_id: server_state.instance_guid,
  public_key: public_key,
  user_state: EvoleapLicensing::UserState.new(JSON.parse(current_user.elm_user_state)),
  session_state: EvoleapLicensing::SessionState.new(session[:elm_session_state])
)

validity = ucm.validate_session(user_identity: user_identity)
if validity.valid?
  current_user.update!(elm_user_state: ucm.user_state.to_h.to_json)
  session[:elm_session_state] = ucm.session_state.to_h

  features = ucm.session_state.features
else
  handle_license_failure(validity.invalid_reason)  # e.g. :license_expired, :no_seats_available
end