Skip to content
← Alle Beiträge
· Delta1 Labs LicensingKeyright

Floating-Sitze, die sich beim Absturz des Clients selbst freigeben

Wie eine selbst gehostete Keyright-Installation eine begrenzte Anzahl gleichzeitiger Sitze vergibt, jeden mit periodischen Heartbeats am Leben hält und den Sitz eines Clients zurückholt, der ohne Rückgabe gestorben ist — samt der echten Races an der Obergrenze, der Uhrenabweichung beim Lease-Ablauf und der Reihenfolge von Heartbeat und Freigabe, mit dem C#, das SDK und Ausgabedienst jeweils ausführen.

Eine Floating-Lizenz ist ein Versprechen mit einem Loch. Sie verkaufen zehn gleichzeitige Sitze, das SDK checkt beim Start der Anwendung brav einen aus, und alles funktioniert, bis zu dem Tag, an dem ein Client-Prozess getötet wird — Stromausfall, erzwungenes Schließen, ein mitten in der Aufgabe geräumter Container —, ohne dem Server je zu sagen, dass er fertig war. Der Sitz, den er hielt, ist nun ein Geist: gegen Ihre Obergrenze gezählt, von niemandem beansprucht und nicht von einem echten Nutzer zu unterscheiden, der einfach weggegangen ist. Tun Sie nichts, und Ihre Zehn-Sitz-Lizenz verhungert langsam, während sich Geister anhäufen. Holen Sie zu gierig zurück, und Sie reißen jemandem den Sitz weg, dessen Laptop nur neunzig Sekunden geschlafen hat.

Die eigentliche Frage ist, wie ein Ausgabedienst eine begrenzte Zahl von Sitzen vergibt und die toten sicher zurückholt, ohne eine dauerhafte Verbindung zu jedem Client und ohne je den lebenden Zählstand über die Obergrenze driften zu lassen. Keyright tut es mit einem Lease: ein Sitz ist kein Flag, das man setzt und löscht, er ist eine kurzlebige Gewährung mit einer Frist, am Leben gehalten durch Heartbeats und durch Ablauf zurückgeholt. Diese eine Entwurfsentscheidung verwandelt eine unbeantwortbare Frage — lebt dieser Client noch? — in eine beantwortbare — wurde dieses Lease kürzlich genug erneuert? Dieser Beitrag zeigt, wie der Lease-Lebenszyklus funktioniert und wo sich die Races verstecken.

Ein Sitz ist ein Lease, kein Flag

Das naive Modell speichert einen Boolean pro Sitz und einen Zählstand. Checkout kippt ein Bit und erhöht; Freigabe kippt es zurück. Es scheitert in dem Moment, in dem ein Client ohne Freigabe stirbt, weil das Bit für immer gesetzt bleibt. Es gibt keinen begrenzten Weg zur Rückholung, nur Heuristiken, die in beide Richtungen falsch liegen.

Das Lease-Modell speichert pro aktivem Sitz einen kleinen Datensatz mit einer Frist:

{
  "leaseId": "lease_7e2a9c",
  "licenseId": "KR-9QX2-7F3M",
  "seatHolder": "host-7e2a9c:pid-4821",
  "issuedAt": "2026-11-21T09:12:04.118Z",
  "expiresAt": "2026-11-21T09:14:04.118Z",
  "renewals": 0
}

Ein Sitz ist genau dann lebendig, wenn ein Lease für ihn existiert und now() vor seinem expiresAt liegt, wie die Dienstuhr urteilt. Das ist die ganze Definition. Ein abgestürzter Client hört auf zu erneuern; sein expiresAt gleitet in die Vergangenheit; der Sitz wird rückholbar, ohne irgendeine spezielle Absturzerkennung irgendwo. Die Frist leistet die Arbeit, die eine Präsenzprüfung per Heartbeat nie könnte, weil sie keine zweite Nachricht braucht, um den Tod zu bestätigen — das Ausbleiben einer Erneuerung ist das Signal.

VERFÜGBAR count < cap GEHALTEN now < expiresAt ERNEUERND Heartbeat verlängert ZURÜCKGEHOLT Sitz frei checkout erneuern ⟳ freigeben Ablauf (kein Heartbeat) ein zurückgeholter Sitz kehrt in den verfügbaren Pool zurück — ein toter Client nimmt die gestrichelte Ablauf-Kante, nicht die Freigabe
Die Lease-Zustandsmaschine. Ein sauberer Ausstieg nimmt die durchgezogene Kante freigeben; ein abgestürzter Client nimmt die gestrichelte Kante Ablauf — dasselbe Ziel, ohne jede Absturzerkennung.

