Skip to content
← Todas las publicaciones
· Delta1 Labs LicensingKeyright

Recarga en caliente de mejoras de licencia

Un cliente renueva o mejora su plan a media jornada y tu servicio sigue sirviendo el plan antiguo hasta que alguien lo reinicia. Este artículo conecta el estado de licencia de Keyright con la infraestructura de tokens de cambio e IOptionsMonitor de .NET para que un plan ampliado se propague a cada compuerta, worker y política en caché en cuanto el SDK lo detecta — sin reinicio, sin sondeo en tu código de compuerta — manteniendo la caducidad por tiempo como una decisión por llamada, no como un cambio de configuración.

Un cliente mejora de Standard a Pro a las 2 de la tarde, o renueva una suscripción caducada, o compra el complemento de exportación programada. Su licencia ahora es más amplia que esta mañana. Tu servicio, en marcha desde el último despliegue, no lo sabe. Sigue devolviendo 402 en el endpoint de exportación que el cliente acaba de pagar, mantiene el worker en segundo plano inactivo, sigue aplicando el tope de asientos antiguo — hasta que alguien reinicia el proceso y lee la licencia de nuevo al arrancar. “Compra la mejora y luego reinicia la aplicación” es una mala frase para un correo de confirmación de compra.

La solución habitual es releer la licencia en cada petición, y para una decisión de compuerta eso es correcto: quieres detectar la caducidad en el instante en que ocurre, así que la comprobación de autorización debería evaluar la licencia por llamada. Pero no todos los consumidores de una licencia están ligados a una petición. Un worker en segundo plano que debe arrancar cuando el cliente gana una entitlement no tiene ninguna petición de la que colgar una comprobación. Un pool de conexiones dimensionado a un límite de asientos con licencia se construye una sola vez. Una política de autorización compilada está en caché. Estos son consumidores push — necesitan que se les avise, una vez, cuando el plan cambia — y sondear la licencia desde cada uno de ellos es la forma equivocada.

Conclusión clave: Modela el plan de licencia — lo que la licencia concede — como un IOptionsMonitor<LicensePlan>, reconstruido a partir del Validate() sin conexión del SDK. Impulsa su token de cambio desde un bucle de RefreshAsync en segundo plano que solo señaliza cuando el plan realmente se amplía o se reduce. Entonces cada consumidor push se suscribe con OnChange y reacciona a una renovación o mejora sin reinicio, mientras las compuertas ligadas a petición siguen evaluando la caducidad por llamada. La concesión es configuración recargada en caliente; si la concesión está activa ahora sigue siendo una decisión por llamada.

Los dos relojes de una licencia

Una licencia lleva dos clases de estado que cambian en relojes completamente distintos. La concesión — edición, el conjunto de entitlements, límites numéricos — cambia solo cuando cambia el lease: una renovación, una mejora, una revocación. Eso es un evento discreto y raro. La activación en un instante — ¿está esta entitlement pasada su caducidad ahora mismo, está el lease dentro de su ventana de gracia? — cambia continuamente con el reloj de pared y se vuelve a derivar en cada llamada.

Confundirlos es el error. Si recargas toda la licencia como configuración en un temporizador, detectas la caducidad tarde (cuando el temporizador vuelva a hacer tick) y recargas constantemente para nada. Si solo lees por petición, tus consumidores no ligados a petición nunca se enteran de una mejora. El diseño limpio dirige cada reloj a la infraestructura construida para él: la concesión discreta pasa por la maquinaria de tokens de cambio de .NET, y la activación continua sigue siendo un Validate() por llamada.

Bucle de refrescoRefreshAsync ~15 minLicenseChangeSignalse dispara al cambiarIOptionsMonitor<LicensePlan>recalcula + cambia cachéSupervisor workerPool por asientosCompuertasOnChange — sin reinicioValidate() por llamadacaducidad al instante — sin tokenreloj de tiempo

Modelar la concesión como opciones

LicensePlan es una clase de opciones corriente que describe lo que la licencia concede. A propósito no guarda ningún estado por instante — ningún indicador de “activa ahora” — porque esos pertenecen al otro reloj.

public sealed class LicensePlan
{
    public string Edition { get; set; } = "Community";
    public IReadOnlySet<string> Entitlements { get; set; } = ImmutableHashSet<string>.Empty;
    public IReadOnlyDictionary<string, int> Limits { get; set; } = ImmutableDictionary<string, int>.Empty;

    public bool Grants(string entitlement) => Entitlements.Contains(entitlement);
    public int Limit(string name) => Limits.TryGetValue(name, out var v) ? v : 0;
}

