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).
166 lines
5.8 KiB
Python
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
|