Node-Locked vs. Floating Licenses: Which One Do You Need?

using System;
using System.Threading;
using System.Threading.Tasks;
using PermitCore;

namespace PermitCore.Examples;

public static class FloatingLeaseLifecycle
{
    public static async Task RunAsync(PermitCoreClient client, string licenseKey,
        Func<CancellationToken, Task> protectedWork, CancellationToken stop = default,
        TimeSpan? heartbeatInterval = null)
    {
        var interval = heartbeatInterval ?? TimeSpan.FromMinutes(4);
        if (interval <= TimeSpan.Zero || interval > TimeSpan.FromMinutes(4))
            throw new ArgumentOutOfRangeException(nameof(heartbeatInterval));

        var seat = await client.CheckoutAsync(licenseKey, ct: stop);
        if (!seat.Success || string.IsNullOrWhiteSpace(seat.SessionToken))
            throw new InvalidOperationException("No floating seat was granted.");

        var token = seat.SessionToken;
        using var lease = CancellationTokenSource.CreateLinkedTokenSource(stop);
        Task? work = null;
        try
        {
            var remaining = Remaining(seat);
            lease.CancelAfter(remaining);
            work = protectedWork(lease.Token);
            while (!work.IsCompleted)
            {
                var pause = Task.Delay(remaining / 2 < interval ? remaining / 2 : interval, lease.Token);
                if (await Task.WhenAny(work, pause) == work) break;
                await pause;
                var renewed = await client.HeartbeatAsync(token, lease.Token);
                remaining = Remaining(renewed);
                lease.Token.ThrowIfCancellationRequested();
                lease.CancelAfter(remaining);
            }
            await work;
        }
        finally
        {
            lease.Cancel();
            try
            {
                if (work is not null) await work;
            }
            catch (OperationCanceledException) when (lease.IsCancellationRequested) { }
            finally
            {
                using var cleanup = new CancellationTokenSource(TimeSpan.FromSeconds(5));
                if (!await client.TryCheckinAsync(token, cleanup.Token))
                    Console.Error.WriteLine("Seat return unconfirmed; the last granted deadline still applies.");
            }
        }
    }

    private static TimeSpan Remaining(FloatingSession session)
    {
        if (!session.Success || !session.ExpiresAt.HasValue)
            throw new InvalidOperationException("Floating access could not be renewed.");
        var remaining = session.ExpiresAt.Value.ToUniversalTime() - DateTime.UtcNow;
        if (remaining <= TimeSpan.Zero)
            throw new InvalidOperationException("The floating session deadline has passed.");
        return remaining;
    }
}