"""Rôles par application — consommation du registre du Hub (HUB-19). Portage Python du pilote ShaarIt 0.7.0 (``src/hub_roles.rs``), contrat D3(a) du plan Hub v2 : à l'ouverture de session draco, Kanbante demande au Hub le niveau du porteur du cookie pour l'application ``kanbante`` — ``GET {hub}/api/roles/kanbante``, en-tête Cookie complet de la requête relayé tel quel, ``Accept: application/json``, délai 2 s → ``{"app", "sub", "role", "explicite", "ttl_secondes": 60}``, rôle ∈ {``aucun``, ``utilisateur``, ``administrateur``}. Cache mémoire par ``sub``, TTL 60 s, sur le patron du cache de révocations de ``app.draco`` : l'horodatage est posé **avant** l'appel — un échec ne déclenche pas de rafale et l'ancien cache reste en vigueur (il resservira aux appels suivants pendant le TTL posé par la tentative). L'URL du Hub est résolue comme celle de la barre commune (``app.config.resoudre_urls_draco`` : variable explicite ``DRACO_HUB_URL`` > hôte public de la requête > dérivation par l'hôte sœur de l'agent > défaut officiel) — jamais d'URL dev figée. **Repli obligatoire** : Hub injoignable, en erreur ou réponse illisible → ``None`` (rôle **inconnu**), et l'appelant garde son comportement actuel. Le registre ne crée jamais un verrouillage nouveau. Depuis la 0.46.11, la consultation transporte aussi le drapeau ``explicite`` de la réponse : le niveau vient-il d'une ligne posée par l'administrateur (``True``), du défaut du registre (``False``), ou la réponse ne le dit-elle pas (``None``) ? Le pont s'en sert pour ne traiter un « aucun » comme un verrouillage que lorsqu'il est explicite ou d'origine inconnue : un « aucun » que le registre présente lui-même comme un défaut n'est pas une décision de l'administrateur et ne doit fermer aucune porte. """ from __future__ import annotations import logging import threading import time import httpx from app.config import resoudre_urls_draco logger = logging.getLogger(__name__) #: Identifiant de Kanbante dans le registre des applications du Hub. APP = "kanbante" #: TTL du cache, aligné sur ``ttl_secondes`` annoncé par le Hub #: et sur le cache de révocations draco. CACHE_TTL = 60.0 # secondes ROLES_CONNUS = ("aucun", "utilisateur", "administrateur") _verrou = threading.Lock() _cache: dict[str, tuple[str, bool | None]] = {} _cache_fetched_at: float = 0.0 def _reset_cache() -> None: """Vide le cache (tests, ou redémarrage de processus).""" global _cache_fetched_at with _verrou: _cache.clear() _cache_fetched_at = 0.0 def _consulter( hub_url: str, cookie: str ) -> tuple[str, bool | None] | None: """Un appel au registre ; ``(rôle, explicite)`` ou ``None``. ``explicite`` vaut ``True`` si le niveau vient d'une ligne posée par l'administrateur, ``False`` s'il vient du défaut du registre, ``None`` si la réponse ne le dit pas (le Hub actuel l'émet toujours). """ url = f"{hub_url.rstrip('/')}/api/roles/{APP}" try: reponse = httpx.get( url, headers={"Cookie": cookie, "Accept": "application/json"}, timeout=2.0, ) except Exception as exc: # Hub injoignable : repli, jamais un blocage logger.debug("Registre des rôles du Hub injoignable (%s) : %s", url, exc) return None if getattr(reponse, "status_code", None) != 200: logger.debug( "Registre des rôles du Hub en erreur (%s) : statut %s", url, getattr(reponse, "status_code", "?"), ) return None try: donnees = reponse.json() except Exception: return None if not isinstance(donnees, dict): return None role = donnees.get("role") if role not in ROLES_CONNUS: return None explicite = donnees.get("explicite") return role, explicite if isinstance(explicite, bool) else None def _detail_pour( cookie: str, sub: str, hote: str | None = None ) -> tuple[str, bool | None] | None: """``(rôle, explicite)`` connus pour ce ``sub``, ou ``None``. ``cookie`` est l'en-tête Cookie complet de la requête, relayé tel quel au Hub ; ``hote`` est l'hôte public de la requête, pour résoudre l'URL du Hub comme la barre commune. Cache partagé par ``role_pour`` et ``explicite_pour`` : une seule consultation par ``sub`` et par TTL. """ global _cache_fetched_at sub = str(sub or "") if not sub: return None now = time.monotonic() with _verrou: if now - _cache_fetched_at < CACHE_TTL and sub in _cache: return _cache[sub] # Horodatage posé avant l'appel (patron révocations) : # l'ancien cache est conservé tel quel pendant l'appel. _cache_fetched_at = now hub_url = resoudre_urls_draco(hote).hub_url resultat = _consulter(hub_url, cookie) if resultat is not None: with _verrou: _cache[sub] = resultat _cache_fetched_at = time.monotonic() else: logger.debug( "Registre des rôles du Hub indisponible (%s/api/roles/%s)" " — comportement actuel conservé", hub_url, APP, ) return resultat def role_pour(cookie: str, sub: str, hote: str | None = None) -> str | None: """Niveau connu pour ce ``sub`` : un rôle ou ``None`` (inconnu).""" detail = _detail_pour(cookie, sub, hote) return detail[0] if detail is not None else None def explicite_pour( cookie: str, sub: str, hote: str | None = None ) -> bool | None: """Le niveau de ce ``sub`` est-il une décision explicite ? ``True`` : ligne posée par l'administrateur dans la matrice du Hub. ``False`` : le registre applique son défaut, aucune décision n'existe pour ce compte. ``None`` : inconnu (Hub injoignable ou réponse sans le drapeau). """ detail = _detail_pour(cookie, sub, hote) return detail[1] if detail is not None else None