Server Application Integration

Server Registration (.NET)

using evoleap.Licensing;
using evoleap.Licensing.Server;
using Newtonsoft.Json;
using System;
using System.IO;
using System.Threading.Tasks;

public class ServerLicensing
{
    private static readonly Guid ProductId = new Guid("00000000-0000-0000-0000-000000000000"); // your product ID
    private static readonly Version AppVersion = new Version(1, 0, 0);

    private readonly string _statePath = Path.Combine(
        Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData),
        "MyServerApp", "elm-server-state.json");

    public ServerControlManager Manager { get; private set; }
    public InstanceIdentity Identity { get; private set; }

    public async Task<bool> InitializeAsync(string licenseKey)
    {
        var publicKey = PublicKeyFile.ReadFrom("elm-public-key.txt");

        Manager = new ServerControlManager(ProductId, AppVersion, publicKey,
            controlStrategy: null, savedState: LoadState()); // savedState is null on first run

        // Host name, CPU identifier, volume hash, IP and MAC addresses
        Identity = new InstanceIdentity().AddAllHardwareKeys();

        if (!Manager.ServerState.Registered)
        {
            RegistrationResult registration = await Manager.RegisterAsync(licenseKey, Identity);
            SaveState(); // failed attempts are recorded in the state as well
            if (!registration.Success)
            {
                Console.Error.WriteLine($"Registration failed: {registration.ErrorMessage}");
                return false;
            }
            Console.WriteLine($"Registered as instance {Manager.ServerState.InstanceId}");
        }

        InstanceValidity validity = await Manager.ValidateInstanceAsync(Identity);
        SaveState();
        return validity.IsValid;
    }

    private IServerState LoadState() =>
        File.Exists(_statePath)
            ? JsonConvert.DeserializeObject<PersistedServerState>(File.ReadAllText(_statePath))
            : null;

    public void SaveState()
    {
        Directory.CreateDirectory(Path.GetDirectoryName(_statePath));
        var json = JsonConvert.SerializeObject(PersistedServerState.From(Manager.ServerState), Formatting.Indented);
        var temp = _statePath + ".tmp";
        File.WriteAllText(temp, json);
        File.Move(temp, _statePath, overwrite: true); // atomic replace
    }
}

The SDK's own ServerState class is internal, so persist a copy through your own IServerState implementation:

using evoleap.Licensing;
using evoleap.Licensing.Desktop;       // OfflineCheckoutInfo
using evoleap.Licensing.Server;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;

public class PersistedServerState : IServerState
{
    // Matches the released IControlState. The unreleased v3.5 SDK adds a CustomData member to it.
    public bool Registered { get; set; }
    public DateTime? RegisteredAt { get; set; }
    public DateTime FirstLaunchTime { get; set; }
    public DateTime? LastSuccessfulValidationTime { get; set; }
    public int LastValidationStatus { get; set; }
    public TimeSpan GracePeriodForValidationFailures { get; set; }
    public Guid InstanceId { get; set; }
    public List<DateTime> FailedRegistrationTimes { get; set; } = new List<DateTime>();
    public List<DateTime> FailedValidationTimes { get; set; } = new List<DateTime>();
    public List<string> Features { get; set; } = new List<string>();
    public List<string> FeatureGroups { get; set; } = new List<string>();
    public List<OfflineCheckoutInfo> OfflineCheckouts { get; set; } = new List<OfflineCheckoutInfo>();

    ReadOnlyCollection<DateTime> IControlState.FailedRegistrationTimes => FailedRegistrationTimes.AsReadOnly();
    ReadOnlyCollection<DateTime> IControlState.FailedValidationTimes => FailedValidationTimes.AsReadOnly();
    ReadOnlyCollection<string> IControlState.Features => Features.AsReadOnly();
    ReadOnlyCollection<string> IControlState.FeatureGroups => FeatureGroups.AsReadOnly();
    ReadOnlyCollection<OfflineCheckoutInfo> IServerState.OfflineCheckouts => OfflineCheckouts.AsReadOnly();

    public static PersistedServerState From(IServerState s) => new PersistedServerState
    {
        Registered = s.Registered,
        RegisteredAt = s.RegisteredAt,
        FirstLaunchTime = s.FirstLaunchTime,
        LastSuccessfulValidationTime = s.LastSuccessfulValidationTime,
        LastValidationStatus = s.LastValidationStatus,
        GracePeriodForValidationFailures = s.GracePeriodForValidationFailures,
        InstanceId = s.InstanceId,
        FailedRegistrationTimes = s.FailedRegistrationTimes.ToList(),
        FailedValidationTimes = s.FailedValidationTimes.ToList(),
        Features = s.Features.ToList(),
        FeatureGroups = s.FeatureGroups.ToList(),
        OfflineCheckouts = s.OfflineCheckouts.ToList()
    };
}

Periodic Validation (.NET)

using evoleap.Licensing;
using System;
using System.Threading;
using System.Threading.Tasks;

public sealed class LicenseMonitor : IDisposable
{
    private readonly ServerLicensing _licensing;
    private readonly SemaphoreSlim _gate = new SemaphoreSlim(1, 1); // the SDK rejects overlapping calls
    private readonly Timer _timer;

    public LicenseMonitor(ServerLicensing licensing)
    {
        _licensing = licensing;
        _timer = new Timer(async _ => await CheckAsync(), null,
            TimeSpan.FromMinutes(30), TimeSpan.FromMinutes(30));
    }

    public async Task<bool> CheckAsync()
    {
        await _gate.WaitAsync();
        try
        {
            InstanceValidity validity = await _licensing.Manager.ValidateInstanceAsync(_licensing.Identity);
            _licensing.SaveState();

            if (validity.IsValid)
            {
                if (validity.IsInValidationFailureGracePeriod)
                    Console.WriteLine($"WARNING: elm unreachable; grace period ends {validity.GracePeriodExpiration:u}");
                return true;
            }

            switch (validity.InvalidReason)
            {
                case InvalidReason.ServiceUnreachable:        // grace period exhausted
                case InvalidReason.LicenseExpired:
                case InvalidReason.InstanceDisabled:
                case InvalidReason.UserTamperingDetected:
                    StopServing(validity.InvalidReason);
                    break;
                case InvalidReason.InconsistentRegistration:  // hardware no longer matches
                case InvalidReason.InstanceNotRegistered:
                    RequestReRegistration(validity.InvalidReason);
                    break;
                default:                                      // ActivationPending, InstanceAlreadyCheckedOut, ...
                    StopServing(validity.InvalidReason);
                    break;
            }
            return false;
        }
        finally
        {
            _gate.Release();
        }
    }

    private void StopServing(InvalidReason reason) { /* drain requests, then stop the host */ }
    private void RequestReRegistration(InvalidReason reason) { /* alert operators */ }

    public void Dispose() => _timer.Dispose();
}

Checking a User Without a Session (Ruby)

entitlement = Rails.cache.fetch("elm:user:#{user.id}", expires_in: 5.minutes) do
  scm.validate_user(user_guid: user.elm_user_guid) # => EvoleapLicensing::UserEntitlement
end

if entitlement.valid?
  entitlement.features        # => ["premium", ...]
  entitlement.feature_groups
  entitlement.custom_data     # => the license's key-value properties
else
  entitlement.invalid_reason  # => :license_expired, :user_disabled, :service_unreachable, ...
  entitlement.error_message
end