Un IConfigureOptions<LicensePlan> lo construye a partir del Validate() sin conexión del SDK. Esta es la factoría que IOptionsMonitor ejecuta en el primer acceso y vuelve a ejecutar cada vez que se dispara el token de cambio del plan.

public sealed class ConfigureLicensePlan(IKeyrightClient client) : IConfigureOptions<LicensePlan>
{
    public void Configure(LicensePlan plan)
    {
        LicenseInfo info = client.Validate();          // local, offline, no network
        plan.Edition      = info.Edition;
        plan.Entitlements = info.Entitlements.ToImmutableHashSet();
        plan.Limits       = info.Limits;
    }
}

Fíjate en lo que lee Configure: el conjunto de entitlements que la licencia lleva y los límites numéricos, no si cada una está sin caducar en este segundo. La concesión es el techo.

El token de cambio que se dispara en un cambio de plan

La pieza que hace reactivo a IOptionsMonitor es un IOptionsChangeTokenSource<LicensePlan>. Su cometido es entregar un IChangeToken en el que el monitor se registra; cuando disparamos ese token, el monitor descarta su LicensePlan en caché, lo reconstruye con la factoría e invoca cada listener de OnChange. Respaldamos el token con un CancellationTokenSource intercambiable.

public sealed class LicenseChangeSignal
{
    private CancellationTokenSource _cts = new();

    public IChangeToken Token => new CancellationChangeToken(_cts.Token);

    public void Signal()
    {
        // Instala una fuente nueva para el PRÓXIMO token, luego cancela la que tienen los consumidores.
        CancellationTokenSource stale = Interlocked.Exchange(ref _cts, new CancellationTokenSource());
        stale.Cancel();      // dispara todo token ya entregado
        stale.Dispose();
    }
}

public sealed class LicensePlanChangeTokenSource(LicenseChangeSignal signal)
    : IOptionsChangeTokenSource<LicensePlan>
{
    public string Name => Options.DefaultName;
    public IChangeToken GetChangeToken() => signal.Token;
}

El orden en Signal() es la parte sutil. El monitor sostiene un token creado sobre el _cts actual. Primero intercambiamos una fuente totalmente nueva en _cts, luego cancelamos la antigua — disparando el token que el monitor sostiene. El monitor reacciona volviendo a llamar a GetChangeToken(), que ahora devuelve un token sobre la nueva fuente, así que queda rearmado para el próximo cambio. Esta es la misma forma que usa el propio ConfigurationChangeTokenSource del framework para las recargas de appsettings.json.

Conéctalo todo al arrancar:

builder.Services.AddSingleton<LicenseChangeSignal>();
builder.Services.AddSingleton<IConfigureOptions<LicensePlan>, ConfigureLicensePlan>();
builder.Services.AddSingleton<IOptionsChangeTokenSource<LicensePlan>, LicensePlanChangeTokenSource>();
builder.Services.AddOptions<LicensePlan>();   // habilita IOptionsMonitor<LicensePlan>

Señalizar solo ante un cambio real

El bucle en segundo plano es la única parte que habla con la red. Refresca el lease en un intervalo y señaliza el token solo cuando la huella del plan realmente se mueve — de lo contrario cada refresh reconstruiría las opciones sin necesidad y despertaría a cada suscriptor.

public sealed class LicenseRefreshLoop(
    IKeyrightClient client, LicenseChangeSignal signal, ILogger<LicenseRefreshLoop> log)
    : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        string current = Fingerprint(client.Validate());
        using var timer = new PeriodicTimer(TimeSpan.FromMinutes(15));

        while (await timer.WaitForNextTickAsync(ct))
        {
            await client.RefreshAsync(ct);         // en línea si es accesible, si no lease en caché
            string next = Fingerprint(client.Validate());
            if (next == current) continue;         // misma concesión — no molestar a nadie

            current = next;
            signal.Signal();                       // ← una llamada se propaga a cada consumidor
            log.LogInformation("Plan de licencia cambiado; recargado en sitio sin reinicio.");
        }
    }

    static string Fingerprint(LicenseInfo i) =>
        $"{i.Edition}|{string.Join(',', i.Entitlements.Order())}|{i.Limit("seats")}";
}

RefreshAsync se degrada con elegancia: cuando el servicio emisor es brevemente inaccesible sirve el lease en caché, así que un parpadeo de red nunca cambia el plan. La huella excluye a propósito las marcas de caducidad — un plan cuyo único cambio es “un minuto más cerca de caducar” no es un cambio de plan.

Consumir el plan recargado en caliente

