Daniel Allaire
20a5e44803
La copie de l'AC d'Icinga est deposee aussi par client_sante, plus tot : sur une flotte neuve elle ne changeait jamais ici, et rien ne partait (reconstruction de Chezlepro). client_backup retient desormais l'empreinte de l'Icinga qui l'a entendu, apres le rapport. eprouver_parefeu ne s'arrete plus sur les critiques presents avant l'activation. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
234 lines
11 KiB
Python
234 lines
11 KiB
Python
#!/usr/bin/env python3
|
|
"""La reconstruction REMET l'etat d'avant — et chaque detenteur d'etat sait le faire.
|
|
|
|
POURQUOI (2026-09-30). Technolibre a ete reconstruite, 0 echec, `make valider` vert — et
|
|
rien n'etait revenu : ni l'annuaire (le mot de passe de `sysadmin` etait celui de
|
|
l'amorcage), ni la racine de l'AC, ni les bases, ni Nextcloud. « Restauration verifiee »
|
|
voulait dire « restauree dans un repertoire temporaire, lue, jetee ».
|
|
|
|
Ce test verifie deux choses :
|
|
|
|
1. COUVERTURE (statique). Chaque groupe detenteur d'etat (`client_backup_groupes_etat`)
|
|
inclut `restaurer.yml` depuis son propre role. Une liste qui en suit une autre prend du
|
|
retard : ajouter un detenteur d'etat sans son point de restauration doit echouer ICI.
|
|
|
|
2. L'OUTIL DE NOEUD (`setops-restaurer`), rendu depuis son vrai gabarit, avec `restic`,
|
|
`psql` & co. remplaces par des doublures :
|
|
- le candidat est le dernier instantane ANTERIEUR a la naissance de la machine ;
|
|
- un repertoire non vide n'est jamais ecrase sans `--remplacer` ;
|
|
- la sauvegarde refuse de deposer tant qu'un etat d'avant attend (code 3), et
|
|
reprend une fois chaque jeu acte ; un depot inexistant = premiere vie (« neuf ») ;
|
|
- la section d'une base s'arrete avant le `DROP DATABASE postgres;` que `pg_dumpall
|
|
--clean` place apres la derniere base (le piege du runbook, rencontre le 2026-09-30).
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
import stat
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
from pathlib import Path
|
|
|
|
import jinja2
|
|
import yaml
|
|
|
|
RACINE = Path(__file__).resolve().parents[2]
|
|
GABARIT = RACINE / "roles/client_backup/templates/restaurer.sh.j2"
|
|
|
|
ECHECS: list[str] = []
|
|
|
|
|
|
def verifier(cond: bool, msg: str) -> None:
|
|
print(("OK " if cond else "ECHEC ") + msg)
|
|
if not cond:
|
|
ECHECS.append(msg)
|
|
|
|
|
|
# --- 1. Couverture -------------------------------------------------------------------
|
|
|
|
def couverture() -> None:
|
|
groupes = yaml.safe_load((RACINE / "roles/client_backup/vars/main.yml").read_text())[
|
|
"client_backup_groupes_etat"]
|
|
for g in groupes:
|
|
taches = RACINE / "roles" / g / "tasks"
|
|
texte = "".join(p.read_text() for p in sorted(taches.glob("*.yml"))) if taches.is_dir() else ""
|
|
verifier(f"client_backup_restaurer_jeu: {g}" in texte,
|
|
f"{g} inclut son point de restauration (restaurer.yml)")
|
|
verifier("{#" not in GABARIT.read_text(), "le gabarit ne contient aucune sequence accolade-diese")
|
|
|
|
# UN ICINGA NEUF ENTEND LE NOEUD TOUT DE SUITE (2026-09-30) : sinon `restauration` reste
|
|
# rouge jusqu'au dimanche apres chaque reconstruction.
|
|
# PAS SUR LA COPIE DE L'AC : `client_sante` la depose aussi, plus tot — sur une flotte
|
|
# neuve elle ne change donc jamais ici (reconstruction de Chezlepro, 2026-09-30).
|
|
taches = yaml.safe_load((RACINE / "roles/client_backup/tasks/verifier.yml").read_text())
|
|
notifiants = [t.get("name", "") for t in taches if t.get("notify") == "Premier rapport a Icinga"]
|
|
verifier(notifiants and all("AC d'Icinga pour la" not in n for n in notifiants)
|
|
and any("jamais entendus" in n for n in notifiants),
|
|
"le premier rapport part d'un marqueur propre a client_backup, pas de la copie partagee de l'AC")
|
|
gest = yaml.safe_load((RACINE / "roles/client_backup/handlers/main.yml").read_text())
|
|
ecoute = [g for g in gest if g.get("listen") == "Premier rapport a Icinga"]
|
|
ordre = [g.get("ansible.builtin.systemd", {}).get("name", "marqueur") for g in ecoute]
|
|
verifier(ordre == ["setops-sauvegarde.service", "setops-verification-depot.service",
|
|
"setops-verification-restauration.service", "marqueur"],
|
|
f"premier rapport : deposer, verifier le depot, la restauration, PUIS retenir ({ordre})")
|
|
|
|
|
|
# --- 2. L'outil de noeud, avec des doublures ------------------------------------------
|
|
|
|
def executable(chemin: Path, texte: str) -> None:
|
|
chemin.write_text(texte)
|
|
chemin.chmod(chemin.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
|
|
|
|
|
|
DUMP = r"""--
|
|
DROP DATABASE nextcloud;
|
|
DROP DATABASE keycloak;
|
|
CREATE DATABASE keycloak WITH TEMPLATE = template0 ENCODING = 'UTF8' LOCALE = 'fr_CA.UTF-8';
|
|
ALTER DATABASE keycloak OWNER TO keycloak;
|
|
\connect keycloak
|
|
CREATE TABLE realm (id text);
|
|
COPY realm FROM stdin;
|
|
\.
|
|
CREATE DATABASE nextcloud WITH TEMPLATE = template0 ENCODING = 'UTF8' LOCALE = 'fr_CA.UTF-8';
|
|
ALTER DATABASE nextcloud OWNER TO nextcloud;
|
|
\connect nextcloud
|
|
CREATE TABLE oc_users (uid text);
|
|
REVOKE CONNECT,TEMPORARY ON DATABASE nextcloud FROM PUBLIC;
|
|
DROP DATABASE postgres;
|
|
CREATE DATABASE postgres WITH TEMPLATE = template0;
|
|
\connect postgres
|
|
"""
|
|
|
|
|
|
def outil() -> None:
|
|
with tempfile.TemporaryDirectory() as d:
|
|
d = Path(d)
|
|
bin_, fixt, log = d / "bin", d / "instantanes", d / "journal"
|
|
for p in (bin_, fixt, log):
|
|
p.mkdir()
|
|
cle = d / "ssh_host_ed25519_key.pub"
|
|
cle.write_text("cle\n") # nee MAINTENANT
|
|
staging = d / "staging"
|
|
|
|
# Deux instantanes : l'un d'AVANT la naissance, l'autre d'apres (l'etat neuf).
|
|
avant, apres = fixt / "avant01", fixt / "apres02"
|
|
for snap, contenu in ((avant, "ancien"), (apres, "neuf")):
|
|
(snap / str(d / "vmail").lstrip("/") / "boite").mkdir(parents=True)
|
|
(snap / str(d / "vmail").lstrip("/") / "boite" / "msg").write_text(contenu)
|
|
dump = snap / str(staging).lstrip("/") / "postgresql" / "toutes-bases.sql"
|
|
dump.parent.mkdir(parents=True)
|
|
dump.write_text(DUMP)
|
|
snaps = [
|
|
{"short_id": "avant01", "id": "avant01" + "0" * 56, "time": "2026-09-29T23:50:50.123456789-04:00"},
|
|
{"short_id": "apres02", "id": "apres02" + "0" * 56, "time": "2099-01-01T00:00:00Z"},
|
|
]
|
|
(d / "snapshots.json").write_text(json.dumps(snaps))
|
|
|
|
# restic : `snapshots --json` et `restore ID --target T --include P...`.
|
|
# SETOPS_TEST_DEPOT_ABSENT=1 imite restic 0.17+ face a un depot inexistant (code 10).
|
|
executable(bin_ / "restic", f"""#!/bin/bash
|
|
if [[ -n "${{SETOPS_TEST_DEPOT_ABSENT:-}}" ]]; then exit 10; fi
|
|
case "$1" in
|
|
snapshots) cat "{d}/snapshots.json" ;;
|
|
restore)
|
|
id="$2"; shift 2; cible=""; inc=()
|
|
while (( $# )); do case "$1" in --target) cible="$2"; shift 2;; --include) inc+=("$2"); shift 2;; *) shift;; esac; done
|
|
for i in "${{inc[@]}}"; do
|
|
[[ -e "{fixt}/$id$i" ]] || continue
|
|
mkdir -p "$cible$(dirname "$i")"; cp -a "{fixt}/$id$i" "$cible$(dirname "$i")/"
|
|
done ;;
|
|
esac
|
|
""")
|
|
# PostgreSQL : on journalise, on garde la section rejouee ; toute base est vierge.
|
|
executable(bin_ / "runuser", '#!/bin/bash\nwhile [[ "$1" != "--" ]]; do shift; done; shift; exec "$@"\n')
|
|
# Sans `-c`, psql lit la section sur son entree standard : c'est ainsi que l'outil
|
|
# doit la lui passer (`postgres` ne lit pas le repertoire jetable de root).
|
|
executable(bin_ / "psql", f"""#!/bin/bash
|
|
echo "psql $*" >> "{log}/pg"
|
|
avec_c=0
|
|
while (( $# )); do
|
|
case "$1" in -f) echo "psql -f INTERDIT" >> "{log}/pg"; shift 2;; -c) avec_c=1; [[ "$2" == select* ]] && echo 0; shift 2;; *) shift;; esac
|
|
done
|
|
if (( ! avec_c )); then cat > "{log}/section.sql"; fi
|
|
""")
|
|
executable(bin_ / "pg_dump", '#!/bin/bash\necho dump\n')
|
|
executable(bin_ / "dropdb", f'#!/bin/bash\necho "dropdb $*" >> "{log}/pg"\n')
|
|
|
|
rendu = jinja2.Environment(undefined=jinja2.StrictUndefined).from_string(
|
|
GABARIT.read_text()).render(
|
|
client_backup_repo="sftp:restic@depot:hote",
|
|
inventory_hostname="hote",
|
|
client_backup_restauration_marques=str(d / "marques"),
|
|
client_backup_restauration_mise_de_cote=str(d / "mis-de-cote"),
|
|
client_backup_staging=str(staging),
|
|
client_backup_jobs=[{"nom": "courriel"}, {"nom": "postgresql"}],
|
|
).replace("/etc/ssh/ssh_host_ed25519_key.pub", str(cle)) \
|
|
.replace("/etc/setops/restic.pass", str(d / "restic.pass"))
|
|
script = d / "setops-restaurer"
|
|
executable(script, rendu)
|
|
env = {**os.environ, "PATH": f"{bin_}:{os.environ['PATH']}"}
|
|
|
|
def lancer(*args: str, **extra: str) -> subprocess.CompletedProcess:
|
|
return subprocess.run(["bash", str(script), *args], env={**env, **extra},
|
|
capture_output=True, text=True)
|
|
|
|
r = lancer("choisir")
|
|
verifier(r.returncode == 0 and json.loads(r.stdout)["instantane"] == "avant01",
|
|
f"le candidat est l'instantane d'AVANT la naissance, pas l'etat neuf ({r.stdout.strip() or r.stderr.strip()})")
|
|
|
|
r = lancer("garde")
|
|
verifier(r.returncode == 3, f"la sauvegarde refuse tant qu'un etat d'avant attend (code {r.returncode})")
|
|
|
|
vmail = d / "vmail"
|
|
(vmail / "neuf").mkdir(parents=True)
|
|
(vmail / "neuf" / "x").write_text("x")
|
|
r = lancer("fichiers", str(vmail))
|
|
verifier(r.returncode != 0 and (vmail / "neuf" / "x").exists(),
|
|
"un repertoire non vide n'est pas ecrase sans --remplacer")
|
|
|
|
r = lancer("fichiers", "--remplacer", str(vmail))
|
|
verifier(r.returncode == 0 and (vmail / "boite" / "msg").read_text() == "ancien"
|
|
and not (vmail / "neuf").exists(),
|
|
f"--remplacer remet l'etat d'avant, a l'identique ({r.stdout.strip() or r.stderr.strip()})")
|
|
verifier(any((d / "mis-de-cote").rglob("x")), "l'etat ecrase a ete mis de cote")
|
|
|
|
r = lancer("base", "nextcloud")
|
|
section = (log / "section.sql").read_text() if (log / "section.sql").exists() else ""
|
|
verifier(r.returncode == 0 and "oc_users" in section, f"la section nextcloud est rejouee ({r.stderr.strip()[:120]})")
|
|
verifier("DROP DATABASE" not in section and "realm" not in section,
|
|
"la section s'arrete avant le DROP DATABASE postgres, et ne deborde sur aucune autre base")
|
|
pg = (log / "pg").read_text()
|
|
verifier("--single-transaction" in pg, "la base est rejouee en une seule transaction")
|
|
verifier("INTERDIT" not in pg, "la section passe par l'entree standard, jamais par `psql -f`")
|
|
|
|
r = lancer("base", "inexistante")
|
|
verifier(r.returncode == 0 and "ABSENTE" in r.stdout, "une base absente de l'instantane est dite, pas inventee")
|
|
|
|
for jeu in ("courriel", "postgresql"):
|
|
lancer("acter", jeu, "restaure", "avant01")
|
|
r = lancer("garde")
|
|
verifier(r.returncode == 0, "la sauvegarde reprend une fois chaque jeu acte")
|
|
|
|
for f in (d / "marques").iterdir():
|
|
f.unlink()
|
|
r = lancer("garde", SETOPS_TEST_DEPOT_ABSENT="1")
|
|
marques = sorted(p.name for p in (d / "marques").iterdir())
|
|
verifier(r.returncode == 0 and marques == ["courriel", "postgresql"]
|
|
and "etat=neuf" in (d / "marques" / "courriel").read_text(),
|
|
"depot inexistant = premiere vie : chaque jeu est acte « neuf »")
|
|
|
|
|
|
def main() -> int:
|
|
couverture()
|
|
outil()
|
|
if ECHECS:
|
|
print(f"\n{len(ECHECS)} echec(s).")
|
|
return 1
|
|
print("\nLa restauration est couverte et l'outil se comporte comme annonce.")
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|