Set-OPS-Public/scripts/gabarit_etat.py

#!/usr/bin/env python3
"""Le gabarit dore, face a ce que le SITE declare de lui. Ne corrige rien, regarde.

POURQUOI CE CONTROLE EXISTE (2026-09-01). Le gabarit porte des choix qui NE SE CORRIGENT
PAS APRES COUP — au premier rang, son type de machine.

`q35` (PCIe) et non `i440fx` (PCI, le defaut de Proxmox). Convertir une machine deja
installee d'un chipset a l'autre remplace son materiel sous un systeme qui croit connaitre
le sien : les noms d'interfaces predictibles suivent le chemin PCI et changent, les chemins
de disques bougent, et chaque panne qui s'ensuit ressemble a autre chose qu'a sa cause.
C'est un constat paye en anomalies par l'exploitant, et c'est aussi pourquoi Set-OPS
n'utilise pas l'image cloud officielle de Debian : elle est livree pour `i440fx`.

UNE MACHINE NAIT `q35`, OU ELLE NE LE SERA JAMAIS PROPREMENT.

CE QU'ON VERIFIE, ET POURQUOI ICI PLUTOT QU'AU CLONAGE. La propriete s'HERITE : si le
gabarit est conforme, tous ses clones le sont. Verifier chaque copie coute a chaque
creation et ne dit rien de plus que verifier la source une fois. On regarde donc la SOURCE.

Ce n'est pas une preuve du harnais : elle exigerait le cluster, que `make prouver` ne
suppose pas joignable. C'est un controle a la demande, comme `make genome-etat` et
`make underlay-plan`.

Usage :
  python3 scripts/gabarit_etat.py            # code de sortie 0 si conforme
"""
from __future__ import annotations

import subprocess
import sys
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent))

import underlay as underlay_mod  # noqa: E402

# Ce que l'on compare. `qm config` les rend en `cle: valeur`.
CHAMPS = ("machine", "bios")


def _config_distante(noeud_nom: str, vmid: int) -> dict:
    """`qm config <vmid>` sur l'hyperviseur qui porte le gabarit.

    ON PASSE PAR LE SHELL DU NOEUD, pas par l'API : le poste de l'exploitant l'atteint
    deja (c'est ainsi qu'on lit les configurations de VM depuis toujours), et cela evite
    d'exiger un jeton la ou une lecture suffit.
    """
    hote = _adresse_du_noeud(noeud_nom)
    if not hote:
        raise SystemExit(f"Noeud « {noeud_nom} » introuvable dans l'underlay de l'hebergeur.")
    r = subprocess.run(
        ["ssh", "-o", "ConnectTimeout=8", "-o", "BatchMode=yes",
         f"ansible@{hote}", f"sudo -n qm config {int(vmid)}"],
        capture_output=True, text=True, timeout=60)
    if r.returncode != 0:
        raise SystemExit(f"Lecture impossible sur {noeud_nom} ({hote}) : "
                         f"{(r.stderr or '').strip()[:160]}")
    out = {}
    for ligne in r.stdout.splitlines():
        if ":" in ligne:
            k, _, v = ligne.partition(":")
            out[k.strip()] = v.strip()
    return out


def _adresse_du_noeud(nom: str) -> str:
    """L'adresse de gestion d'un hyperviseur, DERIVEE de l'underlay.

    Jamais ecrite ici : les trois noeuds ne sont pas consecutifs (`.41`, `.43`, `.47`), et
    sonder une adresse plausible est une erreur qu'aucun outil ne rattrape.
    """
    u = underlay_mod.charger()
    for h in underlay_mod.hotes(u):
        if h.get("nom") == nom and h.get("role") == "hyperviseur" \
                and str(h.get("ip", "")).startswith("192.168.11."):
            return str(h["ip"])
    return ""


def main() -> int:
    g = underlay_mod.gabarit()
    if not g:
        print("Le SITE ne declare aucun gabarit (cle `gabarit` de son plan). Rien a comparer.")
        return 0

    vmid, noeud = g.get("vmid"), g.get("noeud")
    if not vmid or not noeud:
        print("Le gabarit declare est incomplet : il lui faut `vmid` et `noeud`.")
        return 1

    cfg = _config_distante(str(noeud), int(vmid))
    print(f"Gabarit {vmid} « {cfg.get('name', '?')} » sur {noeud}")

    ecarts = []
    for champ in CHAMPS:
        attendu = str(g.get(champ, "")).strip()
        if not attendu:
            continue
        reel = cfg.get(champ, "")
        etat = "=" if reel == attendu else "≠"
        print(f"  {champ:<10} declare {attendu:<12} reel {reel or '(absent)':<12} {etat}")
        if reel != attendu:
            ecarts.append(f"{champ} : declare « {attendu} », reel « {reel or 'absent'} »")

    if not str(cfg.get("template", "")).strip() == "1":
        ecarts.append("ce VMID n'est PAS un gabarit (`template: 1` absent) — le cloner "
                      "marcherait, mais il derivera au premier demarrage")

    if ecarts:
        print("\nECART — le gabarit ne porte pas ce que le SITE declare :")
        for e in ecarts:
            print(f"  - {e}")
        print("\n  NE PAS CONVERTIR la machine : changer son chipset apres coup casse les")
        print("  noms d'interfaces et les chemins de disques. REFABRIQUER le gabarit.")
        return 1

    print("\nConforme — le gabarit porte ce que le SITE declare de lui.")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())