Files
kanbante/app/hub_roles.py
T
Spark 7b0fee43d2
CI / test (pull_request) Failing after 1s
CI / test (push) Failing after 3m40s
fix(sso): aucune sortie nue au pont, « aucun » seulement si décidé, pont inerte signalé (0.46.11)
Ronde 2 du cas « bruno » : la 0.46.10 déployée, le bouton SSO
ramenait toujours au formulaire nu. Reproduction en pile de
chaque état candidat : la seule variante au symptôme identique
est DRACO_SESSION_SECRET absent du conteneur — draco inerte,
claims toujours None, sortie « jeton absent » vers /login nu,
bouton SSO rendu quand même.

- Pont : jeton absent → draco=absent ; cookie présent + service
  inerte → draco=inactif ; sub vide → draco=invalide. Le
  middleware signale de même une page demandée avec un cookie
  présent mais inutilisable. Relier sans session → draco=echec.
- Registre des rôles : hub_roles transporte le drapeau
  « explicite » (explicite_pour, cache partagé) ; le pont ne
  refuse un « aucun » que s'il est explicite ou d'origine
  inconnue — un défaut du registre ne verrouille plus l'entrée.
- Tests : contrats des sorties nues mis à jour (le cas réel du
  conteneur sans secret est test_pont_inerte_sans_secret),
  rôle aucun dans ses trois états, drapeau transporté.
  Suite complète : échecs identiques à l'arbre vierge (23).
2026-11-16 21:15:04 +00:00

166 lines
5.8 KiB
Python

"""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