Daniel Allaire
0854b2a93c
Some checks are pending
verifier / verifier (push) Waiting to run
Chezlepro detruite (15 VM, disques compris) et refaite depuis le gabarit minimal. 15/15 hotes, 0 echec ; make valider passe, test de restitution compris. Aucun defaut ne venait de la flotte ni du gabarit. 1. Un avertissement n est pas un echec. Proxmox rend WARNINGS: n pour une tache ABOUTIE ; la garde n acceptait que OK et declarait perdues cinq VM clonees a 100 pourcent. Le message parlait d etat stopped — celui de la TACHE, pas de la VM. 2. client_artefacts se contredisait : son commentaire disait de degrader, son code arretait. L autorite monte en premier, donc avant le cache du locataire : aucun ordre ne pouvait satisfaire la garde. 3. harden-below-nxdomain etendait le NXDOMAIN signe de la racine pour le TLD internal a toute la zone du site, sans jamais interroger l autoritatif. Declencheur : toute question sur un nom absent sous internal, y compris la zone d un autre locataire. Le cache contenait la bonne reponse ET un message negatif ; c est le negatif qui etait servi. aggressive-nsec: no avait semble marcher — c est le redemarrage qui vidait le cache, pas le reglage. 4. Un locataire doit savoir a qui demander la zone de son hebergeur, sans quoi il ne peut plus nommer son depot de sauvegarde. La derivation prenait dns_amorcage pour le resolveur du site : faux chez Technolibre, dont l amorcage est 9.9.9.9. P03 l a attrape avant tout deploiement. Au passage : instancier tentait encore le mot de passe unique d avant la separation des voutes ; comparer echouait en exit 4. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_019f91zs9SDdwSzL2CVei6on
459 lines
22 KiB
Python
459 lines
22 KiB
Python
#!/usr/bin/env python3
|
|
"""Generateur d'inventaire Set-OPS (Phase 3) : plan -> hosts.yml.
|
|
|
|
NON destructif : ecrit hosts.genere.yml a cote de l'inventaire de l'instance et compare
|
|
SEMANTIQUEMENT (via ansible-inventory --list) avec l'inventaire actuel. Aucune
|
|
bascule tant que la comparaison n'est pas vide et validee.
|
|
|
|
Derivation :
|
|
- host vars : ansible_host/ansible_user + proxmox_* (IP/VMID/VLAN/passerelle
|
|
derives de la nomenclature ; placement/taille depuis instance/plan/serveurs.yml) ;
|
|
- groupes : socle (serveur_debian/durcis) + groupes de service derives des
|
|
applications de l'hote + groupe d'etat (hotes_actifs/hotes_planifies).
|
|
- Les integrations client_* : les universelles viennent de la POLITIQUE du role
|
|
(roles/client_*/meta/integration.yml), les facultatives de la liste du plan.
|
|
Voir inventory_rules.integrations_de() — source unique des trois lecteurs
|
|
(inventaire, voute, GUI).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
|
|
import json
|
|
import subprocess
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
import yaml
|
|
|
|
import underlay as underlay_mod # noqa: E402
|
|
from devis_sdn import vnet_de # noqa: E402
|
|
from inventory_rules import (
|
|
charger_applications,
|
|
charger_domaines,
|
|
charger_nomenclature,
|
|
charger_serveurs,
|
|
deriver_nomenclature,
|
|
deriver_ressources,
|
|
expositions_des_applications,
|
|
fonction_seq,
|
|
integrations_de,
|
|
integrations_universelles,
|
|
instance_courante,
|
|
inventaire_de,
|
|
liens_acceptes,
|
|
supernet_de,
|
|
)
|
|
|
|
RACINE = Path(__file__).resolve().parents[1]
|
|
ROLES = RACINE / "roles"
|
|
INSTANCE = instance_courante()
|
|
|
|
|
|
INVENTAIRE = inventaire_de(INSTANCE)
|
|
GENERE = INVENTAIRE.with_name("hosts.genere.yml")
|
|
FICHIER_SERVEURS = INSTANCE / "plan/serveurs.yml"
|
|
FICHIER_APPLICATIONS = INSTANCE / "plan/applications.yml"
|
|
FICHIER_NOMENCLATURE = INSTANCE / "plan/nomenclature.yml"
|
|
FICHIER_DOMAINES = INSTANCE / "plan/domaines.yml"
|
|
|
|
GROUPES_SOCLE = ["serveur_debian", "serveur_durci"]
|
|
PLACEMENT = [("noeud", "proxmox_noeud"), ("stockage", "proxmox_stockage"),
|
|
("disque", "proxmox_disque_taille"), ("memoire", "proxmox_memoire"),
|
|
("coeurs", "proxmox_coeurs")]
|
|
|
|
|
|
# --- Bindings (liens) : relations declaratives entre applications -----------------
|
|
# Une application declare ses 'liens' ([{vers, role}]) dans plan/applications.yml ;
|
|
# chaque role decrit les liens qu'il accepte dans roles/<groupe>/meta/liens.yml
|
|
# (setops_liens.accepte). instancier resout la cible (FQDN interne derive) et injecte
|
|
# les variables en host_vars du consommateur. Cf. docs/bindings-conception.md.
|
|
|
|
def _domaine_interne() -> str:
|
|
"""Lit domaine_interne dans group_vars/all de l'instance (keystone, non chiffre)."""
|
|
base = INVENTAIRE.parent / "group_vars" / "all"
|
|
if base.is_dir():
|
|
for fichier in sorted(base.glob("*.yml")):
|
|
try:
|
|
data = yaml.safe_load(fichier.read_text(encoding="utf-8")) or {}
|
|
except yaml.YAMLError:
|
|
continue
|
|
if isinstance(data, dict) and str(data.get("domaine_interne", "")).strip():
|
|
return str(data["domaine_interne"]).strip()
|
|
return ""
|
|
|
|
|
|
|
|
def _zones_deleguees() -> list:
|
|
"""La zone de l'HEBERGEUR, et l'adresse a qui la demander. [] si aucune carte.
|
|
|
|
POURQUOI CETTE DERIVATION EXISTE (mesure du 2026-09-02, reconstruction de Chezlepro
|
|
depuis zero). Un locataire depend de services du SITE par leur NOM : son cache
|
|
d'artefacts, sa forge, son depot de sauvegarde, son autorite. Ces noms vivent dans une
|
|
zone que SON resolveur ne sert pas.
|
|
|
|
Tant que ses machines pointaient directement sur le resolveur du site, ca marchait —
|
|
par accident. Reconstruites proprement, elles utilisent LEUR resolveur, qui ignorait
|
|
la zone de l'hebergeur : la recette a echoue sur la RESTITUTION d'une sauvegarde, avec
|
|
« Could not resolve hostname sauvegarde.genese.internal ». La sauvegarde etait
|
|
intacte ; c'est le chemin pour la NOMMER qui manquait.
|
|
|
|
DERIVEE DU PLAN DU SITE, PAS DE `dns_amorcage` — et la nuance a failli couter cher.
|
|
La premiere version prenait `dns_amorcage` pour « l'adresse du resolveur du site ».
|
|
C'est vrai chez Chezlepro ; c'est FAUX chez Technolibre, dont l'amorcage pointe sur
|
|
`9.9.9.9,149.112.112.112`. On aurait delegue la zone souveraine de l'hebergeur a
|
|
Quad9, qui n'en sait rien — et le NXDOMAIN rendu aurait ressemble a une zone vide.
|
|
P03 l'a attrape avant tout deploiement, en comparant l'inventaire de CHAQUE instance
|
|
a son plan.
|
|
#
|
|
L'adresse vient donc du PLAN DU SITE : la machine qui y porte `serveur_resolveur`.
|
|
C'est la seule source qui dise, par construction, qui resout la zone du site.
|
|
|
|
REND [] QUAND LA CARTE N'EST PAS MONTEE, et c'est le comportement d'un EMANCIPE : il
|
|
ne delegue plus rien, donc ne peut plus nommer les services du site. C'est ce qu'on
|
|
veut CONSTATER d'une emancipation, pas une panne a reparer.
|
|
"""
|
|
try:
|
|
import underlay as underlay_mod
|
|
zone = str((underlay_mod.lire_plan_site("10-intrants.yml") or {})
|
|
.get("domaine_interne") or "").strip()
|
|
except Exception:
|
|
return []
|
|
# Un site qui s'heberge lui-meme partage la zone de son instance : il n'y a alors
|
|
# rien a deleguer, et se declarer transitaire de soi-meme ferait une boucle.
|
|
if not zone or zone == _domaine_interne():
|
|
return []
|
|
try:
|
|
adresses = [a for a in underlay_mod.adresses_site_portant("serveur_resolveur") if a]
|
|
except Exception:
|
|
adresses = []
|
|
if not adresses:
|
|
return []
|
|
return [{"nom": zone, "adresses": adresses}]
|
|
|
|
|
|
def _attributs_cible(vers: str, apps: dict, serveurs: dict, nomenclature: dict, domaine: str) -> dict | None:
|
|
"""Resout une cible de lien en attributs substituables. Phase 1 : applications."""
|
|
if vers in apps:
|
|
hote = apps[vers].get("hote")
|
|
srv = serveurs.get(hote, {})
|
|
_, seq = fonction_seq(str(hote))
|
|
d = deriver_nomenclature(str(srv.get("fonction", "")), seq, nomenclature) or {}
|
|
return {
|
|
"genre": "application",
|
|
"hote": hote,
|
|
"fqdn": f"{hote}.{domaine}" if domaine else str(hote),
|
|
"ip": d.get("adresse_ip"),
|
|
}
|
|
return None
|
|
|
|
|
|
def _substituer(valeur, attrs: dict):
|
|
"""Remplace {cible.X} dans une chaine ; laisse bool/int tels quels."""
|
|
if not isinstance(valeur, str):
|
|
return valeur
|
|
for cle, val in attrs.items():
|
|
valeur = valeur.replace("{cible." + cle + "}", str(val))
|
|
return valeur
|
|
|
|
|
|
def resoudre_liens(apps: dict, serveurs: dict, nomenclature: dict) -> dict:
|
|
"""Derive {hote: {var: valeur}} depuis les 'liens' des applications (bindings)."""
|
|
domaine = _domaine_interne()
|
|
injections: dict = {}
|
|
for nom_app, app in apps.items():
|
|
accepte = None
|
|
for lien in (app.get("liens") or []):
|
|
vers, role = lien.get("vers"), lien.get("role")
|
|
if accepte is None:
|
|
accepte = liens_acceptes(str(app.get("groupe", "")), RACINE)
|
|
spec = accepte.get(role)
|
|
if not spec:
|
|
raise ValueError(
|
|
f"application '{nom_app}': lien role '{role}' non accepte par "
|
|
f"'{app.get('groupe')}' (roles/{app.get('groupe')}/meta/liens.yml).")
|
|
attrs = _attributs_cible(str(vers), apps, serveurs, nomenclature, domaine)
|
|
if attrs is None:
|
|
raise ValueError(f"application '{nom_app}': cible de lien '{vers}' introuvable.")
|
|
attendu = spec.get("cible")
|
|
if attendu and attendu != attrs["genre"]:
|
|
raise ValueError(
|
|
f"application '{nom_app}': lien '{role}' attend une cible '{attendu}', "
|
|
f"'{vers}' est '{attrs['genre']}'.")
|
|
sur_conso = spec.get("injecte_sur", "consommateur") == "consommateur"
|
|
cible_hote = app.get("hote") if sur_conso else attrs["hote"]
|
|
for var, gabarit in (spec.get("variables") or {}).items():
|
|
injections.setdefault(cible_hote, {})[var] = _substituer(gabarit, attrs)
|
|
return injections
|
|
|
|
|
|
def generer() -> dict:
|
|
serveurs = charger_serveurs(FICHIER_SERVEURS).get("serveurs", {})
|
|
apps = charger_applications(FICHIER_APPLICATIONS).get("applications", {})
|
|
nomenclature = charger_nomenclature(FICHIER_NOMENCLATURE)
|
|
injections = resoudre_liens(apps, serveurs, nomenclature)
|
|
# Expositions du plan (champ 'expose') -> pour deriver les SANs de chaque edge.
|
|
domaines = charger_domaines(FICHIER_DOMAINES)
|
|
expositions = expositions_des_applications({"applications": apps}, domaines)
|
|
|
|
services_par_hote: dict = {}
|
|
for app in apps.values():
|
|
services_par_hote.setdefault(app.get("hote"), set()).add(app.get("groupe"))
|
|
|
|
# Politique d'integration : lue une fois, appliquee a tous (voir D-33).
|
|
universelles = integrations_universelles(RACINE)
|
|
# TOUS les groupes de service du plan : une integration universelle dont le
|
|
# service central n'existe pas ici n'a personne a qui parler (2026-08-22).
|
|
services_du_plan = {g for gs in services_par_hote.values() for g in gs}
|
|
|
|
# Rattachement reseau d'une VM. En SDN, elle appartient a son VNet — pas a un pont
|
|
# de l'hyperviseur avec une etiquette. Le nom du VNet se DERIVE (index + zone),
|
|
# exactement comme le VMID et l'adresse : rien a declarer, rien qui puisse diverger.
|
|
#
|
|
# Sans cette derivation, `make creer-vm` posait les VM sur `proxmox_clone_pont`
|
|
# (`vmbr1`) avec l'etiquette du VLAN — l'ancien monde. C'est ce qu'il a fallu
|
|
# corriger a la main sur infra-pki-01, et les treize suivantes auraient suivi.
|
|
#
|
|
# L'ETIQUETTE DOIT ETRE VIDE en SDN : le VNet la porte deja. En poser une seconde
|
|
# au niveau de la carte donnerait un double etiquetage.
|
|
sdn = underlay_mod.routage_tenants(underlay_mod.charger()) == "sdn"
|
|
index_tenant = nomenclature.get("index")
|
|
|
|
# UNE MACHINE SANS FONCTION DECLAREE N'A PAS D'ADRESSE — ET LE DISAIT PAS (2026-08-24).
|
|
#
|
|
# `deriver_nomenclature(...) or {}` avale l'echec : une fonction absente de
|
|
# `nomenclature.fonctions` rend un dictionnaire vide, et la machine entre dans
|
|
# l'inventaire avec `ansible_host: None` et `vlan: None`. La generation se declare
|
|
# REUSSIE. La panne n'apparait qu'au deploiement, sous une forme incomprehensible —
|
|
# Ansible tentant de joindre une adresse qui n'existe pas.
|
|
#
|
|
# Constate en ajoutant `ops-01` aux modeles : `presence-web` range son socle en zone 1
|
|
# (« Fondations ») et n'a pas de categorie 4. La machine a ete posee, la fonction non,
|
|
# et rien ne l'a signale.
|
|
#
|
|
# On refuse en BLOC plutot qu'a la premiere fautive : l'exploitant corrige son plan
|
|
# une fois, pas une machine a la fois.
|
|
# CE GENERATEUR EST CELUI DES TENANTS, ET DE PERSONNE D'AUTRE (2026-08-24).
|
|
#
|
|
# J'y avais ajoute une branche « adressage declare » pour y faire entrer les machines
|
|
# d'un SITE. C'etait le debut d'une confusion : un site et un tenant ne sont pas deux
|
|
# variantes d'une meme chose. Un site est le TERRAIN, un tenant ce qui y pousse.
|
|
#
|
|
# Le symptome etait visible tout de suite — une branche `si l'adresse est declaree`,
|
|
# un `nomenclature.yml` de site reduit a une coquille vide, et un site exclu des devis
|
|
# par ABSENCE d'index plutot que par nature. Une exclusion fondee sur un manque est
|
|
# une exclusion qu'un ajout innocent casserait.
|
|
#
|
|
# Les machines de l'hebergeur se declarent desormais dans `underlay.yml`, a cote des
|
|
# switches et des hyperviseurs — du mobilier de fabric. Ce qui se partage entre les
|
|
# deux mondes, ce sont les ROLES, pas la forme du plan.
|
|
sans_fonction = [
|
|
nom for nom, srv in serveurs.items()
|
|
if not (deriver_nomenclature(str(srv.get("fonction", "")),
|
|
fonction_seq(nom)[1], nomenclature) or {}).get("adresse_ip")
|
|
]
|
|
if sans_fonction:
|
|
connues = ", ".join(sorted((nomenclature.get("fonctions") or {}))) or "(aucune)"
|
|
raise SystemExit(
|
|
"Machines sans adresse derivable — leur `fonction` n'est pas declaree dans "
|
|
"`nomenclature.fonctions` :\n"
|
|
+ "".join(f" - {n} : fonction « {serveurs[n].get('fonction', '')} »\n" for n in sans_fonction)
|
|
+ f"Fonctions connues de ce plan : {connues}")
|
|
|
|
zones_deleguees = _zones_deleguees()
|
|
children: dict = {
|
|
"modeles_vm": {"hosts": {}},
|
|
"hotes_actifs": {"hosts": {}},
|
|
"hotes_planifies": {"hosts": {}},
|
|
}
|
|
for nom, srv in serveurs.items():
|
|
_, seq = fonction_seq(nom)
|
|
d = deriver_nomenclature(str(srv.get("fonction", "")), seq, nomenclature) or {}
|
|
hostvars = {
|
|
# Supernet du tenant, DERIVE du seed comme tout le reste. Il repond a la
|
|
# question « quels clients mon service doit-il accepter ? », posee par
|
|
# PostgreSQL (pg_hba), Postfix (reseaux de confiance) et tout service qui
|
|
# filtre par reseau. Le figer a la main dans group_vars, c'etait garantir
|
|
# qu'il devienne faux : les deux valeurs trouvees le 2026-08-07 dataient de
|
|
# l'ancien monde (10.11.0.0/16 pour un tenant en 10.27.0.0/16), avec un
|
|
# commentaire « AJUSTER » jamais suivi. PostgreSQL refusait Keycloak.
|
|
"setops_supernet": supernet_de(int(index_tenant)) if index_tenant is not None else None,
|
|
"ansible_host": d.get("adresse_ip"),
|
|
"ansible_user": "ansible",
|
|
"proxmox_cidr": d.get("cidr"),
|
|
"proxmox_passerelle": d.get("passerelle"),
|
|
"proxmox_vlan": d.get("vlan"),
|
|
"proxmox_vmid": int(d["vmid"]) if d.get("vmid") else None,
|
|
}
|
|
if sdn and index_tenant is not None and d.get("zone") is not None:
|
|
hostvars["proxmox_pont"] = vnet_de(int(index_tenant), d["zone_libelle"])
|
|
hostvars["proxmox_etiquette_vlan"] = "" # le VNet porte deja le tag
|
|
else:
|
|
hostvars["proxmox_etiquette_vlan"] = d.get("vlan")
|
|
for cle_srv, cle_var in PLACEMENT:
|
|
if str(srv.get(cle_srv, "")).strip():
|
|
hostvars[cle_var] = srv[cle_srv]
|
|
# Ressources derivees des logiciels (groupes de service) + socle SE.
|
|
# setdefault : une valeur explicite du plan (PLACEMENT ci-dessus) gagne.
|
|
ressources = deriver_ressources(sorted(services_par_hote.get(nom, set())), ROLES)
|
|
hostvars.setdefault("proxmox_coeurs", ressources["coeurs"])
|
|
hostvars.setdefault("proxmox_memoire", ressources["memoire"])
|
|
hostvars.setdefault("proxmox_disque_taille", ressources["disque"])
|
|
# Variables derivees des liens (bindings) declares par les applications.
|
|
for var, val in injections.get(nom, {}).items():
|
|
hostvars[var] = val
|
|
services = services_par_hote.get(nom, set())
|
|
groupes = set(GROUPES_SOCLE) | services | integrations_de(srv, services, universelles, services_du_plan=services_du_plan)
|
|
# SANs d'exposition : les FQDN que cet edge sert (derives du plan) -> cert edge
|
|
# (client_pki_sans), au lieu d'une liste manuelle. Vide si l'hote n'est pas un edge.
|
|
sans = sorted({e["fqdn"] for e in expositions if e.get("edge") in groupes})
|
|
if sans:
|
|
hostvars["sans_exposition"] = sans
|
|
# Le resolveur de l'ecosysteme doit savoir a qui demander la zone de l'hebergeur.
|
|
if "serveur_resolveur" in groupes and zones_deleguees:
|
|
hostvars["serveur_resolveur_zones_deleguees"] = zones_deleguees
|
|
etat = "hotes_actifs" if srv.get("etat") == "actif" else "hotes_planifies"
|
|
children[etat]["hosts"][nom] = hostvars
|
|
for groupe in sorted(groupes):
|
|
children.setdefault(groupe, {"hosts": {}})["hosts"][nom] = None
|
|
return {"all": {"children": children}}
|
|
|
|
|
|
def ecrire(path: Path = GENERE) -> None:
|
|
entete = ("# Inventaire GENERE depuis le plan (make instancier / instancier-appliquer).\n"
|
|
"# NE PAS editer a la main : edite instance/plan/serveurs.yml + instance/plan/applications.yml.\n"
|
|
"# Source : instance/plan/serveurs.yml + instance/plan/applications.yml + instance/plan/nomenclature.yml.\n")
|
|
with path.open("w", encoding="utf-8") as fichier:
|
|
fichier.write(entete)
|
|
yaml.safe_dump(generer(), fichier, default_flow_style=False, sort_keys=True, allow_unicode=True)
|
|
|
|
|
|
def _resolu(fichier: Path) -> tuple[dict, dict]:
|
|
cmd = ["ansible-inventory", "-i", str(fichier), "--list"]
|
|
# Une voute chiffree (group_vars/all/vault.yml) fait echouer ansible-inventory sans
|
|
# mot de passe (exit 4).
|
|
#
|
|
# UNE VOUTE, UNE CLE (depuis le 2026-08-28). Ce bloc tentait
|
|
# `~/.config/setops-vault-pass` — le mot de passe UNIQUE d'avant la separation, qui
|
|
# n'ouvre plus rien. `instancier comparer` echouait donc en exit 4 sur un message qui
|
|
# ne parlait que d'`ansible-inventory` : on ne pouvait plus relire l'inventaire en
|
|
# place pour le comparer au genere, donc plus l'appliquer sans `--force`, donc plus
|
|
# voir ce qu'on changeait.
|
|
#
|
|
# `voutes.py identites` rend la liste `etiquette@chemin` de toutes les voutes
|
|
# connues ; Ansible essaie chacune et retient celle qui ouvre. On ne pose rien si
|
|
# l'appelant a deja renseigne l'environnement : sa valeur est plus precise que la
|
|
# notre.
|
|
if not os.environ.get("ANSIBLE_VAULT_PASSWORD_FILE") \
|
|
and not os.environ.get("ANSIBLE_VAULT_IDENTITY_LIST"):
|
|
try:
|
|
ident = subprocess.run(
|
|
[sys.executable, str(Path(__file__).parent / "voutes.py"), "identites"],
|
|
capture_output=True, text=True, check=True).stdout.strip()
|
|
except (subprocess.CalledProcessError, OSError):
|
|
ident = ""
|
|
if ident:
|
|
os.environ["ANSIBLE_VAULT_IDENTITY_LIST"] = ident
|
|
sortie = subprocess.run(cmd, capture_output=True, text=True, check=True).stdout
|
|
data = json.loads(sortie)
|
|
hostvars = data.get("_meta", {}).get("hostvars", {})
|
|
groupes: dict = {}
|
|
for groupe, info in data.items():
|
|
if groupe in ("_meta", "all", "ungrouped") or not isinstance(info, dict):
|
|
continue
|
|
for hote in (info.get("hosts") or []):
|
|
groupes.setdefault(hote, set()).add(groupe)
|
|
return hostvars, groupes
|
|
|
|
|
|
def compter_ecarts(reference: Path, genere: Path) -> int:
|
|
hv_act, grp_act = _resolu(reference)
|
|
hv_gen, grp_gen = _resolu(genere)
|
|
hotes = sorted(set(hv_act) | set(hv_gen))
|
|
ecarts = 0
|
|
for hote in hotes:
|
|
if hote not in hv_gen:
|
|
print(f" - {hote} : ABSENT du genere"); ecarts += 1; continue
|
|
if hote not in hv_act:
|
|
print(f" - {hote} : EN TROP dans le genere"); ecarts += 1; continue
|
|
g_manquants = grp_act.get(hote, set()) - grp_gen.get(hote, set())
|
|
g_surplus = grp_gen.get(hote, set()) - grp_act.get(hote, set())
|
|
vars_diff = [k for k in set(hv_act[hote]) | set(hv_gen[hote])
|
|
if hv_act[hote].get(k) != hv_gen[hote].get(k)]
|
|
if g_manquants or g_surplus or vars_diff:
|
|
ecarts += 1
|
|
print(f" - {hote} :")
|
|
if g_manquants:
|
|
print(f" groupes non reproduits : {', '.join(sorted(g_manquants))}")
|
|
if g_surplus:
|
|
print(f" groupes en trop : {', '.join(sorted(g_surplus))}")
|
|
if vars_diff:
|
|
details = ", ".join(f"{k} (inv={hv_act[hote].get(k)!r} gen={hv_gen[hote].get(k)!r})" for k in sorted(vars_diff))
|
|
print(f" vars differentes : {details}")
|
|
return ecarts
|
|
|
|
|
|
def comparer(strict: bool = False) -> int:
|
|
"""Compare le genere a l'applique. `strict` fait ECHOUER sur un ecart.
|
|
|
|
DEUX APPELANTS, DEUX BESOINS. `make instancier` est une INSPECTION : on veut voir
|
|
le diff avant de decider, et un code d'erreur y transformerait la lecture en panne.
|
|
La preuve P03, elle, AFFIRME que « le plan reproduit l'inventaire » — sans `strict`,
|
|
elle renvoyait 0 quel que soit le nombre d'hotes divergents et ne pouvait donc pas
|
|
echouer. Constate le 2026-08-12 : quatorze hotes divergeaient, la preuve passait.
|
|
"""
|
|
ecrire(GENERE)
|
|
ecarts = compter_ecarts(INVENTAIRE, GENERE)
|
|
if ecarts == 0:
|
|
print("DIFF VIDE : le plan reproduit exactement l'inventaire actuel. Bascule possible.")
|
|
return 0
|
|
print(f"\n{ecarts} hote(s) avec ecart.")
|
|
if strict:
|
|
print("L'inventaire APPLIQUE ne correspond plus au plan. Soit le plan a change et "
|
|
"il faut le basculer (`make instancier-appliquer`), soit hosts.yml a ete "
|
|
"edite a la main — ce que le depot interdit.")
|
|
return 1 if strict else 0
|
|
|
|
|
|
def appliquer(force: bool = False) -> int:
|
|
"""Ecrit hosts.yml depuis le plan. Refuse si le diff n'est pas vide (sauf --force)."""
|
|
ecrire(GENERE)
|
|
ecarts = compter_ecarts(INVENTAIRE, GENERE)
|
|
if ecarts and not force:
|
|
print(f"\nDiff NON vide ({ecarts} hote(s)). Revois 'make instancier'. "
|
|
"Utilise FORCE=1 pour appliquer un changement intentionnel du plan.")
|
|
return 1
|
|
ecrire(INVENTAIRE)
|
|
print(f"\n{os.path.relpath(INVENTAIRE, RACINE)} (re)genere depuis le plan. "
|
|
"git est le filet : git diff / git checkout pour revenir.")
|
|
return 0
|
|
|
|
|
|
def main() -> int:
|
|
import argparse
|
|
parser = argparse.ArgumentParser(description="Generateur d'inventaire Set-OPS (Phase 3).")
|
|
sub = parser.add_subparsers(dest="commande", required=True)
|
|
sub.add_parser("generer", help="Ecrit hosts.genere.yml depuis le plan.")
|
|
sp_cmp = sub.add_parser("comparer", help="Compare le genere a l'inventaire actuel (semantique).")
|
|
sp_cmp.add_argument("--strict", action="store_true",
|
|
help="Sortir en erreur si le diff n'est pas vide (P03).")
|
|
pa = sub.add_parser("appliquer", help="Ecrit hosts.yml depuis le plan (refuse si diff non vide).")
|
|
pa.add_argument("--force", action="store_true", help="Applique meme si le diff n'est pas vide.")
|
|
args = parser.parse_args()
|
|
try:
|
|
if args.commande == "generer":
|
|
ecrire()
|
|
print(f"{os.path.relpath(GENERE, RACINE)} genere depuis le plan.")
|
|
elif args.commande == "comparer":
|
|
return comparer(strict=getattr(args, "strict", False))
|
|
elif args.commande == "appliquer":
|
|
return appliquer(force=args.force)
|
|
except Exception as exc:
|
|
print(f"erreur: {exc}", file=sys.stderr)
|
|
return 2
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|