Récupération élégante de licence dans une app de bureau
Quand une licence expire, est révoquée ou que le service devient brièvement injoignable, une application de bureau ne doit pas réagir de la même façon aux trois cas. Ce guide construit la machine à états qui dérive l'interface à partir du résultat de vérification, d'une politique de grâce et de l'horloge, pour qu'un client payant sur un réseau instable ne voie jamais l'écran de blocage destiné à une clé révoquée.
Une application de bureau a exactement une tâche quand une licence cesse d’être valide : déterminer pourquoi, et réagir en proportion. L’échec qui est livré encore et encore est un unique if (!license.IsValid) ShowLockout() qui traite un essai expiré, une clé révoquée, un fichier corrompu et une coupure réseau de deux secondes comme le même événement. Le client dont le VPN est tombé un instant obtient le même écran rouge que le client dont la clé a été retirée pour impayé, et le premier ouvre un ticket de support qui dit « votre logiciel m’a bloqué sans raison ».
À retenir : L’UX de récupération est une fonction pure de trois entrées — le résultat de vérification, votre politique de grâce et l’horloge — associées à un petit ensemble d’états, chacun avec sa propre présentation et sa propre action de récupération. Construisez cette association comme un seul réducteur, gardez l’échec transitoire strictement séparé d’un verdict négatif faisant autorité, et le bon écran en découle automatiquement.
La vraie question : de combien de façons « invalide » peut-il signifier quelque chose ?
« Invalide » n’est pas un seul état. Une tentative de vérification peut atterrir dans au moins six endroits matériellement différents, et chacun implique quelque chose de différent à dire et un bouton différent à proposer :
public enum LicenseState
{
Valid, // verified, inside its term
Grace, // tolerated: lapsed-but-recent, or service briefly unreachable
Expired, // past term and past grace; no current entitlement
Revoked, // an authoritative server verdict: this key is dead
Tampered, // signature or clock integrity failed locally
Missing // no key installed yet
}
La coupure importante passe entre les états dont l’utilisateur peut se remettre et ceux dont il ne peut pas. Expired et Missing sont corrigés par la personne au clavier : renouveler, ou coller une clé. Revoked et Tampered ne le sont pas ; la seule action honnête est une voie vers le support. Grace est spécial : rien ne va mal sur quoi l’utilisateur doive agir, donc l’app continue de fonctionner et se répare elle-même. Rassembler tout cela dans une seule branche est ce qui produit le bug de blocage-sur-un-clignotement.
Le mécanisme : un réducteur du résultat vers la vue
Un seul appel de vérification renvoie un résultat, pas un booléen. Modélisez-le, et modélisez les deux modes d’échec — un verdict (le serveur ou la signature a dit non) contre un échec de transport (nous n’avons pas pu demander) — comme des cas distincts, car ils ne doivent pas fusionner.
public abstract record VerifyOutcome
{
public sealed record Ok(LicenseClaims Claims) : VerifyOutcome;
public sealed record Negative(DenyReason Reason) : VerifyOutcome; // signed verdict
public sealed record Unreachable(Exception Cause) : VerifyOutcome; // transport only
}
public enum DenyReason { Expired, Revoked, BadSignature, ClockRollback, NotFound }
Désormais toute la politique de récupération est une fonction pure. Elle prend le résultat, depuis combien de temps nous échouons à joindre le service, le budget de grâce et l’horloge, et renvoie l’état plus tout ce dont l’interface a besoin pour le rendre. Pas d’E/S, pas de minuteries, trivialement testable en unitaire.
public static LicenseView Reduce(
VerifyOutcome outcome,
TimeSpan sinceLastGoodCheck,
GracePolicy policy,
DateTimeOffset now) => outcome switch
{
VerifyOutcome.Ok ok when ok.Claims.NotAfter > now
=> LicenseView.Active(ok.Claims),
// Term elapsed, but still inside the post-expiry grace budget.
VerifyOutcome.Ok ok when now - ok.Claims.NotAfter <= policy.PostExpiry
=> LicenseView.InGrace(ok.Claims, expiresIn: policy.PostExpiry - (now - ok.Claims.NotAfter)),
// We simply could not reach the service: never a lockout while we have grace left.
VerifyOutcome.Unreachable when sinceLastGoodCheck <= policy.Offline
=> LicenseView.InGrace(reason: "Reconnecting…", expiresIn: policy.Offline - sinceLastGoodCheck),
VerifyOutcome.Unreachable
=> LicenseView.Expired(recoverable: true, message: "Offline too long — reconnect to continue."),
// Authoritative negatives. Each gets its own screen and its own action.
VerifyOutcome.Negative n => n.Reason switch
{
DenyReason.Expired => LicenseView.Expired(recoverable: true),
DenyReason.NotFound => LicenseView.Missing(),
DenyReason.Revoked => LicenseView.Blocked(DenyReason.Revoked), // no self-service fix
DenyReason.BadSignature => LicenseView.Blocked(DenyReason.BadSignature),
DenyReason.ClockRollback=> LicenseView.Blocked(DenyReason.ClockRollback),
_ => LicenseView.Blocked(n.Reason),
},
_ => LicenseView.Blocked(DenyReason.NotFound),
};
Lisez l’ordre des cas : un résultat Unreachable ne peut jamais retomber jusqu’à un blocage dur tant qu’il reste de la grâce hors ligne. La seule manière d’atteindre Blocked est un Negative — un verdict signé et sans ambiguïté — ou un signal d’altération. Cette seule règle d’ordonnancement est toute la défense contre le blocage de bons clients sur un mauvais réseau.
Unreachable restent en Grace et guérissent ; seul un verdict négatif signé franchit vers les états de blocage dur à droite.Le brancher à un view-model qui se répare lui-même
Le réducteur est pur, donc le view-model autour est mince : relancer la vérification à une cadence, passer le résultat par Reduce et publier le LicenseView résultant. L’interface se lie à une seule propriété et ne contient jamais de if de licence à elle.
public sealed class LicenseStatusViewModel : INotifyPropertyChanged
{
private LicenseView _view = LicenseView.Checking();
public LicenseView View { get => _view; private set { _view = value; OnChanged(); } }
public async Task RefreshAsync(CancellationToken ct)
{
VerifyOutcome outcome = await _license.VerifyAsync(ct); // local Ed25519 + optional revalidation
if (outcome is VerifyOutcome.Ok ok)
_clockGuard.RecordTrustedTime(ok.Claims.IssuedAt); // advance the high-water mark
View = Reduce(outcome, _clockGuard.SinceLastGood, _policy, DateTimeOffset.UtcNow);
// Heal automatically: while in Grace, keep retrying on a short backoff.
if (View.State == LicenseState.Grace)
_retry.Schedule(() => _ = RefreshAsync(ct));
}
}
_clockGuard est ce qui arrête l’astuce du recul de l’horloge. Il persiste l’horodatage le plus élevé jamais vérifié, et si l’horloge locale en lit un antérieur de plus que la tolérance de décalage, VerifyAsync renvoie Negative(ClockRollback), que le réducteur achemine droit vers Blocked. Pour savoir comment dimensionner cette tolérance face aux changements légitimes d’heure d’été et de fuseaux horaires, voir l’article Keyright sur le clock-skew et la tolérance NotBefore.
Les actions de récupération — une par état, rien de plus
Chaque état autre que Valid expose exactement une action primaire, et l’action correspond à qui peut réellement la corriger :
- Grace — aucun bouton. Un bandeau discret et non modal (« Travail hors ligne — reconnexion… »). L’app se répare sans que l’utilisateur fasse quoi que ce soit.
- Expired — une invite « Renouveler » non bloquante qui ouvre le flux d’achat ou de renouvellement, et un champ « Saisir une nouvelle clé ». L’app reste ouverte ; là où cela a du sens, elle dégrade en lecture seule ou vers la surface gratuite Community Edition au lieu de s’éteindre.
- Missing — l’écran d’activation de premier lancement : collez une clé, appuyez sur vérifier,
RefreshAsyncse relance. - Revoked / Tampered — ce sont les seuls états qui justifient un arrêt dur. Montrez pourquoi en langage clair et une unique voie « Contacter le support ». Pas de champ en libre-service, car l’utilisateur ne peut véritablement pas corriger une clé révoquée lui-même ; l’orienter vers le support est la démarche honnête. La recherche qu’exécute votre équipe de support est le flux pourquoi-est-ce-bloqué.
Notez qu’il n’y a pas de bouton réessayer sur les états de blocage dur. Revérifier une clé révoquée renvoie seulement le même Negative(Revoked) ; proposer « Réessayer » entraîne l’utilisateur à le marteler et à ouvrir un ticket quand même.
Mises en garde : où ça fait mal
Le budget de grâce est un compromis, pas un paramètre gratuit. Trop généreux et un client véritablement expiré tourne pendant des semaines ; trop serré et un portable qui dort un week-end accueille l’utilisateur avec un blocage le lundi. Dimensionnez policy.Offline face à votre schéma d’usage réel — l’article sur la fenêtre de grâce lors de pannes transitoires couvre les calculs.
Dégrader en lecture seule est une décision produit, pas de licence. Le réducteur peut vous dire qu’une licence est Expired ; il ne peut pas vous dire quelles fonctions il est sûr de laisser actives. Cette association vit dans votre couche de droits, et se tromper — laisser un export payant actif après l’expiration — annule tout l’objectif.
Le réducteur n’est honnête que dans la mesure où VerifyAsync l’est. Si la vérification avale un échec de signature et renvoie Unreachable, une clé altérée se cache dans l’état de grâce pour toujours. Les contrôles de signature et d’horloge sont locaux et doivent échouer vers Negative, jamais vers un échec de transport. Gardez cette frontière nette.
Une revalidation en arrière-plan ne doit jamais interrompre le travail. Exécutez RefreshAsync hors du thread d’interface et laissez l’état changer l’habillage — un bandeau, un élément de menu désactivé — plutôt que de lancer un modal par-dessus ce que l’utilisateur est en train de taper.
Conclusion
Traitez la récupération comme une association pure, pas comme une dispersion d’instructions if. Modélisez le résultat de vérification comme Ok / Negative / Unreachable, gardez l’échec de transport strictement hors de la voie de blocage, et réduisez le tout à l’un de six états, chacun avec une présentation et une unique action qui correspond à qui peut la corriger. Faites cela et le client au réseau instable guérit en silence dans Grace tandis que la clé révoquée reçoit l’arrêt qu’elle mérite, et aucun ne voit jamais l’écran de l’autre. La Community Edition de Keyright est une bonne cible de dégradation pour des apps de bureau expirées ; la recette complète de récupération et de droits est dans la documentation Keyright.
Essayez Nebula.NET
Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.