Der Checkout und das Race an der Obergrenze

Beim Checkout wird die Korrektheit gewonnen oder verloren. Die Versuchung ist, ihn in zwei Schritten zu schreiben: die lebenden Leases zählen und, falls unter der Obergrenze, ein neues einfügen. Das ist ein lehrbuchmäßiger Time-of-Check-to-Time-of-Use-Bug. Zwei Clients lesen beide „neun lebendig” und fügen beide den zehnten ein — nun sind elf Sitze gegen eine Obergrenze von zehn belegt.

Der SDK-Aufruf ist bewusst schlicht; die ganze harte Logik liegt auf dem Dienst:

using Keyright.Client;

var seats = new SeatClient(new SeatClientOptions
{
    ServiceUri = new Uri("https://licensing.internal.acme.example"),
    LicenseKey = licenseKey,
    SeatHolder = SeatHolder.ForThisProcess(), // host + pid + boot id
});

// Blocks only on the round-trip; throws SeatCapReachedException on 409.
await using SeatLease lease = await seats.CheckoutAsync(cancellationToken);

// The lease keeps itself alive in the background until disposed.
RunApplication();

Auf dem Dienst ist der Checkout ein einziger atomarer bedingter Schreibvorgang. Er fügt das Lease nur ein, wenn die Zahl der lebenden Leases für diese Lizenz im Augenblick des Schreibens noch unter der Obergrenze liegt — das Zählen und das Einfügen sind eine unteilbare Operation, nicht zwei. Ausgedrückt als das Prädikat, das die Speicherschicht erzwingt:

// Service-side. Runs as ONE atomic operation, serialised per licenseId.
public CheckoutResult Checkout(string licenseId, SeatHolder holder, int cap, TimeSpan ttl)
{
    var now = _clock.UtcNow;

    // Count only leases that are still live by the SERVICE clock.
    // Expired leases do not count — they are reclaimed implicitly here.
    int liveCount = _leases.CountWhere(licenseId, l => l.ExpiresAt > now);

    if (liveCount >= cap)
        return CheckoutResult.CapReached(liveCount, cap);

    var lease = new Lease
    {
        LeaseId   = LeaseId.New(),
        LicenseId = licenseId,
        Holder    = holder,
        IssuedAt  = now,
        ExpiresAt = now + ttl,
    };

    // Commit succeeds ONLY IF liveCount is still < cap at write time.
    // If a racing writer committed first, this returns Conflict and we retry.
    return _leases.InsertIfLiveCountBelow(lease, cap, now)
        ? CheckoutResult.Granted(lease)
        : CheckoutResult.CapReached(cap, cap);
}

Die tragende Zeile ist InsertIfLiveCountBelow. Sie ist ein Compare-and-Set: der Schreibvorgang wird nur akzeptiert, wenn das Lebendzähler-Prädikat, auf das er bedingt war, zum Commit-Zeitpunkt noch gilt. Wenn zwei Anfragen um den letzten Sitz rennen, ordnet die Speicherschicht sie. Die erste sieht neun lebendig und bestätigt den zehnten. Die zweite wird gegen den nun bestätigten Zustand ausgewertet, sieht zehn und wird abgelehnt. Der Verlierer erhält ein CapReached-Ergebnis und nie ein Lease-Token — also glaubt er nie, einen Sitz zu halten. Beachten Sie, dass abgelaufene Leases aus liveCount ausgeschlossen sind, was bedeutet, dass jeder Checkout auch eine implizite Rückholung durchführt: der Geist eines abgestürzten Clients zählt in dem Moment nicht gegen die Obergrenze, in dem seine Frist verstrichen ist.

Client A Client B cap = 10 · live = 9 vor dem Race checkout checkout atomarer Schreibvorgang serialisiert pro Lizenz gewährt (Sitz 10) 409 Obergrenze erreicht
An der Obergrenze fallen die beiden Checkouts in einen serialisierten Schreibvorgang zusammen. Einer bestätigt den letzten Sitz; der andere wird gegen den bestätigten Zustand ausgewertet und abgelehnt — es gibt kein Fenster, in dem beide gelingen.

Die Heartbeats und warum sie bedingt sind

Einmal gewährt, muss das Lease am Leben gehalten werden. Das SeatLease, das CheckoutAsync zurückgibt, besitzt eine Hintergrundschleife, die das Lease zu einem Bruchteil des TTL erneuert — standardmäßig bei jedem Drittel des Wegs, sodass ein Zwei-Minuten-Lease etwa alle vierzig Sekunden erneuert wird. Früh zu erneuern ist keine Verschwendung; es ist der Spielraum, der einen langsamen Timer, eine verzögerte Anfrage oder eine verlorene Erneuerung absorbiert, ohne dass das Lease je wirklich verfällt.

Die entscheidende Eigenschaft ist, dass ein Heartbeat bedingt ist. Er heißt nicht „setze expiresAt auf now + TTL für diesen Sitz”; er heißt „verlängere genau dieses Lease, wenn es noch lebt”. Die Erneuerung trägt die leaseId, und der Dienst verweigert sie, wenn dieses Lease verschwunden ist:

// Service-side renewal. Conditional on the lease still existing AND being live.
public RenewResult Renew(string leaseId, TimeSpan ttl)
{
    var now = _clock.UtcNow;

    // Atomic: extend only if the lease is present and not yet expired.
    bool extended = _leases.ExtendIfLive(leaseId, newExpiry: now + ttl, now: now);

    return extended
        ? RenewResult.Renewed(now + ttl)
        : RenewResult.Lost; // released, revoked, or already swept
}
// SDK-side loop. A lost renewal is surfaced, never swallowed.
private async Task HeartbeatLoop(CancellationToken ct)
{
    var interval = _ttl / 3;
    while (!ct.IsCancellationRequested)
    {
        await Task.Delay(interval, ct);
        var result = await _transport.RenewAsync(_leaseId, ct);
        if (result.Kind == RenewKind.Lost)
        {
            _lostSeat.TrySetResult(); // application observes SeatLost
            return;                   // stop renewing a seat we no longer hold
        }
        _expiresAt = result.NewExpiry;
    }
}

ExtendIfLive ist das Gegenstück zu InsertIfLiveCountBelow: ein weiteres Compare-and-Set, diesmal bedingt darauf, dass das Lease vorhanden und nicht abgelaufen ist. Es schließt das Auferstehungs-Race. Stellen Sie sich eine Erneuerung bereits unterwegs vor, wenn die Anwendung release aufruft, oder ein Administrator den Sitz widerruft. Die Freigabe löscht das Lease; eine Millisekunde später trifft der unterwegs befindliche Heartbeat ein. Ein bedingungsloses „Antippen” würde die Zeile fröhlich neu erzeugen und den lebenden Zählstand mit einem Sitz, den niemand nutzt, über die Obergrenze treiben. Weil die Erneuerung bedingt ist, findet sie kein lebendes Lease zum Verlängern, gibt Lost zurück, und das SDK stoppt die Schleife, statt einen toten Sitz wiederzubeleben.

Freigabe, Ablauf und die Reihenfolge, auf die es ankommt

Ein Sitz kehrt auf zwei Wegen zurück. Der saubere ist die Freigabe: await using entsorgt das SeatLease, das einen letzten Aufruf sendet, der das Lease löscht und den Sitz sofort freigibt — ohne auf eine Frist zu warten. Der verlustbehaftete-aber-sichere ist der Ablauf: ein Client, der nie zur Freigabe kommt (weil er abgestürzt ist), hört einfach auf zu erneuern, und sein Lease verfällt.

Der Ablauf wird faul ausgewertet. Der Dienst lässt keinen Timer pro Lease laufen, der auf das Auslösen wartet; er vergleicht now() mit expiresAt, sooft ein Sitz als Nächstes geprüft wird — beim nächsten Checkout für diese Lizenz (wo abgelaufene Leases aus dem Zählstand ausgeschlossen sind, wie oben) und bei einem periodischen, niederfrequenten Sweep, der verwaiste Zeilen aufräumt, damit der Speicher nicht grenzenlos wächst. Die faule Auswertung hält die Kosten von zehntausend untätigen Leases bei null: nichts wacht für ein Lease auf, um das niemand streitet.