Un consumidor push se suscribe una vez y converge hacia el plan que reciba. Aquí un supervisor arranca o detiene un worker de exportación en segundo plano según la entitlement va y viene — el comportamiento que hace que una mejora surta efecto sin reinicio.

public sealed class ExportWorkerSupervisor : IHostedService
{
    private readonly IDisposable? _subscription;
    private readonly ExportWorker _worker;

    public ExportWorkerSupervisor(IOptionsMonitor<LicensePlan> plan, ExportWorker worker)
    {
        _worker = worker;
        Apply(plan.CurrentValue);                 // estado inicial al arrancar
        _subscription = plan.OnChange(Apply);     // cada recarga posterior
    }

    private void Apply(LicensePlan plan)          // idempotente: converge, no alternes
    {
        if (plan.Grants("acme.scheduled-export")) _worker.Enable();
        else                                       _worker.Disable();
    }

    public Task StartAsync(CancellationToken ct) => Task.CompletedTask;
    public Task StopAsync(CancellationToken ct)  { _subscription?.Dispose(); return Task.CompletedTask; }
}

Una compuerta ligada a petición lee CurrentValue para la concesión pero sigue evaluando la caducidad por llamada — aquí es donde se encuentran los dos relojes.

public sealed class ExportEndpoint(IOptionsMonitor<LicensePlan> plan, IKeyrightClient license)
{
    public IResult Handle(ExportRequest req)
    {
        // Barato: ¿concede el plan esto en absoluto? Recargado en sitio al mejorar.
        if (!plan.CurrentValue.Grants("acme.export"))
            return Results.StatusCode(StatusCodes.Status402PaymentRequired);

        // Por llamada: concedido, pero ¿está activo ahora mismo? Capta la caducidad al segundo.
        if (!license.Validate().IsEnabled("acme.export"))
            return Results.StatusCode(StatusCodes.Status402PaymentRequired);

        return Results.Ok(RunExport(req));
    }
}

Si eliminas la segunda comprobación, una entitlement que caducó al mediodía seguiría pasando hasta que el próximo refresh registrara un cambio en la huella — cosa que, para una caducidad simple, nunca haría, porque la caducidad no es un cambio de concesión. La concesión te dice el techo; el Validate() por llamada te dice si estás por debajo de él en este instante.

Advertencias y cuándo se rompe

La caducidad no es un evento de configuración. El error más común es intentar que el plan se recargue en el segundo exacto en que una entitlement caduca. No puede: el token de cambio se dispara ante cambios discretos del lease, y un reloj que avanza con regularidad no produce ninguno. Mantén las decisiones por tiempo por llamada.

OnChange puede dispararse más de una vez. IOptionsMonitor aplica debounce pero no promete entrega exactamente-una-vez, y dos fuentes de token pueden dispararse muy seguidas. Por eso Apply recalcula el estado deseado a partir del plan en vez de alternar — habilitar un worker ya habilitado debe ser una operación nula.

Libera la suscripción. OnChange devuelve un IDisposable; una suscripción capturada que sobrevive a su objetivo gotea y sigue disparándose contra un objeto muerto. Libérala en StopAsync o en el IDisposable contenedor.

Las opciones scoped son instantáneas por petición. Inyecta IOptionsMonitor<LicensePlan>, no IOptions<LicensePlan>. IOptions se resuelve una vez y nunca se actualiza; IOptionsSnapshot es scoped y recalcula por petición pero no tiene OnChange. Solo el monitor te da tanto un valor actual como la callback push.

Una degradación también es un cambio de plan. La señalización se dispara ante cualquier movimiento de la huella, incluida una revocación que colapsa la licencia a Community Edition. Eso es correcto y deseable — la misma maquinaria que enciende una función de pago al mejorar la apaga al revocar, en sitio, sin esperar a un reinicio. Asegúrate de que tus manejadores Apply fallan de forma cerrada ante el plan reducido.

Conectar el estado de licencia con el sistema de opciones es una pequeña cantidad de código que compra una propiedad real: un cliente que mejora ve la mejora surtir efecto en el proceso en marcha, y un cliente cuya licencia caduca pierde el acceso por el mismo camino, con la concesión discreta en el reloj de tokens de cambio y la activación continua en el reloj por llamada. Para el modelo de capacidades que lleva el plan, consulta entitlements y feature flags; para mantener la verificación de firma fuera de la ruta caliente bajo todo esto, consulta cachear la verificación de licencia; y para cómo una renovación llega al SDK en primer lugar, consulta convertir una prueba en licencia de pago.

Prueba Nebula.NET

Endurece tu código .NET en minutos — empieza con la edición gratuita.