Die Reihenfolge, auf die es ankommt, ist Heartbeat-gegen-Freigabe, und die Regel ist einfach: Freigabe ist ein Löschen, Erneuerung ist eine bedingte Verlängerung, und wer von beiden im Speicher zuerst committet, gewinnt deterministisch. Committet die Freigabe zuerst, findet der spätere Heartbeat kein Lease und gibt Lost zurück. Committet ein Heartbeat zuerst, schiebt er lediglich die Frist um ein TTL hinaus — und die folgende Freigabe löscht das Lease dennoch vollständig und gibt den Sitz frei, egal wie weit die Frist verlängert worden war. Es gibt keine Verschränkung, in der ein Sitz zugleich freigegeben und lebendig endet, weil release sich nicht um die Frist schert und die Erneuerung ein gelöschtes Lease nicht neu erzeugen kann.

Wann das bricht, ehrlich gesagt

Floating-Sitze kaufen Ihnen begrenzte Fairness, nicht Perfektion, und drei Grenzen sind es wert, klar genannt zu werden.

Erstens, das Rückholfenster ist das TTL, und nichts verkürzt es. Ein abgestürzter Client hält seinen Sitz, bis die Frist verstreicht. Das TTL zu wählen ist ein echter Kompromiss: kurze TTLs holen Geister schnell zurück, vervielfachen aber den Heartbeat-Verkehr und bestrafen kurze Netzaussetzer; lange TTLs sind schonend für instabile Verbindungen, lassen aber einen toten Client länger besetzen. Keine Einstellung holt sofort zurück und toleriert einen schlafenden Laptop, denn das ist dieselbe Ungewissheit von zwei Seiten betrachtet.

Zweitens, die Offline-Toleranz ist genau durch dieses Fenster begrenzt. Ein Client, der das Netz verliert, arbeitet weiter, bis sein Lease abgelaufen wäre; verbindet er rechtzeitig wieder, heilt ihn der nächste Heartbeat, verpasst er das Fenster, ist der Sitz weg und muss neu ausgecheckt werden, was fehlschlagen kann, wenn die Obergrenze sich inzwischen gefüllt hat. Floating-Lizenzierung ist keine unbegrenzte Offline-Nutzung — sie ist durch das TTL begrenzte Offline-Nutzung, und das ist ihre ehrliche Gestalt.

Drittens, all das ruht auf der Dienstuhr, und nur der Dienstuhr. Das expiresAt des Clients ist beratend; jede Autorisierungsentscheidung ist der Dienst, der sein eigenes now() mit einer Frist vergleicht, die er gespeichert hat. Das macht die Client-Uhrenabweichung zu einem Nicht-Ereignis — aber es bedeutet auch, dass ein Dienst, dessen eigene Uhr springt, das Einzige ist, was das Lease-Timing verderben kann, weshalb Frist, Erneuerung und Sweep alle eine einzige monotone Dienstuhr lesen statt irgendeines vom Client gelieferten Werts.

Fazit

Der Trick bei Floating-Sitzen ist, sich zu weigern, die unbeantwortbare Frage zu beantworten. Sie können nicht zuverlässig erkennen, dass ein Client abgestürzt ist, also versuchen Sie es nie. Sie vergeben ein Lease mit einer Frist, halten es mit bedingten Heartbeats am Leben und lassen die Abwesenheit zurückholen, was der Tod hinterließ. Die Obergrenze hält, weil der Checkout ein einziger atomarer bedingter Schreibvorgang ist, nie ein Lesen-dann-Schreiben; Sitze erstehen nie wieder auf, weil die Erneuerung auf ein lebendes Lease bedingt ist; und der Ablauf braucht keine Absturzerkennung, weil der fehlende Heartbeat die Erkennung ist. Konfigurieren Sie das TTL nach Ihrer Toleranz gegenüber Geistern versus Ihrer Toleranz gegenüber falschen Rückholungen, verdrahten Sie das await using des SDK so, dass saubere Ausstiege sofort freigeben, und die zehn Sitze, die Sie verkauft haben, bleiben zehn — nicht mehr, und nicht weniger als wirklich lebendig sind. Siehe die Optionen für gleichzeitige Sitze in der Keyright-Dokumentation und das Lizenzmodell auf der Keyright-Produktseite.

Nebula.NET testen

Härten Sie Ihren .NET-Code in wenigen Minuten — starten Sie mit der kostenlosen Edition.