diff --git a/CHANGELOG.fr.md b/CHANGELOG.fr.md index 0d6828a..17a8bfd 100644 --- a/CHANGELOG.fr.md +++ b/CHANGELOG.fr.md @@ -51,6 +51,55 @@ et le projet suit le [versionnage sémantique](https://semver.org/lang/fr/). ### Modifié +- **`dsoxlab doctor` guide jusqu'au bout : toutes les étapes qui manquent + d'un coup, dans l'ordre, chaque commande prête à coller.** Deux machines + vides mesurées le 2026-11-16 (Ubuntu 24.04 et AlmaLinux 10) obligeaient à + relancer `doctor` après chaque geste pour découvrir le suivant, et + `provision` échouait encore après un `doctor` vert. Le diagnostic : + - affiche des **étapes numérotées** dans l'ordre des dépendances (git, + provider, libvirt, groupes, pool, firmware EFI, Terraform, Ansible, + collections, clé SSH du catalogue, Include de `~/.ssh/config`), chaque + commande seule sur sa ligne au lieu d'être coupée dans une cellule de + tableau, puis « À savoir », ce qui est prêt, et la commande unique + `dsoxlab doctor --fix` ; + - **ne cache plus aucun contrôle** : sans libvirt, le pool, les groupes et + le firmware restent listés, « faire l'étape N d'abord » ; sans provider + choisi, il diagnostique avec celui qu'il recommande (kvm sur un Linux qui + expose `/dev/kvm`), sans l'enregistrer ; + - **contrôle quatre choses de plus**, qui faisaient échouer `provision` ou + `ssh` : la clé SSH du catalogue, la ligne `Include` de `~/.ssh/config`, le + firmware EFI (issue #381), et les groupes `kvm`/`libvirt`, en distinguant + « reconnectez-vous » de « rejoignez le groupe » ; + - **donne des commandes, plus des liens**, lues dans une table par famille + de distribution (`/etc/os-release`) : git, Terraform et Docker depuis leurs + dépôts officiels, `systemctl enable --now libvirtd` au lieu de `start`, qui + ne survivait pas au redémarrage, et plus de `dnf install incus` sur la + famille RHEL, dont aucun dépôt de base ne l'a ; + - avec `-v`, montre chaque contrôle et les mises en garde des lignes vertes + (un Terraform plus ancien que la dernière version). +- **`doctor --fix` affiche son plan et demande d'abord.** Rien ne part sans + `[y/N]` ou `--yes` ; sans terminal et sans `--yes`, rien ne part (code 1). + Les étapes sans sudo sont lancées par dsoxlab ; celles avec sudo passent + toutes par un seul `ansible-playbook --ask-become-pass -c local`, généré + depuis la même table que l'affichage, qui demande le mot de passe une fois ; + sans terminal, elles s'affichent à coller. Ansible est installé d'abord + (`uv tool install ansible-core`). Chaque étape est revérifiée par un + diagnostic refait, et **le premier échec arrête tout**, en nommant les + étapes restantes : l'ancienne cascade continuait, et créait un pool sans + libvirt. Docker et Incus, quand le catalogue n'en a pas besoin, ne viennent + qu'avec `--clients`. +- **Une mémoire trop petite pour tout le catalogue ne bloque plus.** Elle + passe sous « À savoir » avec `dsoxlab provision --host `, et dans + `informational` en `--json` : `doctor --strict` ne sort plus en 9 pour elle. + `start ` reste bloquant sur la mémoire qu'exige son propre lab. +- `doctor --json` gagne trois champs par contrôle, sans rien retirer : + `commands` (les lignes à coller), `after` (le contrôle à réparer d'abord) et + `warning`. `fix` ne porte plus les commandes qui exigent un shell + (Terraform, Docker) : lire `commands`. Les codes de sortie ne changent pas. +- La section d'installation de `docs/learner.fr.md` donne les mêmes commandes + que le diagnostic, avec `sudo`, pour Debian/Ubuntu et la famille RHEL ; un + test la tient mot pour mot alignée sur la table. + - **Les machines provisionnées ne démarrent plus avec l'hôte, sauf si le catalogue le demande** (issue #377). Les templates kvm et incus posaient le démarrage automatique sur chaque machine, sans moyen d'y échapper : au diff --git a/CHANGELOG.md b/CHANGELOG.md index c012b2a..5c3924e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -50,6 +50,53 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Changed +- **`dsoxlab doctor` guides you to the end: every missing step at once, in + order, each command ready to paste.** Two empty machines measured on + 2026-11-16 (Ubuntu 24.04 and AlmaLinux 10) needed `doctor` to be run again + after each gesture to discover the next one, and `provision` still failed + after a green `doctor`. The diagnosis now: + - prints **numbered steps** in dependency order (git, provider, libvirt, + groups, pool, EFI firmware, Terraform, Ansible, collections, catalogue + SSH key, `~/.ssh/config` Include), each command alone on its line instead + of cut inside a table cell, then « Good to know », what is ready, and the + single command `dsoxlab doctor --fix`; + - **hides no check**: without libvirt, the pool, the groups and the firmware + stay listed, "do step N first"; with no provider chosen, it diagnoses + with the recommended one (kvm on a Linux exposing `/dev/kvm`) without + recording it; + - **checks four new things** that made `provision` or `ssh` fail: the + catalogue SSH key, the `Include` line of `~/.ssh/config`, the EFI firmware + (issue #381), and the `kvm`/`libvirt` groups, telling "log in again" apart + from "join the group"; + - **gives commands, not links**, read from one table per distribution family + (`/etc/os-release`): git, Terraform and Docker from their official + repositories, `systemctl enable --now libvirtd` instead of `start`, which + did not survive a reboot, and no `dnf install incus` on the RHEL family, + where no base repository has it; + - with `-v`, shows every check and the warnings on green lines (a Terraform + older than the latest release). +- **`doctor --fix` shows its plan and asks first.** Nothing runs without + `[y/N]` or `--yes`; without a terminal and without `--yes`, nothing runs + (exit 1). Steps without sudo are run by dsoxlab; sudo steps all go through + one `ansible-playbook --ask-become-pass -c local` run, generated from the + same table as the display, which asks for the password once; without a + terminal they are printed to paste. Ansible is installed first + (`uv tool install ansible-core`). Each step is checked again by a fresh + diagnosis, and **the first failure stops everything**, naming the remaining + steps: the old cascade went on, creating a pool without libvirt. Docker and + Incus, when the catalogue does not need them, only come with `--clients`. +- **A memory too small for the whole catalogue no longer blocks.** It moves + to « Good to know » with `dsoxlab provision --host `, and to + `informational` in `--json`: `doctor --strict` no longer exits 9 for it. + `start ` still blocks on the memory its own lab needs. +- `doctor --json` gains three fields per check, nothing removed: `commands` + (the lines to paste), `after` (the check to repair first) and `warning`. + `fix` no longer carries the commands that need a shell (Terraform, Docker): + read `commands`. Exit codes are unchanged. +- The installation section of `docs/learner.md` gives the same commands as + the diagnosis, with `sudo`, for Debian/Ubuntu and the RHEL family; a test + keeps it word for word in line with the table. + - **Provisioned machines no longer start with the host, unless the catalogue asks** (issue #377). The kvm and incus templates set autostart on every machine, with no way out: when a training machine rebooted on 2026-11-16, diff --git a/docs/learner.fr.md b/docs/learner.fr.md index 61e1365..7a8e4d2 100644 --- a/docs/learner.fr.md +++ b/docs/learner.fr.md @@ -80,29 +80,113 @@ répare ce qui peut l'être sans risque. Deux sortes de labs, et seule la première est gratuite. Un lab **`shell`** se joue dans un répertoire de votre machine : le lab de démonstration en est un, et tout le catalogue Terraform aussi. Un lab **`vm`** démarre de vraies -machines virtuelles à côté de vous — 66 des 86 labs du catalogue Linux le -font — et votre machine doit donc pouvoir les faire tourner : - -- **Linux, avec KVM.** Les hyperviseurs packagés sont KVM/libvirt et Incus, et - aucun des deux n'existe sous Windows ou macOS : là-bas, les labs `vm` - passent par [l'appliance](./appliance.fr.md). Dans une machine virtuelle, - ils réclament en plus la virtualisation imbriquée, qui s'active sur l'hôte - et non dans l'invité. -- **libvirt et QEMU.** `dsoxlab doctor --fix` les installe là où le remède est - un `apt install`, le seul gestionnaire de paquets que les remèdes - connaissent aujourd'hui, et vous ajoute au groupe `kvm` — ce qui prend effet - à votre prochaine connexion. -- **Terraform.** `doctor` le nomme et renvoie à sa page d'installation, mais ne - peut pas l'installer : HashiCorp le distribue par son propre dépôt. Ansible - ne demande rien, il vient avec dsoxlab. -- **Une paire de clés SSH pour le catalogue**, produite par `dsoxlab instructor - bootstrap`. Le mot « instructor » nomme la commande, lancez-la quand même : - un catalogue que vous clonez ne porte aucune clé — son `.gitignore` exclut - tout le répertoire `ssh/`, une clé privée n'ayant rien à faire dans un - dépôt — et `provision` refuse de démarrer sans elle. - -Rien de tout cela ne se devine : `dsoxlab doctor` le range entre ce que ce -catalogue exige et ce qui est informatif, et dit quoi faire de chaque ligne. +machines virtuelles à côté de vous, et votre machine doit donc pouvoir les +faire tourner. Il lui faut **Linux avec KVM** : les hyperviseurs packagés sont +KVM/libvirt et Incus, et aucun des deux n'existe sous Windows ou macOS, où les +labs `vm` passent par [l'appliance](./appliance.fr.md). Dans une machine +virtuelle, ils réclament en plus la virtualisation imbriquée, qui s'active sur +l'hôte et non dans l'invité. + +Le chemin court : lancez `dsoxlab doctor`. Il liste d'un coup toutes les +étapes qui manquent, numérotées dans l'ordre où les faire, chaque commande +seule sur sa ligne, pour votre distribution (lue dans `/etc/os-release`). +Ensuite, `dsoxlab doctor --fix` affiche le plan et le lance une fois que vous +l'avez confirmé : les étapes sans sudo par dsoxlab lui-même, celles avec sudo +par un seul `ansible-playbook`, qui vous demande votre mot de passe une fois. +Chaque étape est revérifiée juste après, et le premier échec arrête tout. + +Les mêmes étapes à la main. Sur **Debian ou Ubuntu** : + +```bash +sudo apt install git +sudo apt install libvirt-clients libvirt-daemon-system qemu-kvm +sudo usermod -aG kvm,libvirt $USER +sudo virsh pool-define-as default dir --target /var/lib/libvirt/images +sudo virsh pool-build default +sudo virsh pool-start default +sudo virsh pool-autostart default +wget -O - https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg +echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(grep -oP '(?<=UBUNTU_CODENAME=).*' /etc/os-release || lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list +sudo apt update && sudo apt install terraform +``` + +Sur **AlmaLinux, Rocky ou RHEL** (libvirt n'y démarre pas tout seul) : + +```bash +sudo dnf install git +sudo dnf install libvirt qemu-kvm +sudo systemctl enable --now libvirtd +sudo usermod -aG kvm,libvirt $USER +sudo virsh pool-define-as default dir --target /var/lib/libvirt/images +sudo virsh pool-build default +sudo virsh pool-start default +sudo virsh pool-autostart default +sudo dnf install -y yum-utils +sudo yum-config-manager --add-repo https://rpm.releases.hashicorp.com/RHEL/hashicorp.repo +sudo dnf -y install terraform +``` + +Fermez ensuite votre session et rouvrez-la : les groupes `kvm` et `libvirt` ne +valent que pour une nouvelle session. Puis, sur toutes les distributions, +depuis le catalogue : + +```bash +uv tool install ansible-core +dsoxlab use --provider kvm +ansible-galaxy collection install -r requirements.yml +dsoxlab instructor bootstrap +mkdir -p ~/.ssh && t=$(mktemp) && { echo 'Include ~/.ssh/config.d/*.conf'; cat ~/.ssh/config 2>/dev/null || true; } > "$t" && mv "$t" ~/.ssh/config && chmod 600 ~/.ssh/config +``` + +Ces commandes installent Ansible (par `uv`, sans sudo), choisissent le +provider, installent les collections Ansible qu'appellent les playbooks du +catalogue, créent la clé SSH du catalogue (le mot « instructor » nomme la +commande, lancez-la quand même : un catalogue que vous clonez ne porte aucune +clé, et `provision` refuse de démarrer sans elle), et font lire à `ssh` les +fichiers que dsoxlab écrit dans `~/.ssh/config.d/`. La dernière marche sur un +`~/.ssh/config` vide ou absent, ce que ne fait pas un `sed -i '1i …'`. + +Si `doctor` signale le firmware EFI absent : `sudo apt install ovmf` sur Debian ou +Ubuntu, `sudo dnf install edk2-ovmf` sur la famille RHEL. Il arrive d'habitude avec QEMU. + +Une mémoire trop petite pour tout le catalogue ne bloque rien : `doctor` le dit +sous « À savoir », et `dsoxlab provision --host ` ne monte que la +machine du lab que vous jouez. + +Docker ne sert qu'aux catalogues dont les labs déclarent des conteneurs ; +`dsoxlab doctor --fix --clients` l'installe, depuis le dépôt de Docker. À la +main, sur Debian ou Ubuntu (remplacez `ubuntu` par `debian` dans les deux URL +sur Debian) : + +```bash +sudo apt update +sudo apt install ca-certificates curl +sudo install -m 0755 -d /etc/apt/keyrings +sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc +sudo chmod a+r /etc/apt/keyrings/docker.asc +sudo tee /etc/apt/sources.list.d/docker.sources </dev/null || true; } > "$t" && mv "$t" ~/.ssh/config && chmod 600 ~/.ssh/config +``` + +These install Ansible (with `uv`, no sudo), choose the provider, install the +Ansible collections the catalog's playbooks call, create the catalog's SSH key +(the name says instructor; run it anyway: a catalog you clone carries no key, +and `provision` refuses to start without one), and make `ssh` read the files +dsoxlab writes in `~/.ssh/config.d/`. The last command works on an empty or +missing `~/.ssh/config`, which a `sed -i '1i …'` does not. + +If `doctor` reports the EFI firmware missing: `sudo apt install ovmf` on Debian or +Ubuntu, `sudo dnf install edk2-ovmf` on the RHEL family. It usually comes with QEMU. + +A memory too small for the whole catalog does not block anything: `doctor` +says it under « Good to know », and `dsoxlab provision --host ` brings +up only the machine of the lab you play. + +Docker is needed only by catalogs whose labs declare containers; +`dsoxlab doctor --fix --clients` installs it, from Docker's own repository. By +hand, on Debian or Ubuntu (replace `ubuntu` by `debian` in the two URLs on +Debian): + +```bash +sudo apt update +sudo apt install ca-certificates curl +sudo install -m 0755 -d /etc/apt/keyrings +sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc +sudo chmod a+r /etc/apt/keyrings/docker.asc +sudo tee /etc/apt/sources.list.d/docker.sources <` reste bloquant sur la mémoire +qu'exige son propre lab. `state: choice_required` existe parce qu'une décision n'est pas une panne : un catalogue qui déclare plusieurs providers sans qu'aucun soit choisi bloque bien diff --git a/docs/machine-output.md b/docs/machine-output.md index 8466cb1..4d30027 100644 --- a/docs/machine-output.md +++ b/docs/machine-output.md @@ -650,7 +650,10 @@ A catalog with no `infra:` block is a normal case, not an error: it yields "detail": "bundled with dsoxlab (used by 'check')", "fix": null, "fix_kind": null, - "hint": null + "hint": null, + "commands": [], + "after": null, + "warning": null } ], "informational": [ @@ -660,9 +663,12 @@ A catalog with no `infra:` block is a normal case, not an error: it yields "ok": false, "label": "virsh/KVM", "detail": "virsh not found", - "fix": "sudo apt install libvirt-clients libvirt-daemon-system qemu-kvm", - "fix_kind": "automatic", - "hint": null + "fix": null, + "fix_kind": null, + "hint": null, + "commands": ["sudo apt install libvirt-clients libvirt-daemon-system qemu-kvm"], + "after": null, + "warning": null } ], "notes": ["No lab in this catalog uses a VM: the hypervisors above are informational."] @@ -680,7 +686,7 @@ Each check: | Field | Type | Meaning | | --- | --- | --- | -| `key` | string | **the stable identity**: `python`, `pytest`, `shell`, `git`, `docker`, `egress`, `labs`, `lab_home`, and, on a catalog with `vm` labs, `provider`, `kvm`, `incus`, `terraform`, `tf_providers`, `ansible`, `libvirt_pool`, `hw_virt`, `cpu_arch`, `resources`, `bridge_name` | +| `key` | string | **the stable identity**: `python`, `pytest`, `shell`, `git`, `docker`, `egress`, `labs`, `lab_home`, and, on a catalog with `vm` labs, `provider`, `kvm`, `incus`, `terraform`, `tf_providers`, `ansible`, `collections`, `libvirt_pool`, `groupes`, `efi`, `cle_ssh`, `ssh_include`, `hw_virt`, `cpu_arch`, `resources`, `bridge_name` | | `state` | string | `ok`, `failed`, `choice_required`, or `unknown` | | `ok` | bool | the same thing as `state == "ok"`, kept for a plain green/red reading | | `label` | string | the component's name, translated — for display only | @@ -688,6 +694,14 @@ Each check: | `fix` | string or null | the remediation in its readable form; `dsoxlab doctor --fix` plays the same commands token by token, without a shell | | `fix_kind` | string or null | the remediation category: `automatic`, `manual` (shown, never run), `needs_relogin` or `needs_reboot` (run, but the check stays red until the session or the machine restarts) | | `hint` | string or null | a step only a human should take — an install page, a decision | +| `commands` | array of strings | the commands `doctor` prints for this check, one per line, ready to paste, `sudo` included; empty when there is nothing to run. On the RHEL family they use `dnf`, on Debian and Ubuntu `apt` (read from `/etc/os-release`) | +| `after` | string or null | the `key` of the check to repair first: this one could not be measured without it (the pool without libvirt), so its `state` is `unknown` | +| `warning` | string or null | a remark on a green check (a Terraform older than the latest release); never a failure | + +Since 0.9.5, `resources` sits in `informational` when the machine is too small +for the **whole** catalog: a lab often brings up a single machine, and +`provision --host` does that. `start ` still blocks on the memory its own +lab needs. `state: choice_required` exists because a decision is not a failure: a catalog that declares several providers and has none selected blocks provisioning, but diff --git a/src/dsoxlab/cli/diagnostic.py b/src/dsoxlab/cli/diagnostic.py index 2599ea3..9108c60 100644 --- a/src/dsoxlab/cli/diagnostic.py +++ b/src/dsoxlab/cli/diagnostic.py @@ -23,13 +23,17 @@ import logging import os +import shlex +import shutil import subprocess import sys import webbrowser +from collections.abc import Callable from pathlib import Path from typing import TYPE_CHECKING, Annotated, Any import typer +from rich.text import Text from ..i18n import _ from ..reporting import ( @@ -43,6 +47,7 @@ success, warn, ) +from ..reporting.doctor_rendu import titre_etape from ..security.terminal import texte_affichable from ..services import ( Fix, @@ -53,7 +58,17 @@ EXIT_DOCTOR_REQUIS_KO, DoctorReport, ) -from ..services.remediation import Application, appliquer, obstacle, planifier +from ..services.doctor_controles.incus import _current_user +from ..services.doctor_etapes import Etape +from ..services.remediation import ( + Action, + Application, + PlanCorrection, + chemin_du_playbook, + etape_verifiee, + planifier, + playbook_du_poste, +) from ..utils.shell import CommandError, run_command from ._commun import ( LabHomeOption, @@ -220,6 +235,9 @@ def doctor( fix: Annotated[bool, typer.Option("--fix", help=_("opt_fix"))] = False, as_json: Annotated[bool, typer.Option("--json", help=_("opt_json"))] = False, strict: Annotated[bool, typer.Option("--strict", help=_("opt_doctor_strict"))] = False, + oui: Annotated[bool, typer.Option("--yes", "-y", help=_("opt_doctor_yes"))] = False, + clients: Annotated[bool, typer.Option("--clients", help=_("opt_doctor_clients"))] = False, + verbose: Annotated[bool, typer.Option("--verbose", "-v", help=_("opt_doctor_verbose"))] = False, ) -> None: root = _root(lab_home) @@ -232,18 +250,7 @@ def doctor( error(_("doctor_json_sans_fix")) raise typer.Exit(1) - # Le meta.yml décide de ce qui est bloquant ici : un dépôt sans lab `vm` - # n'a besoin d'aucun hyperviseur, et un dépôt qui a choisi son provider - # n'a pas besoin des autres. Son absence n'est pas une erreur : on - # diagnostique alors le strict socle commun. - try: - repo_meta = _read_repo(root) - except typer.Exit: - # Un meta.yml illisible est justement ce qu'un diagnostic doit - # pouvoir rapporter : l'erreur est déjà affichée, on poursuit sur - # le socle commun plutôt que de sortir sans rien dire d'autre. - repo_meta = None - report = collect_checks(root, repo_meta) + report = collect_checks(root, _relire(root)) if as_json: # Le code de retour ne change pas : `doctor` sort en 0 même quand un @@ -257,82 +264,286 @@ def doctor( _verdict_strict(report) return - print_doctor(report) - joue = _reparer(report) if fix else False + print_doctor(report, verbose=verbose) + joue = _reparer(report, root, oui=oui, clients=clients) if fix else False if strict: # Après des correctifs, l'état de la machine a changé : juger sur le # rapport d'avant dirait faux, et dans le mauvais sens : un `--fix` # réussi sortirait quand même en échec. On remesure. - _verdict_strict(collect_checks(root, repo_meta) if joue else report) + _verdict_strict(collect_checks(root, _relire(root)) if joue else report) -def _reparer(report: DoctorReport) -> bool: - """Joue ce que `--fix` peut jouer, et dit si la machine a changé. +def _relire(root: Path) -> RepoMetadata | None: + """Le meta.yml du catalogue, relu : `--fix` peut avoir choisi le provider. - Le booléen rendu décide de la remesure : sans correctif joué, remesurer - coûterait un diagnostic complet pour un rapport identique. + Son absence n'est pas une erreur : on diagnostique alors le strict socle + commun. Un meta.yml illisible non plus : l'erreur est affichée, et c'est + justement ce qu'un diagnostic doit pouvoir rapporter. """ - plan = planifier(report) - if plan.vide: - info(_("fix_nothing")) - return False + try: + return _read_repo(root) + except typer.Exit: + return None + + +def _actions(root: Path, report: DoctorReport) -> dict[str, Action]: + """Les étapes que dsoxlab fait lui-même, sans commande externe ni sudo.""" + from ..config import set_active_provider + from ..infra.inventory import ajouter_include_ssh + from ..services.doctor_controles.catalogue import creer_cle_ssh + + def provider() -> str | None: + set_active_provider(root, report.provider) + return None + + def include() -> str | None: + try: + ajouter_include_ssh() + except OSError as exc: + return str(exc) + return None + + return { + "provider": provider, + "cle_ssh": lambda: creer_cle_ssh(root), + "ssh_include": include, + } + + +def _commande_de(etape: Etape) -> str: + if etape.remede is not None and etape.remede.lignes: + return etape.remede.lignes[0] + (" …" if len(etape.remede.lignes) > 1 else "") + return titre_etape(etape) + + +def _afficher_plan(plan: PlanCorrection, report: DoctorReport, ansible: list[str]) -> None: + console.print() + info(_("fix_plan_titre", count=plan.executables)) + if plan.sans_sudo: + console.print(Text(" " + _("fix_plan_sans_sudo"))) + for etape in plan.sans_sudo: + console.print(Text(f" {etape.numero:>2}. {_commande_de(etape)}"), soft_wrap=True) + if plan.root: + console.print(Text(" " + _("fix_plan_root"))) + for etape in plan.root: + ligne = f" {etape.numero:>2}. {titre_etape(etape)}" + if etape.remede is not None and etape.remede.reconnexion: + ligne += " " + _("fix_plan_reconnexion") + console.print(Text(ligne), soft_wrap=True) + console.print(Text(" " + shlex.join(ansible), style="dim"), soft_wrap=True) + if not _playbook_jouable(ansible[0]) and shutil.which("uv"): + console.print(Text(" " + _("fix_plan_ansible_d_abord")), soft_wrap=True) + _liste_du_plan("fix_plan_reverifiees", [e for e in plan.manuelles if _attend_une_etape(e)]) + _liste_du_plan("fix_plan_manuelles", [e for e in plan.manuelles if not _attend_une_etape(e)]) + for check in report.a_savoir: + console.print(Text(" " + _("fix_plan_a_savoir", label=check.label))) + + +def _liste_du_plan(cle: str, etapes: list[Etape]) -> None: + if not etapes: + return + console.print(Text(" " + _(cle))) + for etape in etapes: + console.print(Text(f" {etape.numero:>2}. {titre_etape(etape)}"), soft_wrap=True) + + +def _commande_playbook(chemin: Path) -> list[str]: + """L'appel d'ansible-playbook, avec la demande de mot de passe si sudo en exige un.""" + binaire = shutil.which("ansible-playbook") or str(Path.home() / ".local/bin/ansible-playbook") + commande = [binaire, "-i", "localhost,", "-c", "local", str(chemin)] + sans_mot_de_passe = subprocess.run( + ["sudo", "-n", "true"], capture_output=True, check=False, + ).returncode == 0 if shutil.which("sudo") else False + if not sans_mot_de_passe: + commande.insert(1, "--ask-become-pass") + return commande + + +def _interactif() -> bool: + """Un humain peut-il répondre ? Isolé pour que les tests le simulent.""" + return sys.stdin.isatty() + + +def _confirmer(plan: PlanCorrection, *, oui: bool) -> bool: + """Rien ne part sans `[y/N]` ou `--yes`, et sans terminal rien ne part sans `--yes`.""" + if oui: + return True + if not _interactif(): + error(_("fix_needs_yes")) + raise typer.Exit(1) + if typer.confirm(_("fix_confirmer", count=plan.executables), default=False): + return True + info(_("fix_annule")) + return False - for label, correctif in plan.manuels: - info(_("fix_manual", label=label, command=correctif.display)) + +def _reparer(report: DoctorReport, root: Path, *, oui: bool, clients: bool) -> bool: + """Joue le plan de `--fix`, et dit si la machine a changé. + + Le booléen rendu décide de la remesure de `--strict` : sans étape jouée, + remesurer coûterait un diagnostic complet pour un rapport identique. + """ + actions = _actions(root, report) + plan = planifier(report, clients=clients, actions=actions) if not plan.executables: + info(_("fix_rien_a_lancer") if plan.manuelles else _("fix_nothing")) return False - empechement = obstacle(plan) - if empechement is not None: - error(_(empechement)) - raise typer.Exit(1) - if plan.correctifs_sudo: - _preauthentifier(plan.correctifs_sudo) - - info(_("fix_count", count=len(plan.executables))) - appliquer( - plan.executables, - _executer_correctif, - sur_debut=_dire_la_commande, - sur_resultat=_dire_le_resultat, - ) + chemin = chemin_du_playbook() + ansible = _commande_playbook(chemin) if plan.root else [] + _afficher_plan(plan, report, ansible) + if not _confirmer(plan, oui=oui): + return False + + def remesurer() -> DoctorReport: + return collect_checks(root, _relire(root)) + + restantes = [*plan.sans_sudo, *plan.root] + if ( + _jouer_sans_sudo(plan.sans_sudo, actions, remesurer, restantes) + and plan.root + and _jouer_root(plan.root, ansible, chemin, remesurer, restantes) + ): + _dire_les_attendues([e for e in plan.manuelles if _attend_une_etape(e)], remesurer()) + return True + + +def _attend_une_etape(etape: Etape) -> bool: + """Un contrôle sans commande qui ne faisait qu'attendre une autre étape (le + firmware EFI attend libvirt) : il se revérifie, il n'est pas « à faire ».""" + return all(c.apres is not None for c in etape.controles) + + +def _dire_les_attendues(etapes: list[Etape], apres: DoctorReport) -> None: + for etape in etapes: + if etape_verifiee(etape, apres): + success(_("fix_attendue_ok", step=etape.numero, label=titre_etape(etape))) + else: + warn(_("fix_attendue_ko", step=etape.numero, label=titre_etape(etape))) + + +def _jouer_sans_sudo( + etapes: list[Etape], actions: dict[str, Action], + remesurer: Callable[[], DoctorReport], restantes: list[Etape], +) -> bool: + """Les étapes sans privilège, une à une, revérifiées ; rend False au premier échec.""" + for etape in etapes: + code, message = _jouer(etape, actions) + verifiee = code == 0 and etape_verifiee(etape, remesurer()) + application = Application(etape, code, verifiee, message) + _dire_le_resultat(application) + if not application.ok: + _arreter(restantes[restantes.index(etape):]) + return False + if not any(e.remede is not None and e.remede.root for e in restantes): + info(_("fix_rerun")) + return True + + +def _jouer_root( + etapes: list[Etape], ansible: list[str], chemin: Path, + remesurer: Callable[[], DoctorReport], restantes: list[Etape], +) -> bool: + """Les étapes root, toutes par le playbook du poste, puis revérifiées une à une.""" + if not _interactif() and "--ask-become-pass" in ansible: + # Sans terminal, personne ne peut taper le mot de passe : les étapes + # root s'affichent en bloc à coller (décision 2). + _bloc_root(etapes) + return False + if not _playbook_jouable(ansible[0]) and not _installer_ansible(): + warn(_("fix_pas_d_ansible")) + _bloc_root(etapes) + return False + chemin.parent.mkdir(parents=True, exist_ok=True) + chemin.write_text(playbook_du_poste(etapes, _current_user()), encoding="utf-8") + info(_("fix_playbook", path=str(chemin))) + code = subprocess.run(ansible, check=False).returncode + apres = remesurer() + for etape in etapes: + application = Application(etape, code, code == 0 and etape_verifiee(etape, apres)) + _dire_le_resultat(application) + if not application.ok: + _arreter(restantes[restantes.index(etape):]) + return False + if any(e.remede is not None and e.remede.reconnexion for e in etapes): + warn(_("fix_reconnexion_finale")) info(_("fix_rerun")) return True -def _dire_la_commande(label: str, correctif: Fix) -> None: - """La commande est nommée avant de partir : sa sortie arrive sur le même - terminal, et sans cette ligne rien ne dit à qui elle appartient.""" - info(f"[bold]{label}[/bold] → {correctif.display}") +def _playbook_jouable(binaire: str) -> bool: + return Path(binaire).is_file() and os.access(binaire, os.X_OK) -def _preauthentifier(combien: int) -> None: - """Un seul mot de passe pour toute la cascade. +def _installer_ansible() -> bool: + """Le playbook du poste a besoin d'Ansible : `--fix` l'installe d'abord, sans sudo. - Sans ce `sudo -v`, l'utilisateur peut avoir à le retaper à chaque commande, - si `timestamp_timeout` vaut 0 ou si la cascade dépasse cinq minutes. + Décision 3 du 2026-11-16. Le cas réel : une AlmaLinux 10 sans git ni + catalogue, où la seule étape est root (installer git) et où aucune étape + « installer Ansible » n'est au plan, faute de lab `vm`. """ - info(_("fix_sudo_preauth", count=combien)) - # check=False : un mot de passe refusé ou un Ctrl-C sur le prompt sudo est - # une réponse de l'utilisateur, pas une panne. On la traduit en message et - # en code de sortie, pas en trace Python. - if subprocess.run(["sudo", "-v"], check=False).returncode != 0: - error(_("fix_sudo_failed")) - raise typer.Exit(1) + if shutil.which("uv") is None: + return False + info(_("fix_installe_ansible")) + if _executer_correctif(Fix((("uv", "tool", "install", "ansible-core"),))) != 0: + return False + return _playbook_jouable(shutil.which("ansible-playbook") + or str(Path.home() / ".local/bin/ansible-playbook")) + + +def _jouer(etape: Etape, actions: dict[str, Action]) -> tuple[int, str | None]: + """Joue une étape sans sudo : une action de dsoxlab, ou un correctif sans shell.""" + _dire_la_commande(etape) + action = actions.get(etape.cle) + if action is not None: + message = action() + return (0, None) if message is None else (1, message) + correctif = next((c.fix for c in etape.controles if c.fix is not None), None) + if correctif is None: + return 1, None + return _executer_correctif(correctif), None + + +def _dire_la_commande(etape: Etape) -> None: + """La commande est nommée avant de partir : sa sortie arrive sur le même + terminal, et sans cette ligne rien ne dit à qui elle appartient.""" + console.print(Text(f" → {etape.numero}. {_commande_de(etape)}", style="bold"), soft_wrap=True) def _dire_le_resultat(application: Application) -> None: - if not application.ok: - error(_("fix_failure", label=application.label, code=application.code)) + etape = application.etape + titre = titre_etape(etape) + if application.code != 0: + error(_("fix_etape_ko", step=etape.numero, label=titre, code=application.code)) + if application.message: + console.print(Text(" " + application.message), soft_wrap=True) + return + if not application.verifiee: + error(_("fix_etape_non_verifiee", step=etape.numero, label=titre)) return - success(_("fix_success", label=application.label)) + success(_("fix_etape_ok", step=etape.numero, label=titre)) # L'effet différé se dit au moment du succès, sans quoi le prochain # `doctor` remontre la même ligne rouge et l'utilisateur conclut, à tort, # que le correctif a échoué. avis = application.avis_differe if avis is not None: - warn(_(avis, label=application.label)) + warn(_(avis, label=titre)) + + +def _arreter(restantes: list[Etape]) -> None: + numeros = ", ".join(str(e.numero) for e in restantes) + error(_("fix_arret", steps=numeros)) + + +def _bloc_root(etapes: list[Etape]) -> None: + """Le repli : les étapes root à coller, puisque dsoxlab ne les lance pas.""" + warn(_("fix_bloc_root")) + for etape in etapes: + console.print(Text(f" {etape.numero:>2}. {titre_etape(etape)}", style="bold")) + assert etape.remede is not None + for ligne in etape.remede.lignes: + console.print(Text(" " + ligne), soft_wrap=True) def _executer_correctif(correctif: Fix) -> int: @@ -340,10 +551,7 @@ def _executer_correctif(correctif: Fix) -> int: Chaque argv part tel quel à ``run_command`` : aucun token n'est redécoupé en route, un argument portant une espace arrive entier à la commande. La - séquence s'arrête au premier échec, dont le code est rendu. ``check=False`` - parce que `--fix` joue une CASCADE : un correctif en échec doit être - signalé puis laisser tourner les suivants ; lever ici abandonnerait les - réparations restantes sur la première qui rate. + séquence s'arrête au premier échec, dont le code est rendu. La sortie capturée est rejouée sur les flux d'origine : l'utilisateur voit ce qu'apt ou systemctl ont dit, en particulier quand ça a raté. diff --git a/src/dsoxlab/cli/instructeur.py b/src/dsoxlab/cli/instructeur.py index 5c22008..198b53f 100644 --- a/src/dsoxlab/cli/instructeur.py +++ b/src/dsoxlab/cli/instructeur.py @@ -22,7 +22,6 @@ from __future__ import annotations import logging -import subprocess from pathlib import Path from typing import Annotated @@ -83,25 +82,13 @@ def instructor_bootstrap( info(_("bootstrap_key_exists", path=private_key)) else: info(_("bootstrap_generating_key", path=private_key)) - ssh_dir.mkdir(parents=True, exist_ok=True) - ssh_dir.chmod(0o700) - # check=False : l'échec est traduit en message + Exit(2) juste en - # dessous. Une CalledProcessError sortirait la trace Python de - # ssh-keygen au visage du formateur, sans lui dire quoi faire. - result = subprocess.run( - [ - "ssh-keygen", - "-t", "ed25519", - "-N", "", # pas de passphrase - "-C", "dsoxlab-lab", - "-f", str(private_key), - ], - capture_output=True, - text=True, - check=False, - ) - if result.returncode != 0: - error(_("bootstrap_keygen_failed", stderr=result.stderr.strip())) + # La même fonction que `doctor --fix` : un échec de ssh-keygen revient + # en message, traduit ici en Exit(2), jamais en trace Python. + from ..services.doctor_controles.catalogue import creer_cle_ssh + + echec = creer_cle_ssh(root) + if echec is not None: + error(_("bootstrap_keygen_failed", stderr=echec)) raise typer.Exit(2) success(_("bootstrap_key_created", path=private_key)) diff --git a/src/dsoxlab/i18n/strings/en.py b/src/dsoxlab/i18n/strings/en.py index f558863..0b448bb 100644 --- a/src/dsoxlab/i18n/strings/en.py +++ b/src/dsoxlab/i18n/strings/en.py @@ -966,11 +966,17 @@ [dim]--json[/dim] Every issue with its rule key, as a document. Same exit code: 1 as soon as one lab fails. - [cyan]doctor[/cyan] Diagnose the environment. The [bold]Required[/bold] table lists what - blocks this very repo; a hypervisor useless here stays - [bold]Informational[/bold] and never shows up as an error. - [dim]--fix[/dim] Remediate the missing required components. - Informational components are left alone. + [cyan]doctor[/cyan] Diagnose the environment: every missing step at once, + numbered in the order to do them, each command on its + own line, ready to paste. A component this repo does not + need stays optional and never shows up as an error. + [dim]--fix[/dim] Show the plan, then run it once confirmed: steps + without sudo by dsoxlab, sudo steps through one + ansible-playbook run that asks for your password once. + Each step is checked again; the first failure stops. + [dim]--yes[/dim] Run the plan without asking (needed without a terminal). + [dim]--clients[/dim] With --fix, also install the optional Docker and Incus. + [dim]-v[/dim] Every check, and the warnings on green lines. [dim]--json[/dim] The diagnosis as a document, each check carrying a stable key and state. Not with [bold]--fix[/bold]. [dim]--strict[/dim] Turn the diagnosis into an exit code, for a script: @@ -1520,6 +1526,59 @@ "check_tf_providers": "Terraform providers", "check_ansible": "ansible-playbook", "check_collections": "Ansible collections", + "etape_git": 'Install git', + "etape_provider": 'Choose the provider for the machines', + "etape_kvm": 'Install libvirt and QEMU', + "etape_libvirtd": 'Start libvirt, now and at every boot', + "etape_groupes": "Give your account access to the hypervisor, then log in again", + "etape_libvirt_pool": 'Create the libvirt disk pool', + "etape_efi": 'Install the EFI firmware for the machines', + "etape_terraform": "Install Terraform, from HashiCorp's official repository", + "etape_ansible": 'Install Ansible', + "etape_collections": "Install the catalogue's Ansible collections", + "etape_cle_ssh": "Create the catalogue's SSH key", + "etape_ssh_include": "Make ssh read dsoxlab's fragments", + "etape_incus": 'Install Incus', + "etape_docker": "Install Docker, from Docker's official repository", + "etape_labs": 'Get a catalogue', + "etape_reparer": 'Fix: {label}', + "doctor_entete_catalogue": 'catalogue {id}', + "doctor_entete_labs": '{count} labs', + "doctor_entete_labs_1": '1 lab', + "doctor_entete_sans_catalogue": 'no catalogue here', + "doctor_entete_provider": 'provider {provider}', + "doctor_entete_provider_a_confirmer": 'provider {provider} (to confirm, step {step})', + "doctor_n_etapes": '{count} steps are missing. Do them in this order.', + "doctor_n_etapes_1": '1 step is missing.', + "doctor_etape_apres": '(do step {step} first)', + "doctor_etape_reconnexion": 'Then log out and log back in.', + "doctor_a_savoir_titre": 'Good to know (no command fixes it)', + "doctor_a_savoir_une_machine": 'Bring up only the machine of the lab you play:', + "doctor_non_mesure": '? Not measured: {label} ({detail}). Run dsoxlab doctor again.', + "doctor_deja_pret": 'Already ready: {items}', + "doctor_tout_pret": 'Everything is ready. {count} required checks pass.', + "doctor_tout_pret_1": 'Everything is ready. 1 required check passes.', + "doctor_facultatif_installe": 'Optional here, installed: {items}', + "doctor_facultatif_absent": 'Optional here: {items}. Install them too: dsoxlab doctor --fix --clients', + "doctor_mises_en_garde": '{count} warnings on green lines: dsoxlab doctor -v', + "doctor_mises_en_garde_1": '1 warning on a green line: dsoxlab doctor -v', + "doctor_tout_corriger": 'Fix everything at once:', + "check_groupes": 'kvm and libvirt groups', + "check_efi": 'EFI firmware', + "check_cle_ssh": 'Catalogue SSH key', + "check_ssh_include": '~/.ssh/config Include', + "detail_terraform_depasse": 'A newer version exists ({latest}). It is not required.', + "detail_collections_apres_ansible": '{count} collection(s) required: checked once Ansible is installed', + "detail_groupes_ok": 'your account can reach libvirt and /dev/kvm', + "detail_groupes_apres_kvm": 'groups to join once libvirt is installed: {groups}', + "detail_groupes_reconnexion": 'you are in {groups}, but this session was opened before: log out and back in', + "detail_groupes_manquants": 'your account is not in {groups}: libvirt refuses it without sudo', + "detail_efi_apres_kvm": 'checked once libvirt is installed', + "detail_efi_absent": 'no EFI firmware without Secure Boot found: provision cannot start a machine', + "detail_incus_sans_paquet": "not found, and not packaged in this distribution's base repositories", + "detail_cle_ssh_absente": '{path} is missing: provision cannot put a key on the machines', + "detail_ssh_include_absent": '~/.ssh/config does not read ~/.ssh/config.d/: `ssh ` will fail', + "detail_pool_apres_kvm": "pool '{pool}' checked once libvirt is installed", "check_libvirt_pool": "libvirt pool", "check_iso_tool": "genisoimage", "check_labs": "Labs detected", @@ -1566,7 +1625,7 @@ "{providers} (pinned by terraform init)", "detail_tf_providers_absents": "no provider pinned yet: provision has not run for this repository.", - "detail_kvm_missing": "not found", + "detail_kvm_missing": "virsh not found: provision cannot create any machine", "detail_pytest_missing": "not found", "detail_pytest_bundled": "bundled with dsoxlab", "detail_pytest_via": "via {cmd}", @@ -1716,26 +1775,38 @@ "standard output, which would leave the document unreadable. Run " "`dsoxlab doctor --json` to read the diagnosis, then `dsoxlab doctor " "--fix` to act on it.", - "fix_count": "{count} component(s) to fix…", - "fix_needs_tty": - "At least one remediation requires sudo, but this shell is not " - "interactive (no TTY). Run dsoxlab from a terminal, or apply the " - "commands by hand.", - "fix_no_sudo": "sudo not found in PATH: remediation is impossible.", - "fix_sudo_preauth": - "[bold]{count}[/bold] command(s) require sudo. Pre-authentication " - "below (a single prompt for the whole run):", - "fix_sudo_failed": "sudo pre-authentication failed: remediations aborted.", - "fix_success": "{label}: remediation successful.", - "fix_manual": - "{label}: manual step, shown but never run automatically → {command}", + "opt_doctor_yes": 'With --fix: run the plan without asking for confirmation', + "opt_doctor_clients": 'With --fix: also install the optional components (Docker, Incus)', + "opt_doctor_verbose": 'Show every check, and the warnings on green lines', + "fix_plan_titre": 'Plan: {count} step(s). Each one is checked again right after; the first failure stops everything.', + "fix_plan_sans_sudo": 'Without sudo, run by dsoxlab:', + "fix_plan_root": 'With sudo, by the workstation playbook (ansible-playbook asks for your sudo password once):', + "fix_plan_reconnexion": '(log in again afterwards)', + "fix_plan_manuelles": 'To do yourself (never run automatically):', + "fix_plan_a_savoir": 'Not handled: {label} (see "Good to know").', + "fix_rien_a_lancer": 'Nothing --fix can run: the remaining steps are yours to do (see above).', + "fix_needs_yes": 'Nothing was run: this shell has no terminal to confirm the plan. Add --yes to run it.', + "fix_confirmer": 'Run these {count} step(s)?', + "fix_annule": 'Nothing was run.', + "fix_pas_d_ansible": 'ansible-playbook is not available: the sudo steps are shown below, to paste in a terminal.', + "fix_playbook": 'Workstation playbook written to {path}', + "fix_etape_ok": '{step}. {label}: done, checked again.', + "fix_etape_ko": '{step}. {label}: failed (code {code}).', + "fix_etape_non_verifiee": '{step}. {label}: the command succeeded, but the check is still not green.', + "fix_arret": 'Stopped. Remaining steps: {steps}. Fix the cause, then run again: dsoxlab doctor --fix', + "fix_bloc_root": 'Paste these sudo steps in a terminal, in this order:', + "fix_reconnexion_finale": 'Log out and back in before running doctor again: the kvm and libvirt groups only apply to a new session.', + "fix_plan_ansible_d_abord": 'Ansible is installed first, without sudo: uv tool install ansible-core', + "fix_installe_ansible": 'Installing Ansible first (uv tool install ansible-core): the workstation playbook needs it.', + "fix_plan_reverifiees": 'Checked again after the playbook (they were waiting for it):', + "fix_attendue_ok": '{step}. {label}: checked after the playbook, ready.', + "fix_attendue_ko": '{step}. {label}: still missing after the playbook: run dsoxlab doctor to see what to do.', "fix_needs_relogin": "{label}: fixed, but the change only takes effect after you log out " "and back in. This line will stay red until then; it is not a failure.", "fix_needs_reboot": "{label}: fixed, but the change only takes effect after a reboot. " "This line will stay red until then; it is not a failure.", - "fix_failure": "{label}: remediation failed (code {code}).", "fix_rerun": "Run [bold]dsoxlab doctor[/bold] again to verify.", # ── console — labs table ────────────────────────────────────────────────── diff --git a/src/dsoxlab/i18n/strings/fr.py b/src/dsoxlab/i18n/strings/fr.py index b76423a..aadd6ae 100644 --- a/src/dsoxlab/i18n/strings/fr.py +++ b/src/dsoxlab/i18n/strings/fr.py @@ -985,11 +985,18 @@ [dim]--json[/dim] Chaque anomalie avec la clé de sa règle, en document. Même code de retour : 1 dès qu'un lab échoue. - [cyan]doctor[/cyan] Diagnostique l'environnement. Le tableau [bold]Requis[/bold] liste ce qui - bloque ce dépôt-ci ; un hyperviseur inutile ici reste - [bold]Informatif[/bold] et ne s'affiche jamais en erreur. - [dim]--fix[/dim] Applique la remédiation des composants requis manquants. - Les composants informatifs ne sont pas touchés. + [cyan]doctor[/cyan] Diagnostique l'environnement : toutes les étapes qui + manquent d'un coup, numérotées dans l'ordre où les faire, + chaque commande seule sur sa ligne, prête à coller. Un + composant dont ce dépôt n'a pas besoin reste facultatif + et ne s'affiche jamais en erreur. + [dim]--fix[/dim] Affiche le plan, puis le lance une fois confirmé : les + étapes sans sudo par dsoxlab, celles avec sudo par un seul + ansible-playbook qui demande votre mot de passe une fois. + Chaque étape est revérifiée ; le premier échec arrête tout. + [dim]--yes[/dim] Lance le plan sans demander (nécessaire sans terminal). + [dim]--clients[/dim] Avec --fix, installe aussi Docker et Incus facultatifs. + [dim]-v[/dim] Chaque contrôle, et les mises en garde des lignes vertes. [dim]--json[/dim] Le diagnostic en document, chaque contrôle portant une clé et un état stables. Pas avec [bold]--fix[/bold]. [dim]--strict[/dim] Traduit le diagnostic en code de sortie, pour un script : @@ -1552,6 +1559,59 @@ "check_tf_providers": "Providers Terraform", "check_ansible": "ansible-playbook", "check_collections": "Collections Ansible", + "etape_git": 'Installer git', + "etape_provider": 'Choisir le provider des machines', + "etape_kvm": 'Installer libvirt et QEMU', + "etape_libvirtd": 'Démarrer libvirt, maintenant et à chaque démarrage', + "etape_groupes": "Donner à votre compte l'accès à l'hyperviseur, puis vous reconnecter", + "etape_libvirt_pool": 'Créer le pool de disques de libvirt', + "etape_efi": 'Installer le firmware EFI des machines', + "etape_terraform": "Installer Terraform, depuis le dépôt officiel d'HashiCorp", + "etape_ansible": 'Installer Ansible', + "etape_collections": 'Installer les collections Ansible du catalogue', + "etape_cle_ssh": 'Créer la clé SSH du catalogue', + "etape_ssh_include": 'Faire lire à ssh les fragments de dsoxlab', + "etape_incus": 'Installer Incus', + "etape_docker": 'Installer Docker, depuis le dépôt officiel de Docker', + "etape_labs": 'Récupérer un catalogue', + "etape_reparer": 'Réparer : {label}', + "doctor_entete_catalogue": 'catalogue {id}', + "doctor_entete_labs": '{count} labs', + "doctor_entete_labs_1": '1 lab', + "doctor_entete_sans_catalogue": 'aucun catalogue ici', + "doctor_entete_provider": 'provider {provider}', + "doctor_entete_provider_a_confirmer": 'provider {provider} (à confirmer, étape {step})', + "doctor_n_etapes": '{count} étapes manquent. Faites-les dans cet ordre.', + "doctor_n_etapes_1": '1 étape manque.', + "doctor_etape_apres": "(faire l'étape {step} d'abord)", + "doctor_etape_reconnexion": 'Puis fermez votre session et rouvrez-la.', + "doctor_a_savoir_titre": 'À savoir (aucune commande ne le corrige)', + "doctor_a_savoir_une_machine": 'Montez seulement la machine du lab que vous jouez :', + "doctor_non_mesure": '? Non mesuré : {label} ({detail}). Relancez dsoxlab doctor.', + "doctor_deja_pret": 'Déjà prêt : {items}', + "doctor_tout_pret": 'Tout est prêt. {count} contrôles requis passent.', + "doctor_tout_pret_1": 'Tout est prêt. 1 contrôle requis passe.', + "doctor_facultatif_installe": 'Facultatif ici, installé : {items}', + "doctor_facultatif_absent": 'Facultatif ici : {items}. Les installer aussi : dsoxlab doctor --fix --clients', + "doctor_mises_en_garde": '{count} mises en garde sur des lignes vertes : dsoxlab doctor -v', + "doctor_mises_en_garde_1": '1 mise en garde sur une ligne verte : dsoxlab doctor -v', + "doctor_tout_corriger": "Tout corriger d'un coup :", + "check_groupes": 'Groupes kvm et libvirt', + "check_efi": 'Firmware EFI', + "check_cle_ssh": 'Clé SSH du catalogue', + "check_ssh_include": 'Include de ~/.ssh/config', + "detail_terraform_depasse": "Une version plus récente existe ({latest}). Elle n'est pas exigée.", + "detail_collections_apres_ansible": '{count} collection(s) exigée(s) : contrôlées une fois Ansible installé', + "detail_groupes_ok": 'votre compte peut parler à libvirt et ouvrir /dev/kvm', + "detail_groupes_apres_kvm": 'groupes à rejoindre une fois libvirt installé : {groups}', + "detail_groupes_reconnexion": 'vous êtes dans {groups}, mais cette session a été ouverte avant : déconnectez-vous puis reconnectez-vous', + "detail_groupes_manquants": "votre compte n'est pas dans {groups} : libvirt le refuse sans sudo", + "detail_efi_apres_kvm": 'contrôlé une fois libvirt installé', + "detail_efi_absent": 'aucun firmware EFI sans Secure Boot trouvé : provision ne peut démarrer aucune machine', + "detail_incus_sans_paquet": 'introuvable, et absent des dépôts de base de cette distribution', + "detail_cle_ssh_absente": '{path} manque : provision ne peut poser aucune clé sur les machines', + "detail_ssh_include_absent": '~/.ssh/config ne lit pas ~/.ssh/config.d/ : `ssh ` échouera', + "detail_pool_apres_kvm": 'pool « {pool} » contrôlé une fois libvirt installé', "check_libvirt_pool": "Pool libvirt", "check_iso_tool": "genisoimage", "check_labs": "Labs détectés", @@ -1598,7 +1658,7 @@ "{providers} (épinglés par terraform init)", "detail_tf_providers_absents": "aucun provider épinglé : provision n'a pas encore tourné pour ce dépôt.", - "detail_kvm_missing": "introuvable", + "detail_kvm_missing": "virsh introuvable : provision ne peut créer aucune machine", "detail_pytest_missing": "introuvable", "detail_pytest_bundled": "embarqué avec dsoxlab", "detail_pytest_via": "via {cmd}", @@ -1763,20 +1823,32 @@ "écrivent sur la sortie standard, et le document en deviendrait " "illisible. Lancez `dsoxlab doctor --json` pour lire le diagnostic, " "puis `dsoxlab doctor --fix` pour agir dessus.", - "fix_count": "{count} composant(s) à corriger…", - "fix_needs_tty": - "Au moins une remédiation exige sudo, mais ce shell n'est pas " - "interactif (pas de TTY). Lancez dsoxlab depuis un terminal, ou " - "appliquez les commandes à la main.", - "fix_no_sudo": "sudo introuvable dans le PATH : remédiation impossible.", - "fix_sudo_preauth": - "[bold]{count}[/bold] commande(s) nécessitent sudo. " - "Pré-authentification ci-dessous (un seul prompt pour toute la cascade) :", - "fix_sudo_failed": "Pré-authentification sudo échouée : remédiations abandonnées.", - "fix_success": "{label} : remédiation réussie.", - "fix_manual": - "{label} : geste manuel, affiché mais jamais exécuté automatiquement " - "→ {command}", + "opt_doctor_yes": 'Avec --fix : lancer le plan sans demander de confirmation', + "opt_doctor_clients": 'Avec --fix : installer aussi les composants facultatifs (Docker, Incus)', + "opt_doctor_verbose": 'Montrer chaque contrôle, et les mises en garde des lignes vertes', + "fix_plan_titre": 'Plan : {count} étape(s). Chacune est revérifiée juste après ; arrêt au premier échec.', + "fix_plan_sans_sudo": 'Sans sudo, lancées par dsoxlab :', + "fix_plan_root": 'Avec sudo, par le playbook du poste (ansible-playbook vous demandera votre mot de passe sudo une fois) :', + "fix_plan_reconnexion": '(reconnexion nécessaire ensuite)', + "fix_plan_manuelles": 'À faire vous-même (jamais lancé automatiquement) :', + "fix_plan_a_savoir": 'Non traité : {label} (voir « À savoir »).', + "fix_rien_a_lancer": 'Rien que --fix puisse lancer : les étapes restantes sont à faire vous-même (voir plus haut).', + "fix_needs_yes": "Rien n'a été lancé : ce shell n'a pas de terminal pour confirmer le plan. Ajoutez --yes pour le lancer.", + "fix_confirmer": 'Lancer ces {count} étape(s) ?', + "fix_annule": "Rien n'a été lancé.", + "fix_pas_d_ansible": "ansible-playbook n'est pas disponible : les étapes avec sudo sont affichées ci-dessous, à coller dans un terminal.", + "fix_playbook": 'Playbook du poste écrit dans {path}', + "fix_etape_ok": '{step}. {label} : fait, revérifié.', + "fix_etape_ko": '{step}. {label} : échec (code {code}).', + "fix_etape_non_verifiee": "{step}. {label} : la commande a réussi, mais le contrôle n'est toujours pas vert.", + "fix_arret": 'Arrêt. Restent les étapes : {steps}. Corrigez la cause, puis relancez : dsoxlab doctor --fix', + "fix_bloc_root": 'Collez ces étapes avec sudo dans un terminal, dans cet ordre :', + "fix_reconnexion_finale": "Reconnectez-vous avant de relancer doctor : les groupes kvm et libvirt ne valent qu'après une nouvelle session.", + "fix_plan_ansible_d_abord": "Ansible est installé d'abord, sans sudo : uv tool install ansible-core", + "fix_installe_ansible": "Installation d'Ansible d'abord (uv tool install ansible-core) : le playbook du poste en a besoin.", + "fix_plan_reverifiees": "Revérifiés après le playbook (ils l'attendaient) :", + "fix_attendue_ok": '{step}. {label} : contrôlé après le playbook, prêt.', + "fix_attendue_ko": '{step}. {label} : manque encore après le playbook : lancez dsoxlab doctor pour savoir quoi faire.', "fix_needs_relogin": "{label} : corrigé, mais le changement ne prend effet qu'après une " "déconnexion puis une reconnexion. Cette ligne restera rouge d'ici " @@ -1785,7 +1857,6 @@ "{label} : corrigé, mais le changement ne prend effet qu'après un " "redémarrage. Cette ligne restera rouge d'ici là ; ce n'est pas un " "échec.", - "fix_failure": "{label} : échec de la remédiation (code {code}).", "fix_rerun": "Relancez [bold]dsoxlab doctor[/bold] pour vérifier.", # ── console — tableau des labs ──────────────────────────────────────────── diff --git a/src/dsoxlab/infra/inventory.py b/src/dsoxlab/infra/inventory.py index 2235c96..bec0b17 100644 --- a/src/dsoxlab/infra/inventory.py +++ b/src/dsoxlab/infra/inventory.py @@ -350,6 +350,32 @@ def ssh_config_include_present() -> bool: ) +#: La ligne que ``doctor --fix`` pose en tête de ``~/.ssh/config``. +LIGNE_INCLUDE = "Include ~/.ssh/config.d/*.conf" + + +def ajouter_include_ssh() -> None: + """Pose la ligne ``Include`` en TÊTE de ``~/.ssh/config``, fichier vide ou absent compris. + + En tête, parce qu'un ``Include`` placé après un bloc ``Host`` ne vaut que + pour ce bloc. Et sans ``sed -i '1i …'``, qui n'écrit rien dans un fichier + vide, le cas d'un poste neuf (mesuré le 2026-11-16 sur AlmaLinux 10). Le + fichier est réécrit d'un coup (fichier voisin puis ``replace``), en 0600 : + ssh refuse un ``config`` lisible par les autres. + """ + dossier = Path.home() / ".ssh" + dossier.mkdir(mode=0o700, exist_ok=True) + principal = dossier / "config" + try: + actuel = principal.read_text(encoding="utf-8") + except FileNotFoundError: + actuel = "" + provisoire = dossier / "config.dsoxlab" + provisoire.write_text(f"{LIGNE_INCLUDE}\n{actuel}", encoding="utf-8") + provisoire.chmod(0o600) + provisoire.replace(principal) + + def write_user_ssh_config( inventory: dict[str, Any], repo_meta: RepoMetadata ) -> Path: diff --git a/src/dsoxlab/reporting/console.py b/src/dsoxlab/reporting/console.py index ff458ed..aac9bce 100644 --- a/src/dsoxlab/reporting/console.py +++ b/src/dsoxlab/reporting/console.py @@ -12,7 +12,6 @@ from pathlib import Path from typing import Any -from rich import box from rich.console import Console from rich.errors import MarkupError from rich.padding import Padding @@ -30,9 +29,6 @@ from ..services.audit_pedagogique import RapportPedagogique from ..services.catalog import CatalogueConnu, CatalogueInstalle from ..services.doctor import ( - STATE_CHOICE_REQUIRED, - STATE_UNKNOWN, - Check, DoctorReport, ) from ..services.infra_state_service import EtatHote, EtatInfra @@ -612,65 +608,6 @@ def print_structure_reports(reports: list[StructureReport]) -> None: # ── doctor ──────────────────────────────────────────────────────────────────── -def _libelle_statut(check: Check, *, blocking: bool) -> str: - """Le mot qui rend l'état d'un contrôle, dans la langue du lecteur. - - L'état, lui, est un jeton stable porté par le contrôle. Un composant - informatif absent n'est pas un échec, et le vocabulaire change donc de - tableau ; ce qu'une intégration lit, elle, ne change jamais. - """ - if check.state == STATE_CHOICE_REQUIRED: - return _("status_choose") - if check.state == STATE_UNKNOWN: - # Rien mesuré : ni le vert qui rassure à tort, ni le rouge qui accuse - # sans preuve. Le mot le dit dans les deux tableaux. - return _("status_unknown") - if blocking: - return _("status_ok") if check.ok else _("status_ko") - return _("status_present") if check.ok else _("status_absent") - - -def _doctor_table(title: str, checks: list[Check], *, blocking: bool) -> Table: - """Un tableau de checks. - - ``blocking=False`` change le vocabulaire du statut : un composant - informatif absent n'est pas un échec, et l'afficher en rouge est - précisément ce qui décourageait au premier lancement. - """ - # La colonne de remédiation n'existe que s'il y a quelque chose à remédier. - # Sur un poste sain, elle était vide de haut en bas et prenait pourtant sa - # part de largeur : à 80 colonnes, le détail était alors tronqué, et c'est - # lui qui porte la version trouvée et le chemin du composant. Une colonne - # entièrement vide ne dit rien, et elle coûtait la seule information utile. - avec_remediation = any(not check.ok and check.remediation for check in checks) - - # `SIMPLE_HEAD` plutôt que le cadre plein : vingt lignes de filets verticaux - # pour un diagnostic qui est vert de haut en bas, c'est du bruit qui occupe - # six colonnes et attire l'œil là où il n'y a rien à voir. Un trait sous - # l'en-tête suffit à dire « tableau ». - table = Table(title=title, show_header=True, box=box.SIMPLE_HEAD, pad_edge=False) - table.add_column(_('col_component')) - # Le statut tient en un signe. « ✔ OK » disait deux fois la même chose, et - # prenait cinq colonnes au détail, qui porte la version et le chemin. - table.add_column(_('col_status'), justify="center", no_wrap=True) - table.add_column(_('col_detail'), overflow="fold") - if avec_remediation: - # `fold` plutôt que le repli par mots : une remédiation est une - # commande, et une commande porte des chemins. Rich ne coupe pas un - # mot plus long que la colonne, il le tronque par un « … » — et une - # commande tronquée ne se copie pas, donc ne répare rien. Mesuré sur - # `ansible-galaxy collection install -r `. - table.add_column(_('col_remediation'), overflow="fold") - - for check in checks: - status = _libelle_statut(check, blocking=blocking) - cellules = [check.label, status, check.detail] - if avec_remediation: - cellules.append("" if check.ok else f"[dim]{check.remediation}[/dim]") - table.add_row(*cellules) - return table - - def print_infra_status(etat: EtatInfra) -> None: """Qui répond, qui ne répond pas, et pourquoi. @@ -968,27 +905,11 @@ def print_lab_state(etat: LabState) -> None: border_style=teinte, expand=False)) -def print_doctor(report: DoctorReport) -> None: - """Affiche le diagnostic : ce qui bloque, puis ce qui informe.""" - console.print(_doctor_table( - _('doctor_table_title'), report.required, blocking=True, - )) +def print_doctor(report: DoctorReport, *, verbose: bool = False) -> None: + """Affiche le diagnostic en étapes numérotées (voir ``doctor_rendu``).""" + from .doctor_rendu import print_doctor as rendre - if report.optional: - # Titre et pied viennent du rapport : « non requis ici » est faux quand - # le dépôt a des labs vm et qu'aucun provider n'est encore choisi. - console.print(_doctor_table( - _(report.optional_title_key), report.optional, blocking=False, - )) - console.print(f"[dim]{_(report.optional_hint_key)}[/dim]") - - for note in report.notes: - console.print(f"[cyan]ℹ[/cyan] {note}") - - if report.fixable(): - console.print(f"[yellow]{_('doctor_fix_hint')}[/yellow]") - elif report.failing(): - console.print(f"[yellow]{_('doctor_manual_hint')}[/yellow]") + rendre(report, verbose=verbose) # ── messages simples ────────────────────────────────────────────────────────── diff --git a/src/dsoxlab/reporting/doctor_rendu.py b/src/dsoxlab/reporting/doctor_rendu.py new file mode 100644 index 0000000..8b189c9 --- /dev/null +++ b/src/dsoxlab/reporting/doctor_rendu.py @@ -0,0 +1,191 @@ +"""Le rendu de ``dsoxlab doctor`` : des étapes numérotées, pas un tableau. + +Maquettes validées le 2026-11-16. Trois règles : + +- **chaque commande seule sur sa ligne**, jamais dans une cellule : le tableau + d'avant coupait les commandes longues (Terraform, le pool), qui ne se + collaient plus ; +- **tous les manques en une passe**, dans l'ordre où les faire ; +- **un résumé à la fin** : combien d'étapes, ou « tout est prêt », puis la + commande unique. + +Les commandes et les détails s'affichent en ``Text`` littéral : une commande +porte des crochets (``[arch=...]``) que Rich lirait comme du balisage. +""" + +from __future__ import annotations + +import re + +from rich.text import Text + +from ..i18n import _ +from ..services.doctor_controles.modele import STATE_OK, STATE_UNKNOWN, Check, DoctorReport +from ..services.doctor_controles.remedes import TABLE +from ..services.doctor_etapes import Etape, Plan, construire +from .console import console + +#: Un détail plus long ne tient pas dans la ligne « Déjà prêt » : on n'y garde +#: que le libellé. +_DETAIL_COURT = 28 + +#: Une version dans un détail (« git version 2.43.0 », « Terraform v1.16.1 ») : +#: c'est elle qu'on garde dans le résumé, pas la phrase de l'outil. +_VERSION = re.compile(r"(? str: + """Une phrase au singulier ou au pluriel : la clé ``_1`` porte le singulier.""" + return _(f"{cle}_1") if count == 1 else _(cle, count=count) + + +def _ligne(texte: str, style: str = "", retrait: int = 0) -> None: + console.print(Text(" " * retrait + texte, style=style), soft_wrap=True) + + +def _resume_long(texte: str) -> None: + """Une ligne de prose : Rich la replie entre les mots, ce n'est pas une commande.""" + console.print(Text(texte, style="dim")) + + +def _commande(ligne: str) -> None: + # `soft_wrap` : le terminal replie la ligne s'il le faut, Rich ne la coupe + # pas. Une commande coupée par un retour à la ligne ne se colle plus. + console.print(Text(" " + ligne, style="bold"), soft_wrap=True) + + +def titre_etape(etape: Etape) -> str: + """Le titre d'une étape : un verbe pour les étapes connues, le composant sinon.""" + if etape.cle in TABLE or etape.cle == "labs": + return _(f"etape_{etape.cle}") + return _("etape_reparer", label=etape.controles[0].label) + + +def _detail(etape: Etape) -> str: + porteur = next((c for c in etape.controles if c.key == etape.cle), etape.controles[0]) + return porteur.detail + + +def _entete(report: DoctorReport, plan: Plan) -> None: + morceaux = ["dsoxlab doctor"] + if report.catalogue: + morceaux.append(_("doctor_entete_catalogue", id=report.catalogue)) + morceaux.append(_compte("doctor_entete_labs", report.nb_labs)) + else: + morceaux.append(_("doctor_entete_sans_catalogue")) + if report.systeme: + morceaux.append(report.systeme) + if report.provider: + etape = plan.etape_de("provider") + if report.provider_a_confirmer and etape is not None: + morceaux.append(_("doctor_entete_provider_a_confirmer", + provider=report.provider, step=etape.numero)) + else: + morceaux.append(_("doctor_entete_provider", provider=report.provider)) + _ligne(" · ".join(morceaux), style="bold") + + +def _etape(etape: Etape) -> None: + titre = f"{etape.numero:>2}. {titre_etape(etape)}" + texte = Text(titre, style="bold") + if etape.apres is not None: + texte.append(" " + _("doctor_etape_apres", step=etape.apres), style="dim") + console.print(texte, soft_wrap=True) + _ligne(_detail(etape), retrait=4) + if etape.remede is not None: + for ligne in etape.remede.lignes: + _commande(ligne) + if etape.remede.reconnexion: + _ligne(_("doctor_etape_reconnexion"), retrait=4) + else: + indice = next((c.hint for c in etape.controles if c.hint), None) + if indice: + _ligne(indice, retrait=6) + + +def _resume(check: Check) -> str: + """Un contrôle vert en quelques mots : son nom, et sa version s'il en a une.""" + version = _VERSION.search(check.detail or "") + if version is not None: + return f"{check.label} {version.group(0)}" + if check.detail and len(check.detail) <= _DETAIL_COURT and check.detail not in check.label: + return f"{check.label} {check.detail}" + return check.label + + +def _resume_court(checks: list[Check]) -> str: + return " · ".join(_resume(c) for c in checks if c.key not in _TAIRE_SI_PRET) + + +def _a_savoir(report: DoctorReport) -> None: + if not report.a_savoir: + return + console.print() + _ligne(_("doctor_a_savoir_titre"), style="bold") + for check in report.a_savoir: + _ligne("⚠ " + check.detail, style="yellow", retrait=1) + if check.hint: + _ligne(_("doctor_a_savoir_une_machine"), retrait=3) + _commande(check.hint) + + +def _facultatifs(report: DoctorReport, plan: Plan) -> None: + installes = [c for c in report.optional if c.ok] + if installes: + _resume_long(_("doctor_facultatif_installe", items=_resume_court(installes))) + if plan.facultatives: + noms = ", ".join(e.controles[0].label for e in plan.facultatives) + _ligne(_("doctor_facultatif_absent", items=noms), style="dim") + + +def _verbeux(report: DoctorReport) -> None: + """Chaque contrôle, sa mise en garde éventuelle, et les notes de classement.""" + console.print() + for check in [*report.required, *report.a_savoir, *report.optional]: + signe = {STATE_OK: "✔", STATE_UNKNOWN: "?"}.get(check.state, "✘") + _ligne(f"{signe} {check.label} : {check.detail}") + if check.mise_en_garde: + _ligne("⚠ " + check.mise_en_garde, style="yellow", retrait=3) + for note in report.notes: + _ligne("ℹ " + note, style="cyan") + + +def print_doctor(report: DoctorReport, *, verbose: bool = False) -> None: + """Affiche le diagnostic en étapes, puis ce qui est prêt, puis le résumé.""" + plan = construire(report) + _entete(report, plan) + + console.print() + if plan.etapes: + _ligne(_compte("doctor_n_etapes", len(plan.etapes)), style="bold yellow") + for etape in plan.etapes: + console.print() + _etape(etape) + _a_savoir(report) + + if plan.etapes or report.a_savoir: + console.print() + for check in plan.non_mesures: + _ligne(_("doctor_non_mesure", label=check.label, detail=check.detail), style="yellow") + if plan.etapes or plan.non_mesures: + if plan.prets: + _resume_long(_("doctor_deja_pret", items=_resume_court(plan.prets))) + else: + _ligne(_compte("doctor_tout_pret", len(plan.prets)), style="bold green") + _resume_long(" " + _resume_court(plan.prets)) + _facultatifs(report, plan) + + if verbose: + _verbeux(report) + else: + mises_en_garde = sum(1 for c in report.required if c.mise_en_garde) + if mises_en_garde: + _ligne(_compte("doctor_mises_en_garde", mises_en_garde), style="dim") + + if any(not e.manuelle for e in plan.etapes): + console.print() + _ligne(_("doctor_tout_corriger"), style="bold") + _commande("dsoxlab doctor --fix") diff --git a/src/dsoxlab/reporting/machine.py b/src/dsoxlab/reporting/machine.py index d2b7fd7..c77095d 100644 --- a/src/dsoxlab/reporting/machine.py +++ b/src/dsoxlab/reporting/machine.py @@ -133,6 +133,12 @@ def check_dict(check: Check) -> dict[str, Any]: "fix": None if check.fix is None else check.fix.display, "fix_kind": None if check.fix is None else check.fix.kind.value, "hint": check.hint, + # Ajouts compatibles de la refonte du 2026-11-16 : les commandes à + # coller (celles que `doctor` affiche, sudo compris), la clé du contrôle + # à réparer d'abord, et la mise en garde d'une ligne verte. + "commands": list(check.remede.lignes) if check.remede is not None else [], + "after": check.apres, + "warning": check.mise_en_garde, } @@ -146,7 +152,9 @@ def doctor_dict(report: DoctorReport) -> dict[str, Any]: return { "ok": not report.failing(), "required": [check_dict(c) for c in report.required], - "informational": [check_dict(c) for c in report.optional], + # « À savoir » (la mémoire qui ne suffit pas pour tout le catalogue) + # informe sans bloquer : elle rejoint les contrôles informatifs. + "informational": [check_dict(c) for c in [*report.optional, *report.a_savoir]], # Traduites, et c'est assumé : une note explique *pourquoi* un composant # est informatif ici. Rien ne s'y décide, donc rien n'a à s'y comparer. "notes": list(report.notes), diff --git a/src/dsoxlab/services/doctor.py b/src/dsoxlab/services/doctor.py index fd6a8d3..3225f12 100644 --- a/src/dsoxlab/services/doctor.py +++ b/src/dsoxlab/services/doctor.py @@ -38,10 +38,10 @@ # lui-même et atteint donc les familles. Le découpage de l'issue #199 ne devait # réécrire aucun test. import os # noqa: F401 -import platform # noqa: F401 +import platform import shutil # noqa: F401 import subprocess # noqa: F401 -from dataclasses import dataclass +from dataclasses import dataclass, replace from pathlib import Path from ..discovery.scanner import compter_fichiers_labs @@ -50,8 +50,10 @@ from ..models import LabDefinition, RepoMetadata from .doctor_controles.catalogue import ( _VM_RUNTIMES, + _check_cle_ssh, _check_lab_home, _check_labs, + _check_ssh_include, uses_vm, ) from .doctor_controles.conteneurs import ( @@ -74,6 +76,8 @@ _VERSION_UTILISEE, Hebergement, _check_cpu_arch, + _check_efi, + _check_groupes, _check_hw_virt, _check_kvm, _hebergement, @@ -122,6 +126,7 @@ demarrer_pool_fix, explique_echec_provision, ) +from .doctor_controles.remedes import systeme as _systeme from .doctor_controles.reseau import ( _DELAI_EGRESS, _URL_IMAGE, @@ -142,23 +147,83 @@ #: Ce que les appelants importent d'ici : cli/, tests/, et les familles #: elles-mêmes par ``_doctor()``. Rien ne change pour eux (issue #199). __all__ = [ - "EXIT_DOCTOR_INDETERMINE", "EXIT_DOCTOR_REQUIS_KO", "STATE_CHOICE_REQUIRED", - "STATE_FAILED", "STATE_OK", "STATE_UNKNOWN", "_APPARMOR_OVERRIDE", "_CPUINFO", - "_DELAI_EGRESS", "_KVM_DEVICE", "_LIBVIRT_MINIMUM", "_POOL_ABSENT", "_POOL_INACTIF", - "_POOL_INCUS", "_PROVIDER_IMAGE_ARCHS", "_SANS_VM", "_URL_IMAGE", - "_VERSION_COMPILEE", "_VERSION_UTILISEE", "_VM_RUNTIMES", "Check", "DoctorReport", - "Fix", "FixKind", "Hebergement", "_check", "_check_ansible", "_check_bridge_name", - "_check_collections", "_check_cpu_arch", "_check_docker", "_check_egress", - "_check_git", "_check_hw_virt", "_check_incus", "_check_incus_pool", - "_check_iso_tool", "_check_kvm", "_check_lab_home", "_check_labs", - "_check_libvirt_pool", "_check_pytest", "_check_python", "_check_resources", - "_check_shell", "_check_terraform", "_check_tf_providers", "_current_user", "_fix", - "_hebergement", "_hotes_a_compter", "_hotes_images", "_installer", "_joignable", - "_mem_available_mb", "_pool_available_gb", "_pool_cite", "_pools_libvirt", - "_sonde_virsh", "_sonder", "_version_libvirt", "apparmor_fix_command", - "apparmor_override_absent", "creer_pool_command", "creer_pool_fix", - "demarrer_pool_command", "demarrer_pool_fix", "explique_echec_provision", - "nom_du_pool", "uses_services", "uses_vm", + "EXIT_DOCTOR_INDETERMINE", + "EXIT_DOCTOR_REQUIS_KO", + "STATE_CHOICE_REQUIRED", + "STATE_FAILED", + "STATE_OK", + "STATE_UNKNOWN", + "_APPARMOR_OVERRIDE", + "_CPUINFO", + "_DELAI_EGRESS", + "_KVM_DEVICE", + "_LIBVIRT_MINIMUM", + "_POOL_ABSENT", + "_POOL_INACTIF", + "_POOL_INCUS", + "_PROVIDER_IMAGE_ARCHS", + "_SANS_VM", + "_URL_IMAGE", + "_VERSION_COMPILEE", + "_VERSION_UTILISEE", + "_VM_RUNTIMES", + "Check", + "DoctorReport", + "Fix", + "FixKind", + "Hebergement", + "_check", + "_check_ansible", + "_check_bridge_name", + "_check_cle_ssh", + "_check_collections", + "_check_cpu_arch", + "_check_docker", + "_check_efi", + "_check_egress", + "_check_git", + "_check_groupes", + "_check_hw_virt", + "_check_incus", + "_check_incus_pool", + "_check_iso_tool", + "_check_kvm", + "_check_lab_home", + "_check_labs", + "_check_libvirt_pool", + "_check_pytest", + "_check_python", + "_check_resources", + "_check_shell", + "_check_ssh_include", + "_check_terraform", + "_check_tf_providers", + "_current_user", + "_fix", + "_hebergement", + "_hotes_a_compter", + "_hotes_images", + "_installer", + "_joignable", + "_mem_available_mb", + "_pool_available_gb", + "_pool_cite", + "_pools_libvirt", + "_sonde_virsh", + "_sonder", + "_systeme", + "_version_libvirt", + "apparmor_fix_command", + "apparmor_override_absent", + "creer_pool_command", + "creer_pool_fix", + "demarrer_pool_command", + "demarrer_pool_fix", + "explique_echec_provision", + "nom_du_pool", + "provider_recommande", + "uses_services", + "uses_vm", ] #: Providers packagés qui reposent sur un hyperviseur **local**, donc @@ -234,6 +299,28 @@ def _ranger_sortie_reseau(report: DoctorReport, ctx: _CeQueLeDepotDemande) -> No report.optional.append(_check_tf_providers(ctx.repo_meta)) +def provider_recommande(candidates: list[str]) -> str: + """Le provider que le diagnostic prend quand le catalogue en laisse plusieurs. + + kvm sur un Linux qui expose ``/dev/kvm`` : c'est le provider que les + catalogues éprouvent. Sinon le premier hyperviseur local déclaré, puis le + premier candidat. Rien n'est enregistré : le choix reste une étape du plan, + confirmée par l'utilisateur (décision 4 du 2026-11-16). + """ + if "kvm" in candidates and platform.system() == "Linux" and _kvm_present(): + return "kvm" + for nom in candidates: + if nom in _LOCAL_HYPERVISORS: + return nom + return candidates[0] if candidates else "kvm" + + +def _kvm_present() -> bool: + from .doctor_controles.modele import _doctor + + return bool(_doctor()._KVM_DEVICE.exists()) + + def _ranger_hyperviseurs( report: DoctorReport, ctx: _CeQueLeDepotDemande, @@ -272,13 +359,27 @@ def _ranger_hyperviseurs( # choix que l'apprenant n'a pas encore fait. C'est le libellé du tableau # qui mentait, en annonçant « non requis ici » et « ces composants ne # bloquent rien » au-dessus du composant qui bloque 64 labs sur 84. - premier = ctx.candidates[0] if ctx.candidates else "kvm" + # + # Depuis la refonte du 2026-11-16, le diagnostic ne s'arrête plus là : il + # prend le provider qu'il recommande, et contrôle tout ce que ce choix + # demande. Avant, tous les contrôles kvm restaient cachés jusqu'au choix, + # et l'apprenant découvrait le chemin une commande à la fois. Seul + # l'hyperviseur recommandé passe en requis : `--fix` n'installe donc pas + # kvm ET incus. + recommande = provider_recommande(ctx.candidates) report.required.append(_check( "provider", False, _("detail_provider_unresolved", candidates=", ".join(ctx.candidates) or "?"), - hint=f"dsoxlab use --provider {premier}", + hint=f"dsoxlab use --provider {recommande}", forced_state=STATE_CHOICE_REQUIRED, )) + report.provider_a_confirmer = True + if recommande in hypervisors: + report.required.append(hypervisors[recommande]) + report.optional.extend( + _sort_hypervisors([n for n in _LOCAL_HYPERVISORS if n != recommande]) + ) + return report.optional.extend(_sort_hypervisors(list(_LOCAL_HYPERVISORS))) report.optional_title_key = "doctor_choose_title" report.optional_hint_key = "doctor_choose_hint" @@ -299,9 +400,19 @@ def _ranger_materiel_local(report: DoctorReport, ctx: _CeQueLeDepotDemande) -> N if ctx.repo_meta is None: return if ctx.repo_meta.infra.hosts: - report.required.append( - _check_resources(ctx.repo_meta.infra, ctx.active, ctx.hotes_demandes) - ) + ressources = _check_resources(ctx.repo_meta.infra, ctx.active, ctx.hotes_demandes) + if ctx.hotes_demandes is None and ressources.state == STATE_FAILED: + # Tout le catalogue ne tient pas en mémoire : « À savoir », non + # bloquant (décision 6 du 2026-11-16). Un lab ne monte souvent + # qu'une machine, et `provision --host` le permet. `start `, + # qui passe les hôtes de son lab, garde le contrôle bloquant : là, + # la mémoire manque pour CE lab. + premier = ctx.repo_meta.infra.hosts[0].name + report.a_savoir.append(replace( + ressources, hint=f"dsoxlab provision --host {premier}", remede=None, + )) + else: + report.required.append(ressources) # Le nom du pont ne dépend que du contrat : aucune sonde, donc aucune # raison de le taire quand l'hyperviseur manque. Il vaut mieux ici qu'au # premier `provision`, où l'échec arrive après le téléchargement de @@ -327,20 +438,33 @@ def _ranger_outillage_vm( if ctx.active in _LOCAL_HYPERVISORS: _ranger_materiel_local(report, ctx) - # Ces contrôles-ci portent sur la CONFIGURATION d'un hyperviseur déjà - # installé. Les jouer quand l'hyperviseur lui-même manque empilerait trois - # lignes rouges pour une seule cause, et noierait celle qui compte : c'est - # exactement ce qui décourageait au premier lancement. - if ctx.active == "kvm" and hypervisors["kvm"].ok: + # Ces contrôles-ci portent sur la CONFIGURATION d'un hyperviseur. Quand + # l'hyperviseur manque, ils ne peuvent pas mesurer : ils restent listés, + # en attente de l'étape qui l'installe, avec leur commande (refonte du + # 2026-11-16). Avant, ils disparaissaient, et chaque passage de `doctor` + # en révélait un de plus. + if ctx.active == "kvm": + kvm_ok = hypervisors["kvm"].ok + report.required.append(_check_groupes(kvm_ok)) # Même lecture que `_check_resources` et que le template Terraform : # une seule fonction la porte, sinon les trois divergent un jour. pool = nom_du_pool(ctx.repo_meta.infra) if ctx.repo_meta else "default" - report.required.append(_check_libvirt_pool(pool)) + if kvm_ok: + report.required.append(_check_libvirt_pool(pool)) + else: + report.required.append(_check( + "libvirt_pool", False, _("detail_pool_apres_kvm", pool=pool), + forced_state=STATE_UNKNOWN, apres="kvm", fix=creer_pool_fix(pool), + )) + report.required.append(_check_efi(kvm_ok)) elif ctx.active == "incus" and hypervisors["incus"].ok: # Symétrie avec la branche kvm : elle contrôle son pool de stockage, # celle-ci ne contrôlait que l'outil ISO. report.required.append(_check_incus_pool()) report.required.append(_check_iso_tool()) + if ctx.repo_meta is not None and ctx.active in _LOCAL_HYPERVISORS: + report.required.append(_check_cle_ssh(ctx.root)) + report.required.append(_check_ssh_include()) def collect_checks( @@ -378,7 +502,11 @@ def collect_checks( ) hypervisors = _hypervisor_checks() - report = DoctorReport() + report = DoctorReport( + catalogue=repo_meta.id if repo_meta else None, + nb_labs=len(labs), + systeme=_systeme().nom, + ) report.required.extend([_check_python(), _check_pytest(root), _check_shell()]) # git sert au parcours d'accueil (`catalog add` clone), quel que soit le # domaine du dépôt : il est requis partout. @@ -386,6 +514,10 @@ def collect_checks( _ranger_docker(report, labs) _ranger_sortie_reseau(report, ctx) _ranger_hyperviseurs(report, ctx, hypervisors) + if ctx.needs_vm and not ctx.active and report.provider_a_confirmer: + ctx = replace(ctx, active=provider_recommande(ctx.candidates)) + # Un catalogue sans machine n'a pas de provider à annoncer. + report.provider = ctx.active if ctx.needs_vm else "" if ctx.needs_vm: _ranger_outillage_vm(report, ctx, hypervisors) diff --git a/src/dsoxlab/services/doctor_controles/catalogue.py b/src/dsoxlab/services/doctor_controles/catalogue.py index c860ff8..cd94f17 100644 --- a/src/dsoxlab/services/doctor_controles/catalogue.py +++ b/src/dsoxlab/services/doctor_controles/catalogue.py @@ -6,12 +6,14 @@ from __future__ import annotations +import subprocess from pathlib import Path from ...i18n import _ from ...models import LabDefinition from ...models.runtime import RuntimeType -from .modele import Check, _check +from .modele import Check, _check, _doctor +from .remedes import remede #: Types de runtime qui exigent une VM provisionnée. Les deux alias #: historiques comptent autant que la valeur cible. @@ -74,3 +76,64 @@ def _check_lab_home(root: Path) -> Check: def uses_vm(labs: list[LabDefinition]) -> bool: """Ce dépôt a-t-il au moins un lab qui exige une VM provisionnée ?""" return any(lab.runtime.type in _VM_RUNTIMES for lab in labs) + + +# ── accès SSH aux machines ──────────────────────────────────────────────────── + +def _check_cle_ssh(root: Path) -> Check: + """La clé que ``provision`` pose sur les machines, et sans laquelle il échoue. + + Jamais contrôlée jusqu'ici : sur les deux postes neufs du 2026-11-16, + ``doctor`` était vert et ``provision`` s'arrêtait sur la clé publique + absente. ``instructor bootstrap`` la crée dans ``/ssh/``. + """ + privee = root / "ssh" / "id_ed25519" + publique = root / "ssh" / "id_ed25519.pub" + if privee.is_file() and publique.is_file(): + return _check("cle_ssh", True, str(publique)) + return _check( + "cle_ssh", False, _("detail_cle_ssh_absente", path=str(publique)), + remede=remede("cle_ssh", _doctor()._systeme()), + ) + + +def _check_ssh_include() -> Check: + """``~/.ssh/config`` lit-il les fragments que ``provision`` écrit ? + + Sans la ligne ``Include``, le fragment est écrit mais jamais lu, et + ``ssh `` échoue alors que les énoncés le demandent. ``provision`` + le disait après coup ; le diagnostic le dit avant. Le remède marche sur un + fichier vide ou absent, ce qu'un ``sed -i '1i …'`` ne fait pas (il n'écrit + rien dans un fichier vide, mesuré le 2026-11-16). + """ + from ...infra.inventory import ssh_config_include_present + + if ssh_config_include_present(): + return _check("ssh_include", True, "~/.ssh/config") + return _check( + "ssh_include", False, _("detail_ssh_include_absent"), + remede=remede("ssh_include", _doctor()._systeme()), + ) + + +def creer_cle_ssh(root: Path) -> str | None: + """Crée ``/ssh/id_ed25519`` (et sa clé publique) si elle manque. + + Partagée par ``instructor bootstrap`` et ``doctor --fix`` : deux commandes + qui créent la même clé doivent la créer de la même façon. Rend ``None`` en + cas de succès (ou si la clé existe déjà), la sortie de ssh-keygen sinon. + """ + ssh_dir = root / "ssh" + privee = ssh_dir / "id_ed25519" + if privee.is_file() and (ssh_dir / "id_ed25519.pub").is_file(): + return None + ssh_dir.mkdir(parents=True, exist_ok=True) + ssh_dir.chmod(0o700) + # check=False : l'échec est rendu en message, pas en trace Python. + resultat = subprocess.run( + ["ssh-keygen", "-t", "ed25519", "-N", "", "-C", "dsoxlab-lab", "-f", str(privee)], + capture_output=True, text=True, check=False, + ) + if resultat.returncode != 0: + return resultat.stderr.strip() or f"ssh-keygen: code {resultat.returncode}" + return None diff --git a/src/dsoxlab/services/doctor_controles/conteneurs.py b/src/dsoxlab/services/doctor_controles/conteneurs.py index dccff02..53650a6 100644 --- a/src/dsoxlab/services/doctor_controles/conteneurs.py +++ b/src/dsoxlab/services/doctor_controles/conteneurs.py @@ -11,6 +11,7 @@ from ...i18n import _ from ...models import LabDefinition from .modele import STATE_UNKNOWN, Check, _check, _doctor +from .remedes import remede def uses_services(labs: list[LabDefinition]) -> bool: @@ -33,7 +34,7 @@ def _check_docker() -> Check: if shutil.which("docker") is None: return _check( "docker", False, _("detail_docker_missing"), - hint="https://docs.docker.com/engine/install/", + remede=remede("docker", _doctor()._systeme()), ) result = _doctor()._sonder(["docker", "version", "--format", "{{.Server.Version}}"], delai=15) if result is None: diff --git a/src/dsoxlab/services/doctor_controles/incus.py b/src/dsoxlab/services/doctor_controles/incus.py index c829f57..1d9cba9 100644 --- a/src/dsoxlab/services/doctor_controles/incus.py +++ b/src/dsoxlab/services/doctor_controles/incus.py @@ -11,7 +11,8 @@ import shutil from ...i18n import _ -from .modele import STATE_UNKNOWN, Check, FixKind, _check, _doctor, _fix, _installer +from .modele import STATE_UNKNOWN, Check, FixKind, _check, _doctor, _fix +from .remedes import remede def _current_user() -> str: @@ -32,9 +33,14 @@ def _check_incus() -> Check: (« permissions to talk to the incus daemon »). """ if not shutil.which("incus"): + # Sur la famille RHEL, incus n'est dans aucun dépôt de base (AlmaLinux + # 10, mesuré le 2026-11-16) : la table ne donne pas de remède, et le + # détail le dit, plutôt qu'un `dnf install incus` qui échoue. + trouve = remede("incus", _doctor()._systeme()) return _check( - "incus", False, _("detail_incus_missing"), - fix=_fix(_installer(["incus"], ["incus"])), + "incus", False, + _("detail_incus_missing") if trouve else _("detail_incus_sans_paquet"), + remede=trouve, ) # Le numéro de version n'est qu'un ornement du diagnostic. Le verdict vient diff --git a/src/dsoxlab/services/doctor_controles/kvm.py b/src/dsoxlab/services/doctor_controles/kvm.py index a4f017b..0922137 100644 --- a/src/dsoxlab/services/doctor_controles/kvm.py +++ b/src/dsoxlab/services/doctor_controles/kvm.py @@ -6,8 +6,10 @@ from __future__ import annotations +import grp import os import platform +import pwd import re import shutil from dataclasses import dataclass @@ -17,7 +19,8 @@ from ...infra import libvirt as libvirt_infra from ...utils.shell import CommandError, CommandResult from .incus import _current_user -from .modele import STATE_UNKNOWN, Check, FixKind, _check, _doctor, _fix, _installer +from .modele import STATE_UNKNOWN, Check, FixKind, _check, _doctor, _fix +from .remedes import Remede, remede def _sonde_virsh(args: list[str], *, delai: int = 5) -> CommandResult | None: @@ -80,10 +83,7 @@ def _check_kvm() -> Check: if not shutil.which("virsh"): return _check( "kvm", False, _("detail_kvm_missing"), - fix=_fix(_installer( - ["libvirt-clients", "libvirt-daemon-system", "qemu-kvm"], - ["libvirt", "qemu-kvm"], - )), + remede=remede("kvm", _doctor()._systeme()), ) # Un virsh qui sort en erreur est justement ce que ce contrôle cherche à # rapporter ; un virsh qui ne répond pas dit la même chose plus fort. @@ -98,7 +98,9 @@ def _check_kvm() -> Check: if probe is None or not probe.ok: return _check( "kvm", False, _("detail_kvm_daemon_err"), - fix=_fix(["sudo", "systemctl", "start", "libvirtd"]), + # `enable --now` et non `start` : un démon seulement démarré + # s'arrête au prochain redémarrage, et le même rouge revient. + fix=_fix(["sudo", "systemctl", "enable", "--now", "libvirtd"]), ) first_line = probe.stdout.splitlines()[0] if probe.stdout else "ok" @@ -217,12 +219,28 @@ def _check_hw_virt() -> Check: detail = _("detail_hw_virt_missing", device=_doctor()._KVM_DEVICE) return _check("hw_virt", False, detail) if not os.access(_doctor()._KVM_DEVICE, os.R_OK | os.W_OK): + gid = _gid("kvm") + if gid is not None and _inscrit("kvm", gid): + # Déjà dans le groupe, mais pas dans cette session : rejouer + # usermod ne changerait rien, seule la reconnexion compte. Sans ce + # cas, `--fix` jugeait son propre usermod en échec, juste après + # l'avoir réussi (réévaluation du 2026-11-16 sur Ubuntu 24.04). + return _check( + "hw_virt", False, + _("detail_groupes_reconnexion", groups="kvm"), + remede=Remede("groupes", (), root=False, reconnexion=True), + ) return _check( "hw_virt", False, _("detail_hw_virt_denied", device=_doctor()._KVM_DEVICE), fix=_fix( ["sudo", "usermod", "-aG", "kvm", _current_user()], kind=FixKind.NEEDS_RELOGIN, ), + # La même clé de remède que le contrôle des groupes : sur kvm, les + # deux lignes rouges deviennent une seule étape, portée par le + # contrôle des groupes, qui ajoute libvirt. Sur incus, celle-ci + # reste seule, et kvm suffit. + remede=remede_groupes(["kvm"]), ) return _check("hw_virt", True, str(_doctor()._KVM_DEVICE)) @@ -263,3 +281,114 @@ def _check_cpu_arch(provider: str) -> Check: archs="/".join(sorted(archs, reverse=True)), ), ) + + +# ── groupes kvm et libvirt ──────────────────────────────────────────────────── + +def _gid(nom: str) -> int | None: + try: + return grp.getgrnam(nom).gr_gid + except KeyError: + return None + + +def _dans_la_session(gid: int) -> bool: + """Le groupe vaut pour CE processus, donc pour cette session.""" + return gid == os.getgid() or gid in os.getgroups() + + +def _inscrit(nom: str, gid: int) -> bool: + """Le compte est membre du groupe dans /etc/group, session ouverte ou non.""" + utilisateur = _current_user() + try: + primaire = pwd.getpwnam(utilisateur).pw_gid + except KeyError: + primaire = None + return primaire == gid or utilisateur in grp.getgrgid(gid).gr_mem + + +def groupes_a_rejoindre(*, kvm_ok: bool) -> list[str]: + """Les groupes dont ce compte a besoin pour piloter l'hyperviseur sans sudo. + + ``kvm`` seulement si ``/dev/kvm`` existe et reste fermé à ce compte : sur + AlmaLinux 10 il est ouvert à tous (0666), sur Ubuntu 24.04 il appartient au + groupe kvm (0660), mesuré le 2026-11-16. ``libvirt`` dès que libvirt est là, + ou attendu : avant l'installation, le groupe n'existe pas encore, mais il + sera créé par le paquet. + """ + groupes: list[str] = [] + device = _doctor()._KVM_DEVICE + if device.exists() and not os.access(device, os.R_OK | os.W_OK): + groupes.append("kvm") + gid = _gid("libvirt") + if (gid is None and not kvm_ok) or (gid is not None and not _dans_la_session(gid)): + groupes.append("libvirt") + return groupes + + +def remede_groupes(groupes: list[str]) -> Remede | None: + return remede("groupes", _doctor()._systeme(), groupes=",".join(groupes)) + + +def _check_groupes(kvm_ok: bool) -> Check: + """Le compte peut-il parler à libvirt et ouvrir ``/dev/kvm`` sans sudo ? + + Le groupe libvirt n'était jamais proposé : ``virsh`` sur l'URI système + restait alors refusé à l'utilisateur, et le parcours mesuré le 2026-11-16 a + dû le deviner. Trois cas, que la reconnexion distingue : + + - groupe absent parce que libvirt n'est pas installé : contrôle en attente + de l'étape libvirt, avec la commande, pour qu'une passe suffise ; + - compte inscrit dans ``/etc/group`` mais session ouverte avant : rien à + relancer, seulement se reconnecter, et le dire évite de rejouer + ``usermod`` en boucle ; + - compte absent du groupe : ``usermod -aG``, puis reconnexion. + """ + manquants = groupes_a_rejoindre(kvm_ok=kvm_ok) + if not manquants: + return _check("groupes", True, _("detail_groupes_ok")) + if _gid("libvirt") is None and not kvm_ok: + return _check( + "groupes", False, _("detail_groupes_apres_kvm", groups=", ".join(manquants)), + forced_state=STATE_UNKNOWN, apres="kvm", remede=remede_groupes(manquants), + ) + a_inscrire = [ + nom for nom in manquants + if (gid := _gid(nom)) is None or not _inscrit(nom, gid) + ] + if not a_inscrire: + return _check( + "groupes", False, _("detail_groupes_reconnexion", groups=", ".join(manquants)), + remede=Remede("groupes", (), root=False, reconnexion=True), + ) + return _check( + "groupes", False, _("detail_groupes_manquants", groups=", ".join(a_inscrire)), + remede=remede_groupes(a_inscrire), + ) + + +# ── firmware EFI ────────────────────────────────────────────────────────────── + +def _check_efi(kvm_ok: bool) -> Check: + """Le firmware EFI sans Secure Boot que le template kvm désigne. + + Jamais contrôlé jusqu'ici : ``provision`` échouait sur AlmaLinux 10 après + un ``doctor`` vert (issue #381). La découverte est celle que ``provision`` + utilise, :func:`~dsoxlab.infra.libvirt.efi_loader`, pour que le diagnostic + mesure ce que la commande fera. + """ + if not kvm_ok: + return _check( + "efi", False, _("detail_efi_apres_kvm"), + forced_state=STATE_UNKNOWN, apres="kvm", + ) + try: + chargeur = libvirt_infra.efi_loader() + except Exception: # noqa: BLE001 : un diagnostic ne casse pas la commande + chargeur = None + if chargeur: + return _check("efi", True, Path(chargeur).name) + return _check( + "efi", False, _("detail_efi_absent"), + remede=remede("efi", _doctor()._systeme()), + ) diff --git a/src/dsoxlab/services/doctor_controles/modele.py b/src/dsoxlab/services/doctor_controles/modele.py index ad8d1a3..3c6778b 100644 --- a/src/dsoxlab/services/doctor_controles/modele.py +++ b/src/dsoxlab/services/doctor_controles/modele.py @@ -7,7 +7,6 @@ from __future__ import annotations import shlex -import shutil from collections.abc import Sequence from dataclasses import dataclass, field from enum import StrEnum @@ -15,6 +14,7 @@ from ...exit_codes import ExitCode from ...i18n import _ +from .remedes import Remede #: Les trois états d'un contrôle, en **jetons stables**. Ce sont eux que lit un #: programme : un tableau de bord qui devrait comparer « ok » à « présent » puis @@ -117,10 +117,13 @@ def _installer(apt: Sequence[str], dnf: Sequence[str]) -> list[str]: ``qemu-utils`` s'appelle ``qemu-img`` ; ``genisoimage`` n'existe plus sur Fedora 43, ``xorriso`` fournit ``xorrisofs``, que le contrôle accepte. - apt reste le choix par défaut quand aucun des deux n'est trouvé : c'est le - comportement d'avant, et la famille Debian celle que dsoxlab éprouve. + La famille vient de ``/etc/os-release`` (:func:`.remedes.systeme`), la même + lecture que la table des remèdes : deux détections pouvaient se contredire + sur un même poste. apt reste le choix par défaut quand rien ne se lit. """ - if shutil.which("apt-get") is None and shutil.which("dnf") is not None: + from .remedes import Famille + + if _doctor()._systeme().famille is Famille.RHEL: return ["sudo", "dnf", "install", *dnf] return ["sudo", "apt", "install", *apt] @@ -153,6 +156,23 @@ class Check: à choisir bloque bien le provisionnement, mais rien n'est cassé : le dire en rouge revient à traiter une décision comme une panne.""" + remede: Remede | None = None + """Les commandes à coller, une par ligne, tirées de la table unique + (:mod:`.remedes`). C'est ce que ``doctor`` affiche et ce que le playbook de + ``--fix`` joue pour les étapes root. Dérivé de ``fix`` ou de ``hint`` + quand le contrôle n'en donne pas : voir :func:`_check`.""" + + apres: str | None = None + """La clé du contrôle qu'il faut réparer d'abord. Le contrôle n'a pas pu + mesurer sans lui (le pool sans libvirt, les collections sans Ansible) : + il reste listé, en ``unknown``, au lieu de disparaître jusqu'au passage + suivant. C'était le défaut principal du parcours mesuré le 2026-11-16 : + il fallait relancer ``doctor`` après chaque geste pour voir le suivant.""" + + mise_en_garde: str | None = None + """Une remarque sur une ligne verte (Terraform plus ancien que la dernière + version). Affichée sous ``-v`` seulement, et jamais un échec.""" + @property def state(self) -> str: """L'état du contrôle, en jeton stable.""" @@ -174,13 +194,22 @@ def _check( fix: Fix | None = None, hint: str | None = None, forced_state: str | None = None, + remede: Remede | None = None, + apres: str | None = None, + mise_en_garde: str | None = None, ) -> Check: """Un contrôle, dont l'identité stable engendre le libellé traduit. Le libellé n'est pas passé : il se déduit de ``key``. Les deux étaient écrits côte à côte à chaque appel, et rien n'aurait empêché un contrôle d'annoncer ``kvm`` à un programme et « Terraform » à un humain. + + Sans ``remede`` explicite, il se déduit du correctif (une ligne par argv) + ou d'une consigne qui est une commande. Une URL n'est jamais un remède : + c'était le défaut de git, Terraform et Docker, qui renvoyaient lire une page. """ + if remede is None and not ok: + remede = remede_derive(key, fix, hint) return Check( key=key, label=_(f"check_{key}"), @@ -189,9 +218,27 @@ def _check( fix=fix, hint=hint, forced_state=forced_state, + remede=remede, + apres=apres, + mise_en_garde=mise_en_garde, ) +def remede_derive(key: str, fix: Fix | None, hint: str | None) -> Remede | None: + """Le remède d'un contrôle qui n'en donne pas : son correctif, ou sa consigne.""" + if fix is not None: + return Remede( + cle=key, + lignes=tuple(shlex.join(cmd) for cmd in fix.commands), + root=fix.requires_sudo, + tag=key, + reconnexion=fix.kind is FixKind.NEEDS_RELOGIN, + ) + if hint and not hint.startswith(("http://", "https://")): + return Remede(cle=key, lignes=(hint,), root=hint.startswith("sudo ")) + return None + + @dataclass class DoctorReport: """Le diagnostic, séparé en ce qui bloque et ce qui informe.""" @@ -212,6 +259,27 @@ class DoctorReport: d'installer kvm **et** incus pour un choix qui n'est pas fait ; c'est le libellé qui devait dire la vérité, pas le classement.""" + a_savoir: list[Check] = field(default_factory=list) + """Ce qui mérite d'être lu sans bloquer : la mémoire qui ne suffit pas pour + monter tout le catalogue d'un coup (décision du 2026-11-16). Un lab ne monte + souvent qu'une machine, et ``provision --host`` le permet : peindre ce cas + en rouge requis refusait des postes qui jouent parfaitement leurs labs. + Hors de ``failing()``, donc hors du verdict de ``--strict``.""" + + catalogue: str | None = None + """L'``id`` du catalogue diagnostiqué, ou ``None`` hors de tout catalogue.""" + + nb_labs: int = 0 + systeme: str = "" + """Le nom du système (``PRETTY_NAME``), pour l'en-tête.""" + + provider: str = "" + """Le provider avec lequel le diagnostic a été fait.""" + + provider_a_confirmer: bool = False + """Le provider n'est pas choisi : le diagnostic a pris celui qu'il + recommande, pour ne cacher aucun contrôle, sans l'enregistrer.""" + def failing(self) -> list[Check]: # Un contrôle ``unknown`` n'a rien prouvé : il ne peut pas peindre le # verdict en rouge. Son jeton suffit à dire qu'il n'est pas vert. diff --git a/src/dsoxlab/services/doctor_controles/outillage.py b/src/dsoxlab/services/doctor_controles/outillage.py index e998f9e..56abb7c 100644 --- a/src/dsoxlab/services/doctor_controles/outillage.py +++ b/src/dsoxlab/services/doctor_controles/outillage.py @@ -15,6 +15,7 @@ from ...infra import ansible as ansible_infra from ...models import RepoMetadata from .modele import STATE_UNKNOWN, Check, _check, _doctor, _fix, _installer +from .remedes import remede # ── checks unitaires ────────────────────────────────────────────────────────── @@ -73,7 +74,7 @@ def _check_terraform() -> Check: if shutil.which("terraform") is None: return _check( "terraform", False, _("detail_terraform_missing"), - hint="https://developer.hashicorp.com/terraform/install", + remede=remede("terraform", _doctor()._systeme()), ) # Le binaire peut être dans le PATH sans être exécutable, ou disparaître # entre les deux appels. Un diagnostic qui plante en cherchant à @@ -82,7 +83,7 @@ def _check_terraform() -> Check: if result is None: return _check( "terraform", False, _("detail_terraform_missing"), - hint="https://developer.hashicorp.com/terraform/install", + remede=remede("terraform", _doctor()._systeme()), ) # Un terraform présent mais qui sort en erreur passait pour vert : le code # retour n'était pas lu, et « ok » s'affichait faute de stdout. `provision` @@ -92,10 +93,27 @@ def _check_terraform() -> Check: return _check( "terraform", False, detail[-1] if detail else _("detail_terraform_broken"), - hint="https://developer.hashicorp.com/terraform/install", + remede=remede("terraform", _doctor()._systeme()), ) first = result.stdout.splitlines()[0] if result.stdout else "ok" - return _check("terraform", True, first) + return _check("terraform", True, first, mise_en_garde=_terraform_depasse(result.stdout)) + + +def _terraform_depasse(sortie: str) -> str | None: + """La version plus récente que ``terraform version`` annonce, mise en forme. + + ``terraform version`` interroge lui-même le service de versions d'HashiCorp + et écrit « Your version of Terraform is out of date! The latest version is + 1.17.2. » : on lit cette phrase au lieu de refaire la requête. Une + mise en garde seulement, sous ``-v`` (décision 7 du 2026-11-16) : une + version plus ancienne n'empêche rien. + """ + texte = " ".join(sortie.split()) + marque = "The latest version is " + if "out of date" not in texte or marque not in texte: + return None + derniere = texte.split(marque, 1)[1].split()[0].rstrip(".") + return _("detail_terraform_depasse", latest=derniere) def _check_collections(root: Path) -> Check: @@ -120,6 +138,21 @@ def _check_collections(root: Path) -> Check: if not besoins.mesurable: # `ansible-galaxy` n'a pas répondu : on ne peint pas en rouge ce qu'on # n'a pas pu regarder, et `--strict` a son propre code pour cela. + # + # Sans Ansible, la cause est connue : l'étape « installer Ansible » + # vient d'abord. Le « ? » d'avant cachait cette cause (parcours mesuré + # le 2026-11-16), et le remède reste affiché pour qu'une seule passe + # de `--fix` fasse les deux. + if not ansible_infra.has_ansible_playbook(): + return _check( + "collections", False, + _("detail_collections_apres_ansible", count=len(besoins.exigees)), + forced_state=STATE_UNKNOWN, apres="ansible", + # `manquantes` est vide quand rien n'est mesuré : on installe + # alors tout ce que le catalogue exige, ou son requirements.yml. + fix=_fix(geste_d_installation(besoins) if besoins.declaration else + ["ansible-galaxy", "collection", "install", *sorted(besoins.exigees)]), + ) return _check( "collections", False, _("detail_collections_non_mesure"), forced_state=STATE_UNKNOWN, @@ -189,7 +222,7 @@ def _check_git() -> Check: if shutil.which("git") is None: return _check( "git", False, _("detail_git_missing"), - hint="https://git-scm.com/downloads", + remede=remede("git", _doctor()._systeme()), ) result = _doctor()._sonder(["git", "--version"]) if result is None: @@ -198,7 +231,7 @@ def _check_git() -> Check: if result.returncode != 0: detail = (result.stderr or result.stdout).strip().splitlines() return _check("git", False, detail[-1] if detail else _("detail_git_muet"), - hint="https://git-scm.com/downloads") + remede=remede("git", _doctor()._systeme())) return _check("git", True, result.stdout.strip() or "ok") diff --git a/src/dsoxlab/services/doctor_controles/remedes.py b/src/dsoxlab/services/doctor_controles/remedes.py new file mode 100644 index 0000000..b9b83cf --- /dev/null +++ b/src/dsoxlab/services/doctor_controles/remedes.py @@ -0,0 +1,270 @@ +"""La table unique des remèdes du diagnostic : chaque commande à coller, par famille. + +Une seule source pour trois lecteurs : l'affichage de ``doctor``, le playbook +de ``doctor --fix`` (qui joue les mêmes étapes) et la doc d'installation, que +``tests/test_doc_installation.py`` compare à cette table. Avant, chaque +contrôle écrivait sa remédiation à la main, et trois d'entre eux ne donnaient +qu'un lien (git, Terraform, Docker) : l'apprenant devait aller lire une page +pour trouver la commande (parcours mesuré le 2026-11-16 sur Ubuntu 24.04 et +AlmaLinux 10, ~/Projets/ckne-captures/doctor/). + +Les commandes viennent des pages officielles, lues le 2026-11-16 : + +- Terraform : https://developer.hashicorp.com/terraform/install (dépôt + HashiCorp, jamais le paquet de la distribution, en retard d'une version) ; +- Docker : https://docs.docker.com/engine/install/ubuntu/ et /rhel/ ; +- libvirt, git, OVMF : les paquets des distributions, noms relevés sur les + machines de mesure (``libvirt-clients libvirt-daemon-system qemu-kvm`` sur + Ubuntu 24.04, ``libvirt qemu-kvm`` sur AlmaLinux 10). + +La famille se lit dans ``/etc/os-release`` (``ID``, puis ``ID_LIKE``), et +retombe sur la présence d'``apt-get`` ou de ``dnf`` quand le fichier ne dit +rien d'utile. +""" + +from __future__ import annotations + +import shutil +from collections.abc import Callable +from dataclasses import dataclass +from enum import StrEnum +from pathlib import Path + +OS_RELEASE = Path("/etc/os-release") + + +class Famille(StrEnum): + """La famille de distribution du poste, qui décide des commandes.""" + + DEBIAN = "debian" + RHEL = "rhel" + + +@dataclass(frozen=True) +class Systeme: + """Ce que dit ``/etc/os-release`` du poste, réduit à ce qui choisit une commande.""" + + famille: Famille + identifiant: str + """``ID`` : ``ubuntu``, ``debian``, ``almalinux``, ``fedora``…""" + + nom: str + """``PRETTY_NAME``, pour l'en-tête du diagnostic.""" + + +def _champs(texte: str) -> dict[str, str]: + champs: dict[str, str] = {} + for ligne in texte.splitlines(): + cle, sep, valeur = ligne.partition("=") + if sep: + champs[cle.strip()] = valeur.strip().strip('"').strip("'") + return champs + + +def systeme(chemin: Path | None = None) -> Systeme: + """Le système du poste. Ne lève jamais : un poste illisible retombe sur apt ou dnf. + + ``OS_RELEASE`` est lu à l'appel, pas à la définition, pour que les tests + simulent une autre distribution en déplaçant cette constante. + """ + try: + champs = _champs((chemin or OS_RELEASE).read_text(encoding="utf-8", errors="replace")) + except OSError: + champs = {} + identifiant = champs.get("ID", "").lower() + proches = set(champs.get("ID_LIKE", "").lower().split()) | {identifiant} + if proches & {"rhel", "fedora", "centos"}: + famille = Famille.RHEL + elif proches & {"debian", "ubuntu"}: + famille = Famille.DEBIAN + elif shutil.which("apt-get") is None and shutil.which("dnf") is not None: + famille = Famille.RHEL + else: + famille = Famille.DEBIAN + return Systeme(famille=famille, identifiant=identifiant, + nom=champs.get("PRETTY_NAME", identifiant or "Linux")) + + +@dataclass(frozen=True) +class Remede: + """Une étape à faire : ses commandes, et ce qu'elle engage. + + ``lignes`` sont des commandes de shell prêtes à coller, dans l'ordre, une par + ligne : ce que l'apprenant lit, et ce que la doc d'installation reproduit + mot pour mot. ``root`` dit qu'au moins une ligne passe par ``sudo`` : ces + étapes, ``--fix`` les confie au playbook du poste, qui demande lui-même le + mot de passe, et ne les lance jamais en silence. ``tag`` est l'étiquette de + l'étape dans ce playbook. + """ + + cle: str + lignes: tuple[str, ...] + root: bool + tag: str | None = None + reconnexion: bool = False + """L'effet n'existe qu'après une déconnexion puis une reconnexion.""" + + +_TERRAFORM_DEBIAN = ( + ("wget -O - https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o " + "/usr/share/keyrings/hashicorp-archive-keyring.gpg"), + ('echo "deb [arch=$(dpkg --print-architecture) ' + "signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] " + "https://apt.releases.hashicorp.com $(grep -oP '(?<=UBUNTU_CODENAME=).*' /etc/os-release " + '|| lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list'), + "sudo apt update && sudo apt install terraform", +) +_TERRAFORM_RHEL = ( + "sudo dnf install -y yum-utils", + "sudo yum-config-manager --add-repo https://rpm.releases.hashicorp.com/RHEL/hashicorp.repo", + "sudo dnf -y install terraform", +) +_TERRAFORM_FEDORA = ( + ("wget -O- https://rpm.releases.hashicorp.com/fedora/hashicorp.repo | " + "sudo tee /etc/yum.repos.d/hashicorp.repo"), + "sudo dnf -y install terraform", +) + + +def _docker_debian(identifiant: str) -> tuple[str, ...]: + distribution = "debian" if identifiant == "debian" else "ubuntu" + return ( + "sudo apt update", + "sudo apt install ca-certificates curl", + "sudo install -m 0755 -d /etc/apt/keyrings", + (f"sudo curl -fsSL https://download.docker.com/linux/{distribution}/gpg " + "-o /etc/apt/keyrings/docker.asc"), + "sudo chmod a+r /etc/apt/keyrings/docker.asc", + "sudo tee /etc/apt/sources.list.d/docker.sources </dev/null || true; } " + '> "$t" && mv "$t" ~/.ssh/config && chmod 600 ~/.ssh/config' +) + + +def _paquets(sys_: Systeme, apt: str, dnf: str) -> tuple[str, ...]: + if sys_.famille is Famille.RHEL: + return (f"sudo dnf install {dnf}",) + return (f"sudo apt install {apt}",) + + +def _kvm(s: Systeme, v: dict[str, str]) -> Remede: + lignes = _paquets(s, "libvirt-clients libvirt-daemon-system qemu-kvm", "libvirt qemu-kvm") + if s.famille is Famille.RHEL: + # Sur AlmaLinux 10, le paquet n'active aucun démon (mesuré le + # 2026-11-16) : sans cette ligne, l'étape suivante n'apparaissait + # qu'au passage d'après, en « libvirt ne répond pas ». + lignes += ("sudo systemctl enable --now libvirtd",) + return Remede("kvm", lignes, root=True, tag="libvirt") + + +def _pool(s: Systeme, v: dict[str, str]) -> Remede: + pool = v.get("pool", "default") + return Remede("libvirt_pool", ( + f"sudo virsh pool-define-as {pool} dir --target /var/lib/libvirt/images", + f"sudo virsh pool-build {pool}", + f"sudo virsh pool-start {pool}", + f"sudo virsh pool-autostart {pool}", + ), root=True, tag="pool") + + +def _terraform(s: Systeme, v: dict[str, str]) -> Remede: + lignes: tuple[str, ...] + if s.identifiant == "fedora": + lignes = _TERRAFORM_FEDORA + else: + lignes = _TERRAFORM_RHEL if s.famille is Famille.RHEL else _TERRAFORM_DEBIAN + return Remede("terraform", lignes, root=True, tag="terraform") + + +def _cle_ssh(s: Systeme, v: dict[str, str]) -> Remede: + option = f" --lab-home {v['racine']}" if v.get("racine") else "" + return Remede("cle_ssh", (f"dsoxlab instructor bootstrap{option}",), root=False) + + +def _docker(s: Systeme, v: dict[str, str]) -> Remede: + lignes = _DOCKER_RHEL if s.famille is Famille.RHEL else _docker_debian(s.identifiant) + return Remede("docker", lignes, root=True, tag="docker") + + +def _incus(s: Systeme, v: dict[str, str]) -> Remede | None: + # Incus n'est dans aucun dépôt de base d'AlmaLinux 10 (dnf info incus : + # « No matching Packages », mesuré le 2026-11-16) : pas de remède + # plutôt qu'une commande qui échoue. + if s.famille is Famille.RHEL: + return None + return Remede("incus", ("sudo apt install incus",), root=True, tag="incus") + + +_Fabrique = Callable[[Systeme, dict[str, str]], "Remede | None"] + +#: La table : une entrée par étape, dans l'ordre où le diagnostic les présente. +#: Cet ordre est aussi celui des dépendances (libvirt avant son pool, Ansible +#: avant ses collections), et :func:`rang` le rend aux autres modules. +TABLE: dict[str, _Fabrique] = { + "git": lambda s, v: Remede("git", _paquets(s, "git", "git"), root=True, tag="git"), + "provider": lambda s, v: Remede( + "provider", (f"dsoxlab use --provider {v.get('provider', 'kvm')}",), root=False), + "kvm": _kvm, + "libvirtd": lambda s, v: Remede( + "libvirtd", ("sudo systemctl enable --now libvirtd",), root=True, tag="libvirt"), + "groupes": lambda s, v: Remede( + "groupes", (f"sudo usermod -aG {v.get('groupes', 'kvm,libvirt')} $USER",), + root=True, tag="groupes", reconnexion=True), + "libvirt_pool": _pool, + "efi": lambda s, v: Remede("efi", _paquets(s, "ovmf", "edk2-ovmf"), root=True, tag="libvirt"), + "terraform": _terraform, + "ansible": lambda s, v: Remede("ansible", ("uv tool install ansible-core",), root=False), + "collections": lambda s, v: Remede( + "collections", + (f"ansible-galaxy collection install -r {v.get('fichier', 'requirements.yml')}",), + root=False), + "cle_ssh": _cle_ssh, + "ssh_include": lambda s, v: Remede("ssh_include", (_INCLUDE_SSH,), root=False), + "incus": _incus, + "docker": _docker, +} + + +def rang(cle: str) -> int: + """La place d'une étape dans l'ordre des dépendances ; les inconnues à la fin.""" + ordre = list(TABLE) + return ordre.index(cle) if cle in ordre else len(ordre) + + +def remede(cle: str, sys_: Systeme, **valeurs: str) -> Remede | None: + """Le remède de l'étape ``cle`` sur ce système, ou ``None`` s'il n'en existe pas. + + ``valeurs`` porte ce que la table ne peut pas savoir : le pool, le fichier de + collections, la racine du catalogue, le provider, les groupes. + """ + fabrique = TABLE.get(cle) + return fabrique(sys_, valeurs) if fabrique is not None else None diff --git a/src/dsoxlab/services/doctor_etapes.py b/src/dsoxlab/services/doctor_etapes.py new file mode 100644 index 0000000..b7e94bf --- /dev/null +++ b/src/dsoxlab/services/doctor_etapes.py @@ -0,0 +1,137 @@ +"""Du diagnostic aux étapes : ce qui manque, dans l'ordre où le faire. + +Le tableau d'avant listait des composants ; l'apprenant devait deviner l'ordre, +et relancer ``doctor`` après chaque geste pour découvrir le suivant (parcours +mesurés le 2026-11-16 sur Ubuntu 24.04 et AlmaLinux 10). Ce module range les +contrôles en **étapes numérotées** : + +- une étape par remède : deux lignes rouges qui se réparent par la même + commande (``/dev/kvm`` fermé et groupe libvirt absent) sont une seule étape ; +- dans l'ordre des dépendances de la table des remèdes (libvirt avant son + pool, Ansible avant ses collections) ; +- un contrôle qui attend une autre étape le dit : « faire l'étape N d'abord ». + +L'affichage et ``--fix`` lisent tous deux ces étapes : ce qui est montré est +ce qui est joué, dans le même ordre. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field + +from .doctor_controles.modele import STATE_OK, STATE_UNKNOWN, Check, DoctorReport +from .doctor_controles.remedes import Remede, rang + +#: Les composants que `doctor --fix --clients` installe quand ils sont facultatifs. +_CLIENTS = frozenset({"docker", "incus"}) + + +@dataclass +class Etape: + """Une chose à faire : ses contrôles, sa commande, et ce qu'elle attend.""" + + cle: str + """La clé du remède (``kvm``, ``groupes``…), ou celle du contrôle sans remède.""" + + controles: list[Check] + remede: Remede | None + numero: int = 0 + apres: int | None = None + """Le numéro de l'étape à faire d'abord, quand un contrôle l'attend.""" + + facultative: bool = False + """Un composant que ce catalogue n'exige pas (Docker, Incus) : seulement + avec ``--fix --clients``.""" + + @property + def detail(self) -> str: + return self.controles[0].detail + + @property + def manuelle(self) -> bool: + """Rien à lancer : un geste que seul l'humain peut faire (BIOS, reconnexion).""" + return self.remede is None or not self.remede.lignes + + +@dataclass +class Plan: + """Les étapes du diagnostic, et ce qui n'en est pas une.""" + + etapes: list[Etape] = field(default_factory=list) + facultatives: list[Etape] = field(default_factory=list) + non_mesures: list[Check] = field(default_factory=list) + """Une sonde muette sans étape à attendre : ni vert, ni étape. Le dire, + plutôt que de conclure « tout est prêt » sur une mesure qui n'a pas eu lieu.""" + + prets: list[Check] = field(default_factory=list) + + def etape_de(self, cle_controle: str) -> Etape | None: + for etape in self.etapes: + if any(c.key == cle_controle for c in etape.controles): + return etape + return None + + +def _a_faire(check: Check) -> bool: + """Le contrôle demande-t-il un geste ? + + ``unknown`` n'en demande que s'il attend une étape (``apres``) : une sonde + muette sans cause connue n'a pas de remède, elle se remesure. + """ + if check.state == STATE_OK: + return False + if check.state == STATE_UNKNOWN: + return check.apres is not None + return True + + +def _regrouper(checks: list[Check], *, facultative: bool) -> list[Etape]: + """Une étape par clé de remède, dans l'ordre des dépendances.""" + par_cle: dict[str, Etape] = {} + for check in checks: + cle = check.remede.cle if check.remede is not None else check.key + etape = par_cle.get(cle) + if etape is None: + par_cle[cle] = Etape(cle, [check], check.remede, facultative=facultative) + continue + etape.controles.append(check) + # Le remède retenu est celui du contrôle qui porte la clé : le contrôle + # des groupes ajoute libvirt à kvm, celui de /dev/kvm ne connaît que kvm. + if check.key == cle and check.remede is not None: + etape.remede = check.remede + position = {id(c): i for i, c in enumerate(checks)} + return sorted( + par_cle.values(), + key=lambda e: (rang(e.cle), position[id(e.controles[0])]), + ) + + +def construire(report: DoctorReport) -> Plan: + """Range le diagnostic en étapes numérotées.""" + plan = Plan() + a_faire = [c for c in report.required if _a_faire(c)] + plan.etapes = _regrouper(a_faire, facultative=False) + for numero, etape in enumerate(plan.etapes, start=1): + etape.numero = numero + for etape in plan.etapes: + attendues = [ + prealable.numero + for c in etape.controles if c.apres + if (prealable := plan.etape_de(c.apres)) is not None + and prealable.numero < etape.numero + ] + etape.apres = max(attendues) if attendues else None + + plan.non_mesures = [ + c for c in report.required if c.state == STATE_UNKNOWN and c.apres is None + ] + plan.prets = [c for c in report.required if c.state == STATE_OK] + # `--clients` ne vise que les clients facultatifs, Docker et Incus + # (décision 1 du 2026-11-16) : un hyperviseur que ce catalogue n'utilise + # pas, ou qu'aucun catalogue ne demande encore, ne s'installe pas en passant. + facultatifs = [ + c for c in report.optional + if not c.ok and c.remede is not None and c.key in _CLIENTS + ] + plan.facultatives = _regrouper(facultatifs, facultative=True) + return plan diff --git a/src/dsoxlab/services/remediation.py b/src/dsoxlab/services/remediation.py index 74fb6fe..a82dcab 100644 --- a/src/dsoxlab/services/remediation.py +++ b/src/dsoxlab/services/remediation.py @@ -1,129 +1,222 @@ -"""Ce que ``doctor --fix`` va jouer, et ce qui l'en empêche. - -La décision et l'exécution vivaient dans la commande, qui pesait 56 de -complexité cognitive pour 121 lignes : elle partageait les correctifs en deux -familles, vérifiait les préconditions de sudo, lançait la cascade, classait -chaque sortie, puis rejugeait le tout pour ``--strict``. Rien de cela n'est du -câblage, et rien n'était joignable par un test sans passer par la CLI. - -Trois règles portent tout le module, et chacune vient d'un défaut constaté : - -1. **Un correctif ``MANUAL`` n'est jamais exécuté.** Le geste appartient à - l'humain ; ``--fix`` se contente de le nommer. -2. **Un échec n'arrête pas la cascade.** ``--fix`` répare plusieurs choses - indépendantes : lever sur la première qui rate abandonnerait les autres. -3. **Un succès à effet différé le dit.** Un ``usermod -aG`` réussi laisse la - ligne rouge jusqu'à la reconnexion. Sans ce message, l'utilisateur relance - ``doctor``, revoit le même rouge, et conclut que le correctif a échoué. +"""Ce que ``doctor --fix`` va jouer, dans quel ordre, et par quel moyen. + +Refondu le 2026-11-16 avec le diagnostic en étapes (maquettes validées). Quatre +règles portent le module, et chacune vient d'un défaut mesuré : + +1. **Le plan se lit en entier avant toute action**, et rien ne part sans + ``[y/N]`` ou ``--yes``. Sans terminal et sans ``--yes``, rien n'est lancé. +2. **Une étape root n'est jamais lancée en silence.** Elles passent toutes par + un playbook généré depuis la table des remèdes, joué par ``ansible-playbook + --ask-become-pass -c local`` : une seule demande de mot de passe, faite par + Ansible. Sans terminal, elles s'affichent en bloc à coller (décision 2). +3. **Chaque étape est revérifiée juste après, et la première qui échoue + arrête tout.** L'ancienne règle (« un échec n'arrête pas la cascade ») + lançait des étapes qui dépendaient de celle qui venait d'échouer : un pool + créé sans libvirt, des collections sans Ansible. +4. **Un succès à effet différé le dit.** Un ``usermod -aG`` réussi ne vaut + qu'après une reconnexion : sans ce message, le ``doctor`` suivant ressemble + à un échec. + +Docker et Incus, quand le catalogue ne les exige pas, n'entrent dans le plan +qu'avec ``--clients`` (décision 1). """ from __future__ import annotations -import shutil -import sys -from collections.abc import Callable, Iterable -from dataclasses import dataclass +import os +import re +from collections.abc import Callable +from dataclasses import dataclass, field +from pathlib import Path + +import yaml from .doctor import DoctorReport, Fix, FixKind +from .doctor_controles.modele import STATE_OK, Check +from .doctor_etapes import Etape, construire -#: Signature d'un exécuteur de correctif : il rend le code de retour. Elle est -#: injectable pour que les tests décrivent une cascade sans toucher la machine, -#: ce que l'ancienne forme interdisait. +#: Signature d'un exécuteur de correctif sans shell : il rend le code de retour. +#: Injectable, pour que les tests décrivent une cascade sans toucher la machine. Executeur = Callable[[Fix], int] +#: Une étape que dsoxlab fait lui-même, sans commande externe : choisir le +#: provider, créer la clé du catalogue, ajouter la ligne Include. Rend ``None`` +#: en cas de succès, le message d'échec sinon. +Action = Callable[[], str | None] -@dataclass(frozen=True) + +@dataclass class PlanCorrection: - """Les correctifs disponibles, rangés par ce qu'on a le droit d'en faire.""" + """Les étapes de ``--fix``, rangées par ce qu'on a le droit d'en faire.""" + + sans_sudo: list[Etape] = field(default_factory=list) + """Lancées par dsoxlab, sans privilège.""" + + root: list[Etape] = field(default_factory=list) + """Confiées au playbook du poste.""" - manuels: tuple[tuple[str, Fix], ...] = () - executables: tuple[tuple[str, Fix], ...] = () + manuelles: list[Etape] = field(default_factory=list) + """Jamais lancées : dsoxlab les nomme, l'humain les fait.""" @property def vide(self) -> bool: - return not self.manuels and not self.executables + return not (self.sans_sudo or self.root or self.manuelles) @property - def correctifs_sudo(self) -> int: - return sum(1 for _label, fix in self.executables if fix.requires_sudo) + def executables(self) -> int: + return len(self.sans_sudo) + len(self.root) + + +def _correctif(etape: Etape) -> Fix | None: + """Le correctif sans shell d'une étape, s'il en existe un.""" + return next((c.fix for c in etape.controles if c.fix is not None), None) + + +def _est_manuelle(etape: Etape, actions: dict[str, Action]) -> bool: + if etape.manuelle: + return True + correctif = _correctif(etape) + if correctif is not None and correctif.kind is FixKind.MANUAL: + return True + if etape.remede is not None and etape.remede.root: + return False + return etape.cle not in actions and correctif is None + + +def planifier( + report: DoctorReport, *, clients: bool = False, actions: dict[str, Action] | None = None, +) -> PlanCorrection: + """Partage les étapes du diagnostic entre « à lancer », « au playbook », « à dire ».""" + actions = actions or {} + etapes = construire(report) + plan = PlanCorrection() + toutes = etapes.etapes + (etapes.facultatives if clients else []) + for etape in toutes: + if _est_manuelle(etape, actions): + plan.manuelles.append(etape) + elif etape.remede is not None and etape.remede.root: + plan.root.append(etape) + else: + plan.sans_sudo.append(etape) + return plan + + +# ── le playbook du poste ────────────────────────────────────────────────────── + +#: ``sudo`` en tête de commande, ou après un tube ou un ``&&`` : le playbook +#: tourne déjà en root (``become``), le préfixe n'a plus d'objet. +_SUDO = re.compile(r"(^|[|&;]\s*|\s)sudo\s+") + +#: ``apt install`` ou ``dnf install`` sans ``-y`` attend une réponse qu'aucun +#: playbook ne donnera : le paquet n'est jamais installé. +_INSTALL = re.compile(r"\b(apt|apt-get|dnf|yum)\s+install\b(?!\s+-y)") + +#: Un nom de compte, tel que ``useradd`` l'accepte : rien d'autre n'entre +#: dans une commande jouée en root. +_COMPTE = re.compile(r"^[a-z_][a-z0-9_-]*[$]?$") + + +def lignes_root(lignes: tuple[str, ...], utilisateur: str) -> str: + """Les lignes d'un remède, telles que le playbook les joue en root. + + Trois transformations, et aucune autre : ``sudo`` retiré (le playbook est + déjà root), ``-y`` ajouté aux installations, et ``$USER`` remplacé par le + compte de l'apprenant. Sous ``become``, ``$USER`` vaudrait ``root`` : + ``usermod -aG libvirt $USER`` ajouterait root au groupe, et rien ne + changerait pour l'apprenant. + """ + if not _COMPTE.match(utilisateur): + msg = f"refusing an unusual account name in a root command: {utilisateur!r}" + raise ValueError(msg) + jouees = [] + for ligne in lignes: + sans_sudo = _SUDO.sub(lambda m: m.group(1), ligne) + sans_question = _INSTALL.sub(lambda m: f"{m.group(0)} -y", sans_sudo) + jouees.append(sans_question.replace("$USER", utilisateur)) + return "\n".join(["set -e", *jouees]) + "\n" + + +def playbook_du_poste(etapes: list[Etape], utilisateur: str) -> str: + """Le playbook qui joue les étapes root, une tâche par étape, dans l'ordre. + + Généré depuis la table des remèdes, jamais écrit à la main : ce qu'il joue + est exactement ce que ``doctor`` affiche, aux trois transformations près de + :func:`lignes_root`. + """ + taches = [] + for etape in etapes: + assert etape.remede is not None + taches.append({ + "name": f"{etape.numero}. {etape.cle}", + "ansible.builtin.shell": lignes_root(etape.remede.lignes, utilisateur), + "args": {"executable": "/bin/bash"}, + "environment": {"DEBIAN_FRONTEND": "noninteractive"}, + "tags": [etape.remede.tag or etape.cle], + }) + jeu = [{ + "name": "dsoxlab doctor --fix", + "hosts": "localhost", + "gather_facts": False, + "become": True, + # Sans cette variable, Ansible avertit qu'il a « découvert » python3 : + # vrai, sans objet ici, et c'est la seule ligne jaune que l'apprenant + # voyait (réévaluation du 2026-11-16 sur AlmaLinux 10). + "vars": {"ansible_python_interpreter": "auto_silent"}, + "tasks": taches, + }] + return yaml.safe_dump(jeu, sort_keys=False, allow_unicode=True, width=1000) + + +def chemin_du_playbook() -> Path: + base = Path(os.environ.get("XDG_CACHE_HOME") or Path.home() / ".cache") + return base / "dsoxlab" / "poste.yml" + + +# ── revérification ──────────────────────────────────────────────────────────── + +def _reussi(check: Check) -> bool: + """Un contrôle revenu au vert, ou qui n'attend plus qu'une reconnexion.""" + if check.state == STATE_OK: + return True + remede = check.remede + return remede is not None and remede.reconnexion and not remede.lignes + + +def etape_verifiee(etape: Etape, apres: DoctorReport) -> bool: + """L'étape a-t-elle produit son effet ? On le lit dans un diagnostic refait. + + Un code de retour nul ne suffit pas : ``apt install`` sort en 0 sur un + paquet déjà présent qui ne règle rien, et un ``uv tool install`` peut + poser un binaire hors du PATH. C'est le contrôle qui fait foi. + """ + cles = {c.key for c in etape.controles} + nouveaux = [c for c in [*apres.required, *apres.optional] if c.key in cles] + return bool(nouveaux) and all(_reussi(c) for c in nouveaux) @dataclass(frozen=True) class Application: - """Un correctif joué, et ce qu'il faut en dire.""" + """Une étape jouée, et ce qu'il faut en dire.""" - label: str + etape: Etape code: int - kind: FixKind + verifiee: bool + message: str | None = None @property def ok(self) -> bool: - return self.code == 0 + return self.code == 0 and self.verifiee @property def avis_differe(self) -> str | None: """La clé du message à afficher quand l'effet n'est pas immédiat.""" if not self.ok: return None - if self.kind is FixKind.NEEDS_RELOGIN: + if self.etape.remede is not None and self.etape.remede.reconnexion: + return "fix_needs_relogin" + correctif = _correctif(self.etape) + if correctif is not None and correctif.kind is FixKind.NEEDS_RELOGIN: return "fix_needs_relogin" - if self.kind is FixKind.NEEDS_REBOOT: + if correctif is not None and correctif.kind is FixKind.NEEDS_REBOOT: return "fix_needs_reboot" return None - - -def planifier(report: DoctorReport) -> PlanCorrection: - """Partage les correctifs du rapport entre « à dire » et « à jouer ».""" - manuels: list[tuple[str, Fix]] = [] - executables: list[tuple[str, Fix]] = [] - for controle in report.fixable(): - if controle.fix is None: - continue - cible = manuels if controle.fix.kind is FixKind.MANUAL else executables - cible.append((controle.label, controle.fix)) - return PlanCorrection(tuple(manuels), tuple(executables)) - - -def obstacle(plan: PlanCorrection, *, interactif: bool | None = None) -> str | None: - """La clé du message qui empêche la cascade, ou ``None`` si la voie est libre. - - Un correctif par sudo a besoin d'un terminal pour demander le mot de passe, - et de ``sudo`` lui-même. Les deux se vérifient **avant** d'en jouer un seul : - échouer au milieu d'une cascade laisse la machine dans un état que personne - n'a décrit. - """ - if not plan.correctifs_sudo: - return None - if interactif is None: - interactif = sys.stdin.isatty() - if not interactif: - return "fix_needs_tty" - if shutil.which("sudo") is None: - return "fix_no_sudo" - return None - - -def appliquer( - executables: Iterable[tuple[str, Fix]], - executer: Executeur, - *, - sur_debut: Callable[[str, Fix], None] | None = None, - sur_resultat: Callable[[Application], None] | None = None, -) -> list[Application]: - """Joue la cascade entière, sans jamais s'arrêter sur un échec. - - Les deux rappels encadrent chaque correctif, pour que l'appelant rende au - fil de l'eau : ``sur_debut`` nomme la commande avant qu'elle parte, puisque - sa sortie va arriver sur le terminal sans rien pour l'annoncer, et - ``sur_resultat`` dit ce qu'elle a donné. Une cascade de dix correctifs qui - n'afficherait rien avant la fin donnerait l'impression d'avoir gelé. - """ - resultats: list[Application] = [] - for label, fix in executables: - if sur_debut is not None: - sur_debut(label, fix) - application = Application(label=label, code=executer(fix), kind=fix.kind) - resultats.append(application) - if sur_resultat is not None: - sur_resultat(application) - return resultats diff --git a/tests/test_doc_installation.py b/tests/test_doc_installation.py new file mode 100644 index 0000000..e8d8561 --- /dev/null +++ b/tests/test_doc_installation.py @@ -0,0 +1,56 @@ +"""La doc d'installation dit les commandes de la table des remèdes, mot pour mot. + +Décision 5 du 2026-11-16 : la doc d'installation et le diagnostic donnent les +mêmes commandes, avec ``sudo`` partout. Avant, la doc annonçait que ``--fix`` +ne connaissait qu'apt et que Terraform se réduisait à un lien, alors que le +diagnostic, lui, avait changé. Ce test part de la table, pas de la doc : une +commande ajoutée ou corrigée dans la table et oubliée ici le fait échouer. +""" + +from __future__ import annotations + +from pathlib import Path + +import pytest + +from dsoxlab.services.doctor_controles import remedes + +DOCS = Path(__file__).resolve().parent.parent / "docs" + +#: Les deux familles que dsoxlab éprouve, et dont la doc donne les commandes. +FAMILLES = { + "ubuntu": "ID=ubuntu\nID_LIKE=debian\n", + "almalinux": 'ID="almalinux"\nID_LIKE="rhel centos fedora"\n', +} + + +def _lignes(tmp_path: Path, contenu: str) -> list[tuple[str, str]]: + fichier = tmp_path / "os-release" + fichier.write_text(contenu, encoding="utf-8") + systeme = remedes.systeme(fichier) + lignes = [] + for cle in remedes.TABLE: + remede = remedes.remede(cle, systeme) + if remede is not None: + lignes.extend((cle, ligne) for ligne in remede.lignes) + return lignes + + +@pytest.mark.parametrize("page", ["learner.md", "learner.fr.md"]) +@pytest.mark.parametrize("famille", list(FAMILLES)) +def test_chaque_commande_de_la_table_est_dans_la_doc( + tmp_path: Path, page: str, famille: str, +) -> None: + texte = (DOCS / page).read_text(encoding="utf-8") + absentes = [ + f"{cle}: {ligne}" for cle, ligne in _lignes(tmp_path, FAMILLES[famille]) + if ligne not in texte + ] + assert absentes == [], f"{page} ne dit pas ces commandes de la table ({famille})" + + +@pytest.mark.parametrize("page", ["learner.md", "learner.fr.md"]) +def test_la_doc_ne_promet_plus_un_lien_a_la_place_d_une_commande(page: str) -> None: + texte = (DOCS / page).read_text(encoding="utf-8") + assert "developer.hashicorp.com/terraform/install" not in texte + assert "sed -i '1i Include" not in texte diff --git a/tests/test_doctor.py b/tests/test_doctor.py index 1111cf6..9785783 100644 --- a/tests/test_doctor.py +++ b/tests/test_doctor.py @@ -111,6 +111,12 @@ def _outillage_present(monkeypatch: pytest.MonkeyPatch) -> None: doctor, "_check_resources", lambda infra, provider: doctor._check("resources", True, "ok"), ) + # Les contrôles de la refonte du 2026-11-16 lisent eux aussi la machine + # (groupes du compte, firmware, ~/.ssh/config, clé du catalogue). + monkeypatch.setattr(doctor, "_check_groupes", lambda kvm_ok: doctor._check("groupes", True, "ok")) + monkeypatch.setattr(doctor, "_check_efi", lambda kvm_ok: doctor._check("efi", True, "OVMF")) + monkeypatch.setattr(doctor, "_check_cle_ssh", lambda root: doctor._check("cle_ssh", True, "ok")) + monkeypatch.setattr(doctor, "_check_ssh_include", lambda: doctor._check("ssh_include", True, "ok")) def _labs(monkeypatch: pytest.MonkeyPatch, labs: list[LabDefinition]) -> None: @@ -208,10 +214,12 @@ def test_unresolved_provider_is_a_decision_not_a_failure( """Several candidates and no choice: name the choice, do not make it. The check is blocking, since `provision` cannot run without it, but it - carries its own status so a pending decision is not painted red. It - stays a hint too: choosing a provider for the learner would silently - decide how their labs run. + carries its own status so a pending decision is not painted red. Nothing + is recorded: the choice stays a step that the learner confirms. """ + device = tmp_path / "kvm" + device.touch() + monkeypatch.setattr(doctor, "_KVM_DEVICE", device) _labs(monkeypatch, [_lab("a", RuntimeType.VM)]) report = doctor.collect_checks(tmp_path, _repo(candidates=["kvm", "incus"])) @@ -220,7 +228,34 @@ def test_unresolved_provider_is_a_decision_not_a_failure( assert provider.state == doctor.STATE_CHOICE_REQUIRED assert provider.fix is None assert "use --provider kvm" in (provider.hint or "") - assert not report.fixable() + assert report.provider == "kvm" + assert report.provider_a_confirmer + + +def test_unresolved_provider_checks_the_recommended_path_only( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch, stub_hypervisors: None +) -> None: + """No choice made: the diagnosis follows the recommended provider (kvm on a + Linux with /dev/kvm) and hides none of its checks, so one pass shows every + missing step (2026-11-16 rework). Only that hypervisor becomes required: + `--fix` must never install kvm AND incus for an undecided choice. + """ + device = tmp_path / "kvm" + device.touch() + monkeypatch.setattr(doctor, "_KVM_DEVICE", device) + _labs(monkeypatch, [_lab("a", RuntimeType.VM)]) + report = doctor.collect_checks(tmp_path, _repo(candidates=["kvm", "incus"])) + + requis = {c.key for c in report.required} + assert {"kvm", "groupes", "libvirt_pool", "efi", "cle_ssh", "ssh_include"} <= requis + assert "incus" not in requis + assert "incus" in {c.key for c in report.optional} + # virsh is missing in this stub: the pool cannot be measured, it waits for + # the kvm step instead of disappearing. + pool = next(c for c in report.required if c.key == "libvirt_pool") + assert pool.state == doctor.STATE_UNKNOWN + assert pool.apres == "kvm" + assert pool.remede is not None and "pool-define-as" in pool.remede.lignes[0] def test_legacy_runtime_aliases_still_count_as_vm() -> None: diff --git a/tests/test_doctor_fix.py b/tests/test_doctor_fix.py index 72a00af..302e931 100644 --- a/tests/test_doctor_fix.py +++ b/tests/test_doctor_fix.py @@ -1,17 +1,18 @@ -"""`doctor --fix` : un correctif typé, joué sans shell, catégorisé. - -Ce que ce module prouve, catégorie par catégorie : - -- AUTOMATIC s'exécute par le wrapper centralisé, token par token : un argument - qui porte une espace arrive **entier** à la commande, ce qu'une chaîne - passée à un shell aurait redécoupé en deux mots ; -- MANUAL n'est **jamais** exécuté : il est affiché, le geste appartient à - l'humain ; -- NEEDS_RELOGIN et NEEDS_REBOOT s'exécutent, puis disent que la ligne restera - rouge jusqu'à la reconnexion ou au redémarrage : sans ce message, - l'utilisateur relançait `doctor`, revoyait le rouge, et croyait le correctif - en échec ; -- une séquence de commandes s'arrête au premier échec, et le dit. +"""`doctor --fix` de bout en bout, sur un diagnostic injecté. + +Ce que ce module prouve : + +- rien ne part sans confirmation : sans terminal et sans ``--yes``, aucune + commande n'est lancée, et le message dit comment faire ; +- une étape sans sudo part en argv, token par token : un argument qui porte + une espace arrive **entier**, ce qu'un shell aurait redécoupé ; +- un correctif MANUAL n'est **jamais** exécuté ; +- chaque étape est revérifiée par un diagnostic refait, et la **première** qui + échoue arrête tout, en nommant les étapes restantes ; +- un succès à effet différé (reconnexion, redémarrage) le dit ; +- les étapes root passent par le playbook du poste, jamais par un ``sudo`` + lancé en silence ; sans terminal pour le mot de passe, elles s'affichent en + bloc à coller. Et la preuve de fond : plus aucun ``shell=True`` dans ``src/dsoxlab/``. """ @@ -21,16 +22,23 @@ from pathlib import Path import pytest +import yaml from typer.testing import CliRunner from dsoxlab.cli import app, diagnostic from dsoxlab.services import doctor as service_doctor from dsoxlab.services.doctor import DoctorReport, Fix, FixKind +from dsoxlab.services.doctor_controles.remedes import Remede from dsoxlab.utils.shell import CommandResult runner = CliRunner() +def _texte(resultat: object) -> str: + """La sortie, espaces normalisés : Rich replie les phrases à la largeur du terminal.""" + return " ".join(resultat.output.split()) # type: ignore[attr-defined] + + @pytest.fixture(autouse=True) def environnement(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: """Un dépôt vide suffit : le rapport est injecté, pas découvert.""" @@ -38,146 +46,291 @@ def environnement(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: monkeypatch.setenv("DSOXLAB_LANG", "en") for variable in ("XDG_STATE_HOME", "XDG_CACHE_HOME", "XDG_DATA_HOME"): monkeypatch.setenv(variable, str(tmp_path / variable.lower())) + monkeypatch.setattr(diagnostic, "_interactif", lambda: False) -def _rapport(*correctifs: Fix) -> DoctorReport: - """Un diagnostic où chaque correctif porte un contrôle en échec.""" - report = DoctorReport() - for index, correctif in enumerate(correctifs): - report.required.append( - service_doctor.Check( - key=f"composant_{index}", - label=f"Component {index}", - ok=False, - detail="broken", - fix=correctif, - ) - ) - return report +def _check(index: int, ok: bool, correctif: Fix | None = None, + remede: Remede | None = None) -> service_doctor.Check: + return service_doctor._check( + f"composant_{index}", ok, "ok" if ok else "broken", fix=correctif, remede=remede, + ) -def _doctor_fix( - monkeypatch: pytest.MonkeyPatch, *correctifs: Fix -) -> tuple[list[list[str]], object]: - """Joue `doctor --fix` sur un rapport injecté, en espionnant run_command. +class Diagnostics: + """Le premier diagnostic montre les correctifs ; les suivants, ce qu'ils ont produit. - Rend les argv **exacts** reçus par le wrapper, et le résultat CLI. Aucun - shell ne tourne : ce que l'espion enregistre est ce que la commande - recevrait. + ``repares`` liste les indices que les correctifs ont réellement réparés : + un correctif « réussi » dont le contrôle reste rouge n'est pas une réussite. """ + + def __init__(self, correctifs: list[Fix | None], remedes: list[Remede | None] | None = None, + repares: set[int] | None = None) -> None: + self.correctifs = correctifs + self.remedes = remedes or [None] * len(correctifs) + self.repares = set(range(len(correctifs))) if repares is None else repares + self.appels = 0 + + def __call__(self, root: Path, meta: object) -> DoctorReport: + self.appels += 1 + report = DoctorReport() + for i, (correctif, remede) in enumerate(zip(self.correctifs, self.remedes, strict=True)): + ok = self.appels > 1 and i in self.repares + report.required.append(_check(i, ok, None if ok else correctif, None if ok else remede)) + return report + + +def _doctor_fix( + monkeypatch: pytest.MonkeyPatch, diagnostics: Diagnostics, *options: str, + code: int = 0, +) -> tuple[list[list[str]], object]: + """Joue `doctor --fix` en espionnant run_command : rend les argv exacts reçus.""" appels: list[list[str]] = [] def faux_run_command(cmd: list[str], **kwargs: object) -> CommandResult: appels.append(list(cmd)) - return CommandResult(returncode=0, stdout="", stderr="") + return CommandResult(returncode=code, stdout="", stderr="boom" if code else "") monkeypatch.setattr(diagnostic, "run_command", faux_run_command) - monkeypatch.setattr( - diagnostic, "collect_checks", lambda root, meta: _rapport(*correctifs) - ) - resultat = runner.invoke(app, ["doctor", "--fix"]) + monkeypatch.setattr(diagnostic, "collect_checks", diagnostics) + resultat = runner.invoke(app, ["doctor", "--fix", *options]) return appels, resultat +def test_sans_terminal_ni_yes_rien_ne_part(monkeypatch: pytest.MonkeyPatch) -> None: + """Le plan s'affiche, et rien n'est lancé : un script doit le demander par --yes.""" + correctif = Fix((("install-tool",),)) + + appels, resultat = _doctor_fix(monkeypatch, Diagnostics([correctif])) + + assert appels == [] + assert resultat.exit_code == 1 + assert "Add --yes" in _texte(resultat) + assert "install-tool" in _texte(resultat), "le plan est affiché avant le refus" + + def test_un_argument_avec_espace_reste_un_seul_token( monkeypatch: pytest.MonkeyPatch, ) -> None: - """AUTOMATIC : la commande part en argv, jamais dans un shell. - - C'est LE test qui prouve le gain : « two words » passé à - ``subprocess.run(..., shell=True)`` aurait été redécoupé en deux - arguments par le shell. En tokens, il arrive entier. - """ + """Une étape sans sudo part en argv, jamais dans un shell.""" correctif = Fix((("install-tool", "--label", "two words"),)) - appels, resultat = _doctor_fix(monkeypatch, correctif) + appels, resultat = _doctor_fix(monkeypatch, Diagnostics([correctif]), "--yes") assert resultat.exit_code == 0 assert appels == [["install-tool", "--label", "two words"]] - assert "remediation successful" in resultat.stdout + assert "done, checked again" in _texte(resultat) -def test_manuel_affiche_et_jamais_execute( - monkeypatch: pytest.MonkeyPatch, -) -> None: +def test_manuel_affiche_et_jamais_execute(monkeypatch: pytest.MonkeyPatch) -> None: """MANUAL : `--fix` nomme le geste, et ne lance rien du tout.""" correctif = Fix((("rm", "-rf", "/something"),), kind=FixKind.MANUAL) - appels, resultat = _doctor_fix(monkeypatch, correctif) + appels, resultat = _doctor_fix(monkeypatch, Diagnostics([correctif]), "--yes") assert resultat.exit_code == 0 assert appels == [], "un correctif manuel ne doit jamais être exécuté" - assert "never run automatically" in resultat.stdout - assert "rm -rf /something" in resultat.stdout + assert "rm -rf /something" in _texte(resultat) + assert "yours to do" in _texte(resultat) -def test_reconnexion_le_rouge_persistant_est_annonce( +def test_un_succes_dont_le_controle_reste_rouge_est_un_echec( monkeypatch: pytest.MonkeyPatch, ) -> None: - """NEEDS_RELOGIN : exécuté, puis le message dit que le rouge va rester. + """Un code nul ne suffit pas : `apt install` sort en 0 sur ce qui ne règle rien.""" + correctif = Fix((("install-tool",),)) - Un `usermod -aG` réussi laisse la ligne rouge jusqu'à la session - suivante : sans cette phrase, le prochain `doctor` ressemble à un échec. - """ - correctif = Fix( - (("usermod", "-aG", "incus", "student"),), kind=FixKind.NEEDS_RELOGIN + appels, resultat = _doctor_fix( + monkeypatch, Diagnostics([correctif], repares=set()), "--yes", + ) + + assert appels == [["install-tool"]] + assert "the check is still not green" in _texte(resultat) + assert "Remaining steps: 1" in _texte(resultat) + + +def test_le_premier_echec_arrete_les_suivants(monkeypatch: pytest.MonkeyPatch) -> None: + """L'ancienne cascade continuait : un pool créé sans libvirt, des collections + sans Ansible. Désormais la première étape qui échoue arrête tout.""" + premier = Fix((("premiere", "etape"),)) + second = Fix((("seconde", "etape"),)) + + appels, resultat = _doctor_fix( + monkeypatch, Diagnostics([premier, second]), "--yes", code=3, ) - appels, resultat = _doctor_fix(monkeypatch, correctif) + assert appels == [["premiere", "etape"]], "la seconde étape ne doit pas partir" + assert "failed (code 3)" in _texte(resultat) + assert "Remaining steps: 1, 2" in _texte(resultat) + + +def test_une_sequence_s_arrete_au_premier_echec(monkeypatch: pytest.MonkeyPatch) -> None: + """Dans une même étape, la seconde commande ne part pas après un échec.""" + correctif = Fix((("premiere", "etape"), ("seconde", "etape"))) + + appels, resultat = _doctor_fix(monkeypatch, Diagnostics([correctif]), "--yes", code=3) + + assert appels == [["premiere", "etape"]] + assert "failed (code 3)" in _texte(resultat) + + +def test_reconnexion_le_rouge_persistant_est_annonce( + monkeypatch: pytest.MonkeyPatch, +) -> None: + correctif = Fix((("usermod", "-aG", "incus", "student"),), kind=FixKind.NEEDS_RELOGIN) + + appels, resultat = _doctor_fix(monkeypatch, Diagnostics([correctif]), "--yes") assert appels == [["usermod", "-aG", "incus", "student"]] - assert "remediation successful" in resultat.stdout - assert "log out" in resultat.stdout - assert "stay red" in resultat.stdout + assert "log out" in _texte(resultat) + assert "stay red" in _texte(resultat) def test_redemarrage_le_rouge_persistant_est_annonce( monkeypatch: pytest.MonkeyPatch, ) -> None: - """NEEDS_REBOOT : exécuté, puis le message annonce l'effet différé.""" correctif = Fix((("modprobe", "kvm"),), kind=FixKind.NEEDS_REBOOT) - appels, resultat = _doctor_fix(monkeypatch, correctif) + appels, resultat = _doctor_fix(monkeypatch, Diagnostics([correctif]), "--yes") assert appels == [["modprobe", "kvm"]] - assert "remediation successful" in resultat.stdout - assert "after a reboot" in resultat.stdout - assert "stay red" in resultat.stdout + assert "after a reboot" in _texte(resultat) -def test_une_sequence_s_arrete_au_premier_echec( - monkeypatch: pytest.MonkeyPatch, +_ROOT = Remede("composant_0", ("sudo apt install libvirt-clients",), root=True, tag="libvirt") + + +def test_sans_terminal_les_etapes_root_s_affichent_a_coller( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch, ) -> None: - """Un correctif en plusieurs commandes ne poursuit pas après un échec. + """Personne ne peut taper le mot de passe : rien n'est lancé, le bloc s'affiche. - C'est l'équivalent typé du ``&&`` d'hier : `pool-build` sur un - `pool-define-as` raté n'a aucun sens, et le code d'échec doit remonter. + ansible-playbook est bien là : c'est l'absence de terminal, et elle seule, + qui doit empêcher le lancement. """ - appels: list[list[str]] = [] + binaire = tmp_path / "ansible-playbook" + binaire.write_text("#!/bin/sh\n", encoding="utf-8") + binaire.chmod(0o755) + lancements: list[list[str]] = [] + monkeypatch.setattr(diagnostic, "_commande_playbook", + lambda chemin: [str(binaire), "--ask-become-pass", str(chemin)]) + monkeypatch.setattr(diagnostic.subprocess, "run", + lambda cmd, **kw: lancements.append(cmd)) - def run_qui_echoue(cmd: list[str], **kwargs: object) -> CommandResult: - appels.append(list(cmd)) - return CommandResult(returncode=3, stdout="", stderr="boom") + appels, resultat = _doctor_fix(monkeypatch, Diagnostics([None], [_ROOT]), "--yes") - correctif = Fix((("premiere", "etape"), ("seconde", "etape"))) - monkeypatch.setattr(diagnostic, "run_command", run_qui_echoue) - monkeypatch.setattr( - diagnostic, "collect_checks", lambda root, meta: _rapport(correctif) - ) + assert appels == [] and lancements == [] + assert "Paste these sudo steps" in _texte(resultat) + assert "sudo apt install libvirt-clients" in _texte(resultat) - resultat = runner.invoke(app, ["doctor", "--fix"]) - assert appels == [["premiere", "etape"]], "la seconde étape ne doit pas partir" - assert "remediation failed (code 3)" in resultat.stderr +def test_les_etapes_root_passent_par_le_playbook_du_poste( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch, +) -> None: + """Un seul ansible-playbook, aucun sudo lancé par dsoxlab, et un playbook qui + joue la ligne affichée, sans sudo et sans question.""" + binaire = tmp_path / "ansible-playbook" + binaire.write_text("#!/bin/sh\n", encoding="utf-8") + binaire.chmod(0o755) + lancements: list[list[str]] = [] + + class Fini: + returncode = 0 + + monkeypatch.setattr(diagnostic, "_interactif", lambda: True) + monkeypatch.setattr(diagnostic, "_current_user", lambda: "student") + monkeypatch.setattr(diagnostic, "_commande_playbook", + lambda chemin: [str(binaire), "--ask-become-pass", str(chemin)]) + monkeypatch.setattr(diagnostic.subprocess, "run", + lambda cmd, **kw: (lancements.append(cmd), Fini())[1]) + + appels, resultat = _doctor_fix(monkeypatch, Diagnostics([None], [_ROOT]), "--yes") + + assert appels == [], "aucune commande root ne part par run_command" + assert len(lancements) == 1 and lancements[0][0] == str(binaire) + jeu = yaml.safe_load(Path(lancements[0][-1]).read_text(encoding="utf-8")) + script = jeu[0]["tasks"][0]["ansible.builtin.shell"] + assert "apt install -y libvirt-clients" in script + assert "sudo" not in script + assert "done, checked again" in _texte(resultat) + + +def test_sans_ansible_fix_l_installe_avant_le_playbook( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch, +) -> None: + """Décision 3 : le playbook du poste a besoin d'Ansible, installé sans sudo. + Le cas réel : une AlmaLinux 10 sans git ni catalogue, où la seule étape est + root et où aucune étape « installer Ansible » n'est au plan. + """ + binaire = tmp_path / "bin" / "ansible-playbook" + lancements: list[list[str]] = [] -def test_le_display_requote_ce_qui_doit_l_etre() -> None: - """La forme affichée se relit telle qu'elle s'exécute, espaces comprises.""" - correctif = Fix((("echo", "deux mots"), ("touch", "fichier"))) + class Fini: + returncode = 0 - assert correctif.display == "echo 'deux mots' && touch fichier" - assert not correctif.requires_sudo - assert Fix((("sudo", "apt", "install", "x"),)).requires_sudo + def faux_run_command(cmd: list[str], **kwargs: object) -> CommandResult: + appels.append(list(cmd)) + binaire.parent.mkdir(exist_ok=True) + binaire.write_text("#!/bin/sh\n", encoding="utf-8") + binaire.chmod(0o755) + return CommandResult(returncode=0, stdout="", stderr="") + + appels: list[list[str]] = [] + monkeypatch.setattr(diagnostic, "_interactif", lambda: True) + monkeypatch.setattr(diagnostic, "_current_user", lambda: "student") + monkeypatch.setattr(diagnostic, "_commande_playbook", + lambda chemin: [str(binaire), "--ask-become-pass", str(chemin)]) + monkeypatch.setattr(diagnostic.shutil, "which", + lambda nom: "/usr/bin/uv" if nom == "uv" else ( + str(binaire) if nom == "ansible-playbook" and binaire.exists() else None)) + monkeypatch.setattr(diagnostic.subprocess, "run", + lambda cmd, **kw: (lancements.append(cmd), Fini())[1]) + monkeypatch.setattr(diagnostic, "run_command", faux_run_command) + monkeypatch.setattr(diagnostic, "collect_checks", Diagnostics([None], [_ROOT])) + + resultat = runner.invoke(app, ["doctor", "--fix", "--yes"]) + + assert appels == [["uv", "tool", "install", "ansible-core"]] + assert len(lancements) == 1 and lancements[0][0] == str(binaire) + assert "done, checked again" in _texte(resultat) + + +def test_un_controle_qui_attendait_le_playbook_est_reverifie_apres( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch, +) -> None: + """Le firmware EFI attend libvirt : ni « à faire vous-même », ni oublié.""" + binaire = tmp_path / "ansible-playbook" + binaire.write_text("#!/bin/sh\n", encoding="utf-8") + binaire.chmod(0o755) + appels = {"n": 0} + + def diagnostics(root: Path, meta: object) -> DoctorReport: + appels["n"] += 1 + report = DoctorReport() + fait = appels["n"] > 1 + report.required.append(service_doctor._check( + "composant_0", fait, "x", remede=None if fait else _ROOT)) + report.required.append(service_doctor._check( + "efi", fait, "OVMF" if fait else "attend libvirt", + forced_state=None if fait else service_doctor.STATE_UNKNOWN, + apres=None if fait else "composant_0")) + return report + + class Fini: + returncode = 0 + + monkeypatch.setattr(diagnostic, "_interactif", lambda: True) + monkeypatch.setattr(diagnostic, "_current_user", lambda: "student") + monkeypatch.setattr(diagnostic, "_commande_playbook", + lambda chemin: [str(binaire), "--ask-become-pass", str(chemin)]) + monkeypatch.setattr(diagnostic.subprocess, "run", lambda cmd, **kw: Fini()) + monkeypatch.setattr(diagnostic, "collect_checks", diagnostics) + + sortie = _texte(runner.invoke(app, ["doctor", "--fix", "--yes"])) + + assert "Checked again after the playbook" in sortie + assert "To do yourself" not in sortie + assert "checked after the playbook, ready" in sortie def test_plus_aucun_shell_true_dans_les_sources() -> None: @@ -189,3 +342,12 @@ def test_plus_aucun_shell_true_dans_les_sources() -> None: if "shell=True" in chemin.read_text(encoding="utf-8") ] assert coupables == [] + + +def test_le_display_requote_ce_qui_doit_l_etre() -> None: + """La forme affichée se relit telle qu'elle s'exécute, espaces comprises.""" + correctif = Fix((("echo", "deux mots"), ("touch", "fichier"))) + + assert correctif.display == "echo 'deux mots' && touch fichier" + assert not correctif.requires_sudo + assert Fix((("sudo", "apt", "install", "x"),)).requires_sudo diff --git a/tests/test_doctor_guide.py b/tests/test_doctor_guide.py new file mode 100644 index 0000000..4cb21e4 --- /dev/null +++ b/tests/test_doctor_guide.py @@ -0,0 +1,481 @@ +"""Le diagnostic qui guide jusqu'au bout (refonte du 2026-11-16). + +Ce que ce module prouve, sans toucher la machine : + +- la table des remèdes donne une commande à coller pour chaque étape, par + famille de distribution, et jamais un lien ; +- la ligne Include se pose en tête de ``~/.ssh/config``, que le fichier soit + absent, vide ou rempli (``sed -i '1i …'`` n'écrit rien dans un fichier vide) ; +- les nouveaux contrôles (groupes, firmware EFI, clé du catalogue, Include) + disent la bonne chose dans chacun de leurs cas ; +- aucun contrôle ne se cache : sans libvirt, le pool, le groupe et le firmware + attendent l'étape qui l'installe ; +- les étapes se numérotent dans l'ordre des dépendances, et deux contrôles + réparés par la même commande sont une seule étape ; +- la mémoire qui ne suffit pas pour tout le catalogue informe sans bloquer, + sauf pour ``start ``. +""" + +from __future__ import annotations + +import os +import shutil +import subprocess +from pathlib import Path + +import pytest + +from dsoxlab.infra import inventory +from dsoxlab.models.lab import LabDefinition, ValidationConfig +from dsoxlab.models.repo import HostDefinition, InfraDefinition, RepoMetadata +from dsoxlab.models.runtime import RuntimeConfig, RuntimeType, Target +from dsoxlab.services import doctor +from dsoxlab.services.doctor_controles import kvm as kvm_controles +from dsoxlab.services.doctor_controles import remedes +from dsoxlab.services.doctor_controles.catalogue import creer_cle_ssh +from dsoxlab.services.doctor_controles.outillage import _terraform_depasse +from dsoxlab.services.doctor_etapes import construire + +UBUNTU = 'ID=ubuntu\nID_LIKE=debian\nPRETTY_NAME="Ubuntu 24.04.5 LTS"\n' +ALMA = 'ID="almalinux"\nID_LIKE="rhel centos fedora"\nPRETTY_NAME="AlmaLinux 10.2"\n' + + +def _os_release(monkeypatch: pytest.MonkeyPatch, tmp_path: Path, contenu: str) -> None: + fichier = tmp_path / "os-release" + fichier.write_text(contenu, encoding="utf-8") + monkeypatch.setattr(remedes, "OS_RELEASE", fichier) + + +# ── la famille de distribution ──────────────────────────────────────────────── + +@pytest.mark.parametrize(("contenu", "famille", "identifiant"), [ + (UBUNTU, remedes.Famille.DEBIAN, "ubuntu"), + ("ID=debian\n", remedes.Famille.DEBIAN, "debian"), + (ALMA, remedes.Famille.RHEL, "almalinux"), + ('ID=fedora\nPRETTY_NAME="Fedora Linux 43"\n', remedes.Famille.RHEL, "fedora"), + ('ID="rocky"\nID_LIKE="rhel centos fedora"\n', remedes.Famille.RHEL, "rocky"), +]) +def test_la_famille_se_lit_dans_os_release( + tmp_path: Path, contenu: str, famille: remedes.Famille, identifiant: str, +) -> None: + fichier = tmp_path / "os-release" + fichier.write_text(contenu, encoding="utf-8") + systeme = remedes.systeme(fichier) + assert (systeme.famille, systeme.identifiant) == (famille, identifiant) + + +def test_un_os_release_absent_retombe_sur_le_gestionnaire_present( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.setattr(remedes.shutil, "which", lambda n: "/usr/bin/dnf" if n == "dnf" else None) + assert remedes.systeme(tmp_path / "absent").famille is remedes.Famille.RHEL + monkeypatch.setattr(remedes.shutil, "which", lambda n: None) + assert remedes.systeme(tmp_path / "absent").famille is remedes.Famille.DEBIAN + + +# ── la table des remèdes ────────────────────────────────────────────────────── + +@pytest.mark.parametrize("contenu", [UBUNTU, ALMA, 'ID=fedora\n', "ID=debian\n"]) +def test_chaque_etape_a_une_commande_et_jamais_un_lien(tmp_path: Path, contenu: str) -> None: + fichier = tmp_path / "os-release" + fichier.write_text(contenu, encoding="utf-8") + systeme = remedes.systeme(fichier) + for cle in remedes.TABLE: + remede = remedes.remede(cle, systeme) + if cle == "incus" and systeme.famille is remedes.Famille.RHEL: + assert remede is None, "incus n'est dans aucun dépôt de base de la famille RHEL" + continue + assert remede is not None, cle + assert remede.lignes, cle + assert not any(ligne.startswith(("http://", "https://")) for ligne in remede.lignes), cle + # `root` se lit dans les lignes : il décide du playbook, il ne peut + # pas contredire la commande qu'il décrit. + assert remede.root == any("sudo " in ligne for ligne in remede.lignes), cle + + +def test_terraform_vient_du_depot_hashicorp_de_chaque_famille(tmp_path: Path) -> None: + for contenu, attendu in ( + (UBUNTU, "https://apt.releases.hashicorp.com"), + (ALMA, "https://rpm.releases.hashicorp.com/RHEL/hashicorp.repo"), + ("ID=fedora\n", "https://rpm.releases.hashicorp.com/fedora/hashicorp.repo"), + ): + fichier = tmp_path / "os-release" + fichier.write_text(contenu, encoding="utf-8") + remede = remedes.remede("terraform", remedes.systeme(fichier)) + assert remede is not None + assert any(attendu in ligne for ligne in remede.lignes), contenu + + +def test_docker_vise_le_depot_de_sa_distribution(tmp_path: Path) -> None: + for contenu, attendu in ((UBUNTU, "linux/ubuntu"), ("ID=debian\n", "linux/debian"), + (ALMA, "linux/rhel")): + fichier = tmp_path / "os-release" + fichier.write_text(contenu, encoding="utf-8") + remede = remedes.remede("docker", remedes.systeme(fichier)) + assert remede is not None + assert any(f"https://download.docker.com/{attendu}" in ligne for ligne in remede.lignes) + + +def test_l_ordre_de_la_table_est_celui_des_dependances() -> None: + rang = remedes.rang + assert rang("git") < rang("kvm") < rang("groupes") < rang("libvirt_pool") < rang("efi") + assert rang("ansible") < rang("collections") + assert rang("inconnue") == len(remedes.TABLE) + + +# ── la ligne Include de ~/.ssh/config ───────────────────────────────────────── + +_CONTENUS = {"absent": None, "vide": "", "rempli": "Host forge\n User git\n"} + + +@pytest.mark.skipif(shutil.which("bash") is None, reason="bash absent") +@pytest.mark.parametrize("cas", list(_CONTENUS)) +def test_la_commande_affichee_marche_sur_un_fichier_vide_absent_ou_rempli( + tmp_path: Path, cas: str, +) -> None: + """La commande telle qu'affichée, jouée par bash dans un HOME jetable.""" + contenu = _CONTENUS[cas] + if contenu is not None: + (tmp_path / ".ssh").mkdir() + (tmp_path / ".ssh" / "config").write_text(contenu, encoding="utf-8") + ligne = remedes.remede("ssh_include", remedes.systeme()) + assert ligne is not None + subprocess.run(["bash", "-c", ligne.lignes[0]], env={**os.environ, "HOME": str(tmp_path)}, + check=True) + + config = tmp_path / ".ssh" / "config" + assert config.read_text(encoding="utf-8") == f"{inventory.LIGNE_INCLUDE}\n{contenu or ''}" + assert config.stat().st_mode & 0o777 == 0o600 + + +@pytest.mark.parametrize("cas", list(_CONTENUS)) +def test_fix_pose_l_include_en_tete_quel_que_soit_le_fichier( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch, cas: str, +) -> None: + monkeypatch.setenv("HOME", str(tmp_path)) + contenu = _CONTENUS[cas] + if contenu is not None: + (tmp_path / ".ssh").mkdir() + (tmp_path / ".ssh" / "config").write_text(contenu, encoding="utf-8") + assert not inventory.ssh_config_include_present() + + inventory.ajouter_include_ssh() + + config = tmp_path / ".ssh" / "config" + assert config.read_text(encoding="utf-8").splitlines()[0] == inventory.LIGNE_INCLUDE + assert config.read_text(encoding="utf-8").endswith(contenu or "\n") + assert config.stat().st_mode & 0o777 == 0o600 + assert inventory.ssh_config_include_present() + assert doctor._check_ssh_include().ok + + +# ── Terraform : la version plus récente, sous -v seulement ──────────────────── + +def test_une_version_depassee_devient_une_mise_en_garde() -> None: + sortie = ( + "Terraform v1.16.1\non linux_amd64\n\nYour version of Terraform is out of date! " + "The latest version\nis 1.17.2. You can update by downloading from " + "https://developer.hashicorp.com/terraform/install\n" + ) + garde = _terraform_depasse(sortie) + assert garde is not None and "1.17.2" in garde + assert _terraform_depasse("Terraform v1.17.2\non linux_amd64\n") is None + + +# ── les groupes kvm et libvirt ──────────────────────────────────────────────── + +@pytest.fixture +def groupes(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> dict[str, object]: + """Pilote les sondes du contrôle des groupes : /dev/kvm, /etc/group, la session.""" + etat: dict[str, object] = {"gids": {"libvirt": 106}, "session": set(), "inscrits": set()} + device = tmp_path / "kvm" + device.touch() + monkeypatch.setattr(doctor, "_KVM_DEVICE", device) + monkeypatch.setattr(kvm_controles.os, "access", lambda p, m: True) + monkeypatch.setattr(kvm_controles, "_gid", lambda n: etat["gids"].get(n)) # type: ignore[attr-defined] # noqa: PLW0108 — relu à chaque appel + monkeypatch.setattr(kvm_controles, "_dans_la_session", lambda g: g in etat["session"]) # type: ignore[operator] + monkeypatch.setattr(kvm_controles, "_inscrit", lambda n, g: n in etat["inscrits"]) # type: ignore[operator] + return etat + + +def test_un_compte_dans_le_groupe_est_vert(groupes: dict[str, object]) -> None: + groupes["session"] = {106} + assert doctor._check_groupes(kvm_ok=True).ok + + +def test_sans_libvirt_le_groupe_attend_l_etape_kvm(groupes: dict[str, object]) -> None: + groupes["gids"] = {} + check = doctor._check_groupes(kvm_ok=False) + assert check.state == doctor.STATE_UNKNOWN + assert check.apres == "kvm" + assert check.remede is not None + assert check.remede.lignes == ("sudo usermod -aG libvirt $USER",) + + +def test_un_compte_absent_du_groupe_recoit_usermod(groupes: dict[str, object]) -> None: + check = doctor._check_groupes(kvm_ok=True) + assert check.state == doctor.STATE_FAILED + assert check.remede is not None and check.remede.reconnexion + assert "usermod -aG libvirt" in check.remede.lignes[0] + + +def test_un_compte_inscrit_mais_pas_reconnecte_n_a_qu_a_se_reconnecter( + groupes: dict[str, object], +) -> None: + """Rejouer usermod ne changerait rien : seule la reconnexion compte.""" + groupes["inscrits"] = {"libvirt"} + check = doctor._check_groupes(kvm_ok=True) + assert check.state == doctor.STATE_FAILED + assert check.remede is not None + assert check.remede.lignes == () + assert check.remede.reconnexion + + +def test_un_dev_kvm_ferme_ajoute_le_groupe_kvm( + groupes: dict[str, object], monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.setattr(kvm_controles.os, "access", lambda p, m: False) + check = doctor._check_groupes(kvm_ok=True) + assert check.remede is not None + assert check.remede.lignes == ("sudo usermod -aG kvm,libvirt $USER",) + + +def test_dev_kvm_ferme_mais_compte_deja_inscrit_n_attend_qu_une_reconnexion( + groupes: dict[str, object], monkeypatch: pytest.MonkeyPatch, +) -> None: + """Juste après `usermod`, /dev/kvm reste fermé dans la session : `--fix` + jugeait sa propre étape en échec (réévaluation sur Ubuntu 24.04).""" + monkeypatch.setattr(kvm_controles.os, "access", lambda p, m: False) + monkeypatch.setattr(doctor.os, "access", lambda p, m: False) + groupes["gids"] = {"libvirt": 106, "kvm": 993} + groupes["inscrits"] = {"kvm", "libvirt"} + + for check in (doctor._check_hw_virt(), doctor._check_groupes(kvm_ok=True)): + assert check.state == doctor.STATE_FAILED, check.key + assert check.remede is not None and check.remede.lignes == (), check.key + assert check.remede.reconnexion, check.key + + +# ── le firmware EFI ─────────────────────────────────────────────────────────── + +def test_le_firmware_attend_libvirt() -> None: + check = doctor._check_efi(kvm_ok=False) + assert check.state == doctor.STATE_UNKNOWN + assert check.apres == "kvm" + + +def test_le_firmware_trouve_est_nomme(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.setattr(kvm_controles.libvirt_infra, "efi_loader", + lambda: "/usr/share/OVMF/OVMF_CODE_4M.fd") + check = doctor._check_efi(kvm_ok=True) + assert check.ok and check.detail == "OVMF_CODE_4M.fd" + + +def test_sans_firmware_le_paquet_efi_est_propose( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch, +) -> None: + _os_release(monkeypatch, tmp_path, ALMA) + monkeypatch.setattr(kvm_controles.libvirt_infra, "efi_loader", lambda: None) + check = doctor._check_efi(kvm_ok=True) + assert check.state == doctor.STATE_FAILED + assert check.remede is not None and check.remede.lignes == ("sudo dnf install edk2-ovmf",) + + +# ── la clé SSH du catalogue ─────────────────────────────────────────────────── + +def test_une_cle_absente_fait_proposer_bootstrap(tmp_path: Path) -> None: + check = doctor._check_cle_ssh(tmp_path) + assert check.state == doctor.STATE_FAILED + assert check.remede is not None + assert check.remede.lignes == ("dsoxlab instructor bootstrap",) + + +@pytest.mark.skipif(shutil.which("ssh-keygen") is None, reason="ssh-keygen absent") +def test_fix_cree_la_cle_que_le_controle_attend(tmp_path: Path) -> None: + assert creer_cle_ssh(tmp_path) is None + assert doctor._check_cle_ssh(tmp_path).ok + assert (tmp_path / "ssh").stat().st_mode & 0o777 == 0o700 + # Une seconde fois ne réécrit rien. + empreinte = (tmp_path / "ssh" / "id_ed25519.pub").read_text(encoding="utf-8") + assert creer_cle_ssh(tmp_path) is None + assert (tmp_path / "ssh" / "id_ed25519.pub").read_text(encoding="utf-8") == empreinte + + +# ── kvm : un démon qui ne répond pas s'active pour de bon ───────────────────── + +def test_libvirtd_s_active_au_demarrage_et_pas_seulement_maintenant( + monkeypatch: pytest.MonkeyPatch, +) -> None: + """`systemctl start` ne survit pas au redémarrage : le rouge revenait.""" + monkeypatch.setattr(doctor.shutil, "which", lambda n: f"/usr/bin/{n}") + monkeypatch.setattr(doctor, "_sonde_virsh", lambda args, delai=5: None) + check = doctor._check_kvm() + assert check.fix is not None + assert check.fix.commands == (("sudo", "systemctl", "enable", "--now", "libvirtd"),) + + +# ── le classement : rien ne se cache, la mémoire informe ────────────────────── + +def _lab() -> LabDefinition: + return LabDefinition( + id="a", title="a", level="l1", skills=["s"], + runtime=RuntimeConfig(type=RuntimeType.VM, targets=[Target(name="t", host="a.lab")]), + distros=["alma10"], doc_url="https://example.test/doc", validation=ValidationConfig(), + ) + + +@pytest.fixture +def machine_vide(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> RepoMetadata: + """Un catalogue à deux machines (3 Go) sur un poste sans rien, 2 Go libres.""" + _os_release(monkeypatch, tmp_path, UBUNTU) + monkeypatch.setenv("HOME", str(tmp_path)) + device = tmp_path / "kvm" + device.touch() + monkeypatch.setattr(doctor, "_KVM_DEVICE", device) + monkeypatch.setattr(doctor, "get_all_labs", lambda root: [_lab()]) + monkeypatch.setattr(doctor.shutil, "which", lambda n: None) + monkeypatch.setattr(doctor.ansible_infra, "has_ansible_playbook", lambda: False) + monkeypatch.setattr(doctor, "_mem_available_mb", lambda: 2048) + monkeypatch.setattr(doctor, "_check_egress", lambda: doctor._check("egress", True, "ok")) + monkeypatch.setattr(kvm_controles, "_gid", lambda n: None) + return RepoMetadata(id="demo", category="demo", infra=InfraDefinition( + provider="kvm", + hosts=[HostDefinition(name="a.lab", ram_mb=2048), HostDefinition(name="b.lab", ram_mb=1024)], + )) + + +def test_une_machine_vide_voit_tous_ses_manques_en_une_passe( + tmp_path: Path, machine_vide: RepoMetadata, +) -> None: + plan = construire(doctor.collect_checks(tmp_path, machine_vide)) + cles = [e.cle for e in plan.etapes] + + assert cles == ["git", "kvm", "groupes", "libvirt_pool", "efi", "terraform", "ansible", + "cle_ssh", "ssh_include"] + numero = {e.cle: e.numero for e in plan.etapes} + attente = {e.cle: e.apres for e in plan.etapes} + for cle in ("groupes", "libvirt_pool", "efi"): + assert attente[cle] == numero["kvm"], cle + assert attente["git"] is None and attente["terraform"] is None + + +def test_la_memoire_de_tout_le_catalogue_informe_sans_bloquer( + tmp_path: Path, machine_vide: RepoMetadata, +) -> None: + report = doctor.collect_checks(tmp_path, machine_vide) + + assert "resources" not in {c.key for c in report.required} + assert [c.key for c in report.a_savoir] == ["resources"] + assert report.a_savoir[0].hint == "dsoxlab provision --host a.lab" + + +def test_start_garde_la_memoire_bloquante_pour_son_lab( + tmp_path: Path, machine_vide: RepoMetadata, +) -> None: + """`start ` passe ses hôtes : là, la mémoire manque pour CE lab.""" + report = doctor.collect_checks(tmp_path, machine_vide, hosts=["a.lab", "b.lab"]) + + assert "resources" in {c.key for c in report.failing()} + assert not report.a_savoir + + +def test_deux_controles_repares_par_la_meme_commande_font_une_etape( + tmp_path: Path, machine_vide: RepoMetadata, monkeypatch: pytest.MonkeyPatch, +) -> None: + """/dev/kvm fermé et groupe libvirt absent : une étape, la commande du groupe.""" + monkeypatch.setattr(doctor.os, "access", lambda p, m: False) + monkeypatch.setattr(kvm_controles.os, "access", lambda p, m: False) + plan = construire(doctor.collect_checks(tmp_path, machine_vide)) + + groupes = [e for e in plan.etapes if e.cle == "groupes"] + assert len(groupes) == 1 + assert {c.key for c in groupes[0].controles} == {"hw_virt", "groupes"} + assert groupes[0].remede is not None + assert groupes[0].remede.lignes == ("sudo usermod -aG kvm,libvirt $USER",) + + +def test_un_provider_a_choisir_n_arrete_plus_le_diagnostic( + tmp_path: Path, machine_vide: RepoMetadata, +) -> None: + machine_vide.infra.provider = "" + machine_vide.infra.providers_available = ["kvm", "incus"] + report = doctor.collect_checks(tmp_path, machine_vide) + plan = construire(report) + + assert report.provider == "kvm" and report.provider_a_confirmer + assert plan.etapes[0].cle in ("git", "provider") + assert {"provider", "kvm", "libvirt_pool"} <= {e.cle for e in plan.etapes} + assert "incus" not in {e.cle for e in plan.etapes} + + +@pytest.mark.parametrize(("candidats", "kvm_present", "attendu"), [ + (["kvm", "incus"], True, "kvm"), + (["incus", "kvm"], True, "kvm"), + (["kvm", "incus"], False, "kvm"), + (["outscale", "incus"], True, "incus"), + (["outscale"], True, "outscale"), +]) +def test_le_provider_recommande( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch, + candidats: list[str], kvm_present: bool, attendu: str, +) -> None: + device = tmp_path / "kvm" + if kvm_present: + device.touch() + monkeypatch.setattr(doctor, "_KVM_DEVICE", device) + assert doctor.provider_recommande(candidats) == attendu + + +def test_les_collections_attendent_ansible_avec_leur_commande( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch, +) -> None: + """Le « ? ansible-galaxy n'a pas répondu » cachait la vraie cause.""" + (tmp_path / "requirements.yml").write_text( + "collections:\n - name: community.general\n", encoding="utf-8", + ) + monkeypatch.setattr(doctor.ansible_infra, "has_ansible_playbook", lambda: False) + monkeypatch.setattr("dsoxlab.services.collections_ansible.collections_installees", lambda: None) + check = doctor._check_collections(tmp_path) + + assert check.state == doctor.STATE_UNKNOWN + assert check.apres == "ansible" + assert check.fix is not None + assert check.fix.commands == ( + ("ansible-galaxy", "collection", "install", "-r", str(tmp_path / "requirements.yml")), + ) + + +# ── le document JSON : des ajouts, rien de retiré ───────────────────────────── + +def test_le_json_porte_les_commandes_l_attente_et_la_mise_en_garde( + tmp_path: Path, machine_vide: RepoMetadata, +) -> None: + from dsoxlab.reporting import machine + + document = machine.doctor_dict(doctor.collect_checks(tmp_path, machine_vide)) + par_cle = {c["key"]: c for c in [*document["required"], *document["informational"]]} + + for champ in ("key", "state", "ok", "label", "detail", "fix", "fix_kind", "hint"): + assert champ in par_cle["kvm"], champ + assert par_cle["kvm"]["commands"] == [ + "sudo apt install libvirt-clients libvirt-daemon-system qemu-kvm", + ] + assert par_cle["libvirt_pool"]["after"] == "kvm" + assert par_cle["libvirt_pool"]["state"] == "unknown" + assert par_cle["git"]["warning"] is None + # La mémoire de tout le catalogue informe : elle n'est plus dans `required`. + assert "resources" not in {c["key"] for c in document["required"]} + assert "resources" in {c["key"] for c in document["informational"]} + + +def test_clients_n_installe_que_docker_et_incus() -> None: + """Hors catalogue, KVM est facultatif : `--clients` ne doit pas l'installer.""" + from dsoxlab.services.doctor_controles.modele import DoctorReport + from dsoxlab.services.doctor_controles.remedes import Remede + + report = DoctorReport() + report.optional.extend([ + doctor._check("kvm", False, "absent", remede=Remede("kvm", ("sudo apt install x",), root=True)), + doctor._check("docker", False, "absent", remede=Remede("docker", ("sudo apt install y",), root=True)), + ]) + assert [e.cle for e in construire(report).facultatives] == ["docker"] diff --git a/tests/test_doctor_installation.py b/tests/test_doctor_installation.py index f37268b..ecd61f4 100644 --- a/tests/test_doctor_installation.py +++ b/tests/test_doctor_installation.py @@ -234,8 +234,10 @@ def test_ansible_est_reparable_automatiquement( ) -> None: """`uv tool install ansible-core` est sûr et sans ambiguïté : --fix le joue. - Terraform, lui, ne porte qu'un `hint` : son installation passe par un dépôt - tiers, ce n'est pas à l'outil de la décider. + Terraform, lui, n'a pas de correctif sans shell : son installation passe + par le dépôt d'HashiCorp, et ses commandes viennent de la table des remèdes + (plus jamais un lien, refonte du 2026-11-16). `--fix` les confie au + playbook du poste, comme toute étape root. """ _labs(monkeypatch, [_lab("a", RuntimeType.VM)]) report = doctor.collect_checks(tmp_path, _repo(provider="kvm")) @@ -245,33 +247,42 @@ def test_ansible_est_reparable_automatiquement( assert correctif is not None assert correctif.display == "uv tool install ansible-core" assert correctif.kind is doctor.FixKind.AUTOMATIC - assert par_label[_("check_terraform")].fix is None - assert "terraform" in (par_label[_("check_terraform")].hint or "") + terraform = par_label[_("check_terraform")] + assert terraform.fix is None + assert terraform.remede is not None and terraform.remede.root + assert any("install terraform" in ligne for ligne in terraform.remede.lignes) -# ── les contrôles de configuration ne parlent qu'après l'installation ───────── +# ── les contrôles de configuration attendent l'installation, sans disparaître ── -def test_les_controles_kvm_se_taisent_si_virsh_manque( +def test_les_controles_kvm_attendent_virsh_sans_disparaitre( tmp_path: Path, monkeypatch: pytest.MonkeyPatch ) -> None: - """Trois lignes rouges pour une seule cause noient celle qui compte. + """Sans libvirt, le pool, le groupe et le firmware ne se mesurent pas. - Le contrôle du pool porte sur la CONFIGURATION d'un libvirt déjà installé : - l'afficher quand libvirt lui-même manque n'apprend rien. + Avant la refonte du 2026-11-16, ils disparaissaient, et chaque passage de + `doctor` en révélait un de plus. Ils restent listés, en `unknown`, liés à + l'étape kvm : ni rouge (rien n'est prouvé), ni caché. Le pool garde sa + commande, pour qu'une seule passe de `--fix` fasse tout. """ monkeypatch.setattr( doctor, "_hypervisor_checks", lambda: { - "kvm": doctor._check("kvm", False, "not found", fix="apt install"), + "kvm": doctor._check("kvm", False, "not found"), "incus": doctor._check("incus", True, "ok"), }, ) _labs(monkeypatch, [_lab("a", RuntimeType.VM)]) report = doctor.collect_checks(tmp_path, _repo(provider="kvm")) - requis = _labels(report.required) - assert _("check_kvm") in requis - assert _("check_libvirt_pool") not in requis + par_cle = {c.key: c for c in report.required} + assert not par_cle["kvm"].ok + for cle in ("libvirt_pool", "efi"): + assert par_cle[cle].state == doctor.STATE_UNKNOWN, cle + assert par_cle[cle].apres == "kvm", cle + assert par_cle["libvirt_pool"].remede is not None + # Rien de ce qui attend ne compte comme un échec : seul kvm est rouge. + assert "libvirt_pool" not in {c.key for c in report.failing()} def test_les_controles_kvm_apparaissent_une_fois_virsh_present( @@ -350,12 +361,14 @@ def test_sans_provider_choisi_le_tableau_ne_dit_plus_non_requis( ne bloquent rien », au-dessus des deux hyperviseurs dont l'un est indispensable pour jouer 64 labs sur 84. - Les checks restent hors du requis, sans quoi `--fix` proposerait - d'installer kvm ET incus pour un choix qui n'est pas fait : c'est le - libellé qui devait changer. + Le cas vaut encore quand aucun hyperviseur local n'est candidat au + diagnostic (ici, deux candidats distants) : les + checks restent hors du requis, sans quoi `--fix` proposerait d'installer + kvm ET incus pour un choix qui n'est pas fait. """ + monkeypatch.setattr(doctor, "_KVM_DEVICE", tmp_path / "absent") _labs(monkeypatch, [_lab("a", RuntimeType.VM)]) - report = doctor.collect_checks(tmp_path, _repo(candidates=["kvm", "incus"])) + report = doctor.collect_checks(tmp_path, _repo(candidates=["outscale", "none"])) assert report.optional_title_key == "doctor_choose_title" assert report.optional_hint_key == "doctor_choose_hint" diff --git a/tests/test_doctor_prerequis_vm.py b/tests/test_doctor_prerequis_vm.py index ffd32fd..33b6652 100644 --- a/tests/test_doctor_prerequis_vm.py +++ b/tests/test_doctor_prerequis_vm.py @@ -27,6 +27,7 @@ from dsoxlab.models.runtime import RuntimeConfig, RuntimeType, Target from dsoxlab.reporting import machine from dsoxlab.services import doctor +from dsoxlab.services.doctor_controles import remedes def _lab(lab_id: str, runtime_type: RuntimeType) -> LabDefinition: @@ -264,6 +265,8 @@ def test_dev_kvm_inaccessible_est_reparable( device.touch() monkeypatch.setattr(doctor, "_KVM_DEVICE", device) monkeypatch.setattr(doctor.os, "access", lambda p, mode: False) + # Un compte hors du groupe kvm, quel que soit le poste qui joue le test. + monkeypatch.setattr("dsoxlab.services.doctor_controles.kvm._gid", lambda nom: None) check = doctor._check_hw_virt() @@ -565,19 +568,30 @@ def _poste(monkeypatch: pytest.MonkeyPatch, *presents: str) -> None: ) +def _os_release(monkeypatch: pytest.MonkeyPatch, tmp_path: Path, contenu: str) -> None: + """Simule la distribution du poste par son /etc/os-release.""" + fichier = tmp_path / "os-release" + fichier.write_text(contenu, encoding="utf-8") + monkeypatch.setattr(remedes, "OS_RELEASE", fichier) + + def test_fedora_recoit_dnf_et_ses_noms_de_paquets( - monkeypatch: pytest.MonkeyPatch, + monkeypatch: pytest.MonkeyPatch, tmp_path: Path, ) -> None: """Issue blog-roadmap #41 : sur Fedora, `--fix` proposait `apt install`. Les noms viennent de `dnf repoquery` sur Fedora 43 et AlmaLinux 10 : - `libvirt-clients` et `libvirt-daemon-system` n'y existent pas. + `libvirt-clients` et `libvirt-daemon-system` n'y existent pas. Sur cette + famille, libvirt ne démarre pas seul : le remède l'active dans la même étape. """ _poste(monkeypatch, "dnf") + _os_release(monkeypatch, tmp_path, 'ID=fedora\nPRETTY_NAME="Fedora Linux 43"\n') kvm = doctor._check_kvm() - assert kvm.fix is not None - assert kvm.fix.commands == (("sudo", "dnf", "install", "libvirt", "qemu-kvm"),) + assert kvm.remede is not None + assert kvm.remede.lignes == ( + "sudo dnf install libvirt qemu-kvm", "sudo systemctl enable --now libvirtd", + ) iso = doctor._check_iso_tool() assert iso.fix is not None @@ -590,14 +604,41 @@ def test_fedora_recoit_dnf_et_ses_noms_de_paquets( assert connu[1] == "sudo dnf install qemu-img" -def test_debian_garde_apt(monkeypatch: pytest.MonkeyPatch) -> None: - """apt gagne dès qu'il est là, et reste le défaut quand rien n'est trouvé.""" - for presents in (("apt-get", "dnf"), ("apt-get",), ()): +def test_debian_garde_apt(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None: + """La famille Debian reçoit apt, et apt reste le défaut quand rien ne se lit. + + os-release décide d'abord ; à défaut (fichier vide), apt gagne dès qu'il est + dans le PATH, et reste le défaut quand rien n'est trouvé. + """ + cas = ( + ("ID=ubuntu\nID_LIKE=debian\n", ("dnf",)), + ("ID=debian\n", ()), + ("", ("apt-get", "dnf")), + ("", ("apt-get",)), + ("", ()), + ) + for contenu, presents in cas: _poste(monkeypatch, *presents) + _os_release(monkeypatch, tmp_path, contenu) kvm = doctor._check_kvm() - assert kvm.fix is not None - assert kvm.fix.commands[0][:3] == ("sudo", "apt", "install") - assert "libvirt-daemon-system" in kvm.fix.commands[0] + assert kvm.remede is not None, (contenu, presents) + assert kvm.remede.lignes == ( + "sudo apt install libvirt-clients libvirt-daemon-system qemu-kvm", + ), (contenu, presents) + + +def test_almalinux_est_de_la_famille_rhel( + monkeypatch: pytest.MonkeyPatch, tmp_path: Path, +) -> None: + """AlmaLinux se reconnaît à son ID_LIKE, et le dépôt Terraform est celui de RHEL.""" + _poste(monkeypatch, "dnf") + _os_release(monkeypatch, tmp_path, 'ID="almalinux"\nID_LIKE="rhel centos fedora"\n') + + terraform = remedes.remede("terraform", remedes.systeme()) + assert terraform is not None + assert "https://rpm.releases.hashicorp.com/RHEL/hashicorp.repo" in terraform.lignes[1] + incus = doctor._check_incus() + assert incus.remede is None, "incus n'est dans aucun dépôt de base d'AlmaLinux 10" def test_un_qemu_img_absent_est_nomme( diff --git a/tests/test_remediation.py b/tests/test_remediation.py index 8f4688c..7e985eb 100644 --- a/tests/test_remediation.py +++ b/tests/test_remediation.py @@ -1,152 +1,209 @@ -"""Ce que `doctor --fix` décide, éprouvé sans toucher la machine. - -Ces décisions vivaient dans la commande, donc derrière un `CliRunner` et des -`monkeypatch` sur `subprocess`. Les cas qu'on ne pouvait pas écrire sont -justement ceux qui coûtent cher quand ils tombent mal : un terminal absent, un -`sudo` introuvable, une cascade dont un maillon rate. +"""Le plan de `doctor --fix` et le playbook du poste, sans toucher la machine. + +Ce que ce module prouve : + +- le plan range chaque étape là où elle doit aller : lancée par dsoxlab (sans + sudo), confiée au playbook (root), ou seulement nommée (manuelle) ; Docker + et Incus facultatifs n'y entrent qu'avec ``--clients`` ; +- le playbook joue exactement les lignes affichées, à trois transformations + près : ``sudo`` retiré, ``-y`` ajouté aux installations, ``$USER`` remplacé + par le compte de l'apprenant (sous ``become``, il vaudrait root) ; +- une étape n'est réussie que si le contrôle, refait, est vert, ou n'attend + plus qu'une reconnexion. """ from __future__ import annotations -from dsoxlab.services.doctor import Check, DoctorReport, Fix, FixKind +import pytest +import yaml + +from dsoxlab.services.doctor import DoctorReport, Fix, FixKind, _check +from dsoxlab.services.doctor_controles.modele import STATE_UNKNOWN +from dsoxlab.services.doctor_controles.remedes import Remede +from dsoxlab.services.doctor_etapes import construire from dsoxlab.services.remediation import ( Application, - appliquer, - obstacle, + etape_verifiee, + lignes_root, planifier, + playbook_du_poste, ) -def _check(key: str, fix: Fix | None, *, ok: bool = False) -> Check: - return Check(key=key, label=key, ok=ok, detail="", fix=fix) +def _rapport(*checks: object, optional: tuple[object, ...] = ()) -> DoctorReport: + report = DoctorReport() + report.required.extend(checks) # type: ignore[arg-type] + report.optional.extend(optional) # type: ignore[arg-type] + return report -def _fix(*, kind: FixKind = FixKind.AUTOMATIC, sudo: bool = False) -> Fix: - commande = ("sudo", "apt", "install", "x") if sudo else ("apt", "install", "x") - return Fix((commande,), kind=kind) +_ROOT = Remede("kvm", ("sudo apt install libvirt-clients",), root=True, tag="libvirt") +_DOCKER = Remede("docker", ("sudo apt install docker-ce",), root=True, tag="docker") -class TestLePlan: - def test_un_manuel_et_un_automatique_sont_separes(self) -> None: - report = DoctorReport(required=[ - _check("manuel", _fix(kind=FixKind.MANUAL)), - _check("auto", _fix()), - ]) +class TestPlanifier: + def test_chaque_etape_va_ou_elle_doit(self) -> None: + report = _rapport( + _check("kvm", False, "absent", remede=_ROOT), + _check("ansible", False, "absent", fix=Fix((("uv", "tool", "install", "ansible-core"),))), + _check("hw_virt", False, "active la virtualisation dans le BIOS"), + _check("provider", False, "à choisir", hint="dsoxlab use --provider kvm"), + ) + plan = planifier(report, actions={"provider": lambda: None}) + assert [e.cle for e in plan.root] == ["kvm"] + assert [e.cle for e in plan.sans_sudo] == ["provider", "ansible"] + assert [e.cle for e in plan.manuelles] == ["hw_virt"] + assert plan.executables == 3 + + def test_un_correctif_manuel_n_est_jamais_lance(self) -> None: + report = _rapport(_check( + "x", False, "cassé", fix=Fix((("rm", "-rf", "/x"),), kind=FixKind.MANUAL), + )) plan = planifier(report) - assert [label for label, _ in plan.manuels] == ["manuel"] - assert [label for label, _ in plan.executables] == ["auto"] + assert plan.executables == 0 + assert [e.cle for e in plan.manuelles] == ["x"] - def test_un_controle_vert_n_est_pas_a_reparer(self) -> None: - report = DoctorReport(required=[_check("vert", _fix(), ok=True)]) - assert planifier(report).vide + def test_une_consigne_sans_action_reste_manuelle(self) -> None: + """Une commande affichée que dsoxlab ne sait pas jouer n'est pas lancée.""" + report = _rapport(_check("labs", False, "aucun", hint="dsoxlab catalog add linux")) + assert [e.cle for e in planifier(report).manuelles] == ["labs"] - def test_un_controle_rouge_sans_correctif_est_ignore(self) -> None: - """Il reste rouge et il se dit : simplement, `--fix` n'a rien à jouer.""" - report = DoctorReport(required=[_check("rouge", None)]) - assert planifier(report).vide + def test_les_facultatifs_n_entrent_qu_avec_clients(self) -> None: + report = _rapport(optional=(_check("docker", False, "absent", remede=_DOCKER),)) - def test_les_correctifs_informatifs_ne_comptent_pas(self) -> None: - """`fixable()` ne regarde que le tableau des contrôles REQUIS : un - composant que ce dépôt n'utilise pas ne se répare pas de force.""" - report = DoctorReport(required=[], optional=[_check("docker", _fix())]) assert planifier(report).vide - - -class TestCeQuiEmpecheLaCascade: - def test_sans_sudo_requis_la_voie_est_libre_meme_hors_terminal(self) -> None: - """Un `--fix` sans sudo doit tourner en CI, où il n'y a pas de TTY.""" - plan = planifier(DoctorReport(required=[_check("auto", _fix())])) - assert obstacle(plan, interactif=False) is None - - def test_sans_terminal_un_correctif_sudo_est_refuse_avant_de_commencer( - self, - ) -> None: - """Échouer au milieu d'une cascade laisse la machine dans un état que - personne n'a décrit : le refus vient avant le premier correctif.""" - plan = planifier(DoctorReport(required=[_check("auto", _fix(sudo=True))])) - assert obstacle(plan, interactif=False) == "fix_needs_tty" - - def test_sans_le_binaire_sudo_la_cascade_est_refusee( - self, monkeypatch - ) -> None: - monkeypatch.setattr("dsoxlab.services.remediation.shutil.which", lambda _: None) - plan = planifier(DoctorReport(required=[_check("auto", _fix(sudo=True))])) - - assert obstacle(plan, interactif=True) == "fix_no_sudo" - - def test_tout_en_place_ne_renvoie_aucun_obstacle(self, monkeypatch) -> None: - monkeypatch.setattr( - "dsoxlab.services.remediation.shutil.which", lambda _: "/usr/bin/sudo" + assert [e.cle for e in planifier(report, clients=True).root] == ["docker"] + + def test_un_controle_en_attente_entre_dans_le_plan(self) -> None: + """Le pool attend libvirt : une seule passe de `--fix` fait les deux.""" + pool = Remede("libvirt_pool", ("sudo virsh pool-define-as default dir",), root=True) + report = _rapport( + _check("kvm", False, "absent", remede=_ROOT), + _check("libvirt_pool", False, "en attente", forced_state=STATE_UNKNOWN, + apres="kvm", remede=pool), ) - plan = planifier(DoctorReport(required=[_check("auto", _fix(sudo=True))])) - - assert obstacle(plan, interactif=True) is None - - def test_le_compte_de_correctifs_sudo_est_celui_annonce(self) -> None: - """Il est affiché avant la pré-authentification : il doit être juste.""" - report = DoctorReport(required=[ - _check("a", _fix(sudo=True)), - _check("b", _fix(sudo=False)), - _check("c", _fix(sudo=True)), - ]) - assert planifier(report).correctifs_sudo == 2 - - -class TestLaCascade: - def test_un_echec_n_arrete_pas_les_suivants(self) -> None: - """`--fix` répare des choses indépendantes : lever sur la première qui - rate abandonnerait les autres sans le dire.""" - joues: list[str] = [] - - def executer(fix: Fix) -> int: - joues.append(fix.commands[0][-1]) - return 1 if fix.commands[0][-1] == "b" else 0 - - plan = planifier(DoctorReport(required=[ - _check("a", Fix((("cmd", "a"),))), - _check("b", Fix((("cmd", "b"),))), - _check("c", Fix((("cmd", "c"),))), - ])) - resultats = appliquer(plan.executables, executer) - - assert joues == ["a", "b", "c"] - assert [r.ok for r in resultats] == [True, False, True] - - def test_les_deux_rappels_encadrent_chaque_correctif(self) -> None: - """La commande est nommée AVANT de partir, sinon sa sortie arrive sur - le terminal sans que rien ne dise à qui elle appartient.""" - trace: list[str] = [] - plan = planifier(DoctorReport(required=[_check("a", Fix((("cmd", "a"),)))])) - - appliquer( - plan.executables, - lambda _fix: 0, - sur_debut=lambda label, _fix: trace.append(f"debut:{label}"), - sur_resultat=lambda app: trace.append(f"fin:{app.label}"), + assert [e.cle for e in planifier(report).root] == ["kvm", "libvirt_pool"] + + +class TestLignesRoot: + def test_sudo_est_retire_partout_y_compris_apres_un_tube(self) -> None: + jouees = lignes_root(( + "wget -O - https://x/gpg | sudo gpg --dearmor -o /k.gpg", + "sudo apt update && sudo apt install terraform", + ), "bob") + + assert "sudo" not in jouees + assert "| gpg --dearmor" in jouees + assert "apt update && apt install -y terraform" in jouees + + def test_une_installation_ne_pose_jamais_de_question(self) -> None: + jouees = lignes_root(( + "sudo apt install git", "sudo dnf install -y yum-utils", "sudo dnf -y install terraform", + ), "bob") + + assert "apt install -y git" in jouees + assert "dnf install -y yum-utils" in jouees + assert "-y -y" not in jouees + assert "dnf -y install terraform" in jouees + + def test_user_vise_l_apprenant_et_pas_root(self) -> None: + """Sous `become`, `$USER` vaut root : le groupe irait au mauvais compte.""" + jouees = lignes_root(("sudo usermod -aG kvm,libvirt $USER",), "student") + assert "usermod -aG kvm,libvirt student" in jouees + assert "$USER" not in jouees + + def test_le_script_s_arrete_a_la_premiere_ligne_en_echec(self) -> None: + assert lignes_root(("sudo true",), "bob").startswith("set -e\n") + + @pytest.mark.parametrize("compte", ["bob; rm -rf /", "$(id)", "Bob Smith", ""]) + def test_un_nom_de_compte_inhabituel_est_refuse(self, compte: str) -> None: + with pytest.raises(ValueError, match="unusual account name"): + lignes_root(("sudo usermod -aG kvm $USER",), compte) + + +class TestPlaybook: + def test_une_tache_par_etape_dans_l_ordre_du_plan(self) -> None: + pool = Remede("libvirt_pool", ("sudo virsh pool-build default",), root=True, tag="pool") + report = _rapport( + _check("libvirt_pool", False, "absent", remede=pool), + _check("kvm", False, "absent", remede=_ROOT), ) - - assert trace == ["debut:a", "fin:a"] - - -class TestCeQuOnDitApres: - def test_un_succes_immediat_n_annonce_rien_de_differe(self) -> None: - assert Application("x", 0, FixKind.AUTOMATIC).avis_differe is None + etapes = planifier(report).root + jeu = yaml.safe_load(playbook_du_poste(etapes, "bob")) + + assert jeu[0]["hosts"] == "localhost" + assert jeu[0]["become"] is True + taches = jeu[0]["tasks"] + # L'ordre est celui des dépendances (libvirt avant son pool), pas + # celui du rapport. + assert [t["tags"] for t in taches] == [["libvirt"], ["pool"]] + assert "apt install -y libvirt-clients" in taches[0]["ansible.builtin.shell"] + assert taches[0]["environment"] == {"DEBIAN_FRONTEND": "noninteractive"} + + def test_un_heredoc_survit_au_yaml(self) -> None: + """Le dépôt Docker s'écrit par un heredoc : ses lignes restent entières.""" + heredoc = Remede("docker", ( + "sudo tee /etc/apt/sources.list.d/docker.sources < object: + return construire(_rapport(check)).etapes[0] + + def test_un_controle_revenu_au_vert_valide_l_etape(self) -> None: + etape = self._etape(_check("kvm", False, "absent", remede=_ROOT)) + assert etape_verifiee(etape, _rapport(_check("kvm", True, "libvirt 10.0.0"))) # type: ignore[arg-type] + + def test_un_controle_toujours_rouge_invalide_l_etape(self) -> None: + """Un code de retour nul ne suffit pas : c'est le contrôle refait qui juge.""" + etape = self._etape(_check("kvm", False, "absent", remede=_ROOT)) + assert not etape_verifiee(etape, _rapport(_check("kvm", False, "absent", remede=_ROOT))) # type: ignore[arg-type] + + def test_une_reconnexion_attendue_compte_comme_reussie(self) -> None: + groupes = Remede("groupes", ("sudo usermod -aG libvirt $USER",), root=True, reconnexion=True) + etape = self._etape(_check("groupes", False, "absent", remede=groupes)) + apres = _rapport(_check( + "groupes", False, "reconnectez-vous", + remede=Remede("groupes", (), root=False, reconnexion=True), + )) + assert etape_verifiee(etape, apres) # type: ignore[arg-type] + + def test_un_controle_disparu_n_est_pas_une_reussite(self) -> None: + etape = self._etape(_check("kvm", False, "absent", remede=_ROOT)) + assert not etape_verifiee(etape, _rapport()) # type: ignore[arg-type] + + +class TestEffetDiffere: + def _application(self, *, kind: FixKind = FixKind.AUTOMATIC, code: int = 0, + reconnexion: bool = False) -> Application: + remede = Remede("x", ("x",), root=False, reconnexion=reconnexion) + etape = construire(_rapport(_check("x", False, "cassé", fix=Fix((("x",),), kind=kind), + remede=remede))).etapes[0] + return Application(etape, code, verifiee=code == 0) + + def test_un_succes_immediat_n_annonce_rien(self) -> None: + assert self._application().avis_differe is None def test_une_reconnexion_requise_est_annoncee(self) -> None: - """Sans ce message, le prochain `doctor` remontre la même ligne rouge - et l'utilisateur conclut, à tort, que le correctif a échoué.""" - assert Application("x", 0, FixKind.NEEDS_RELOGIN).avis_differe == ( - "fix_needs_relogin" - ) + assert self._application(reconnexion=True).avis_differe == "fix_needs_relogin" + assert self._application(kind=FixKind.NEEDS_RELOGIN).avis_differe == "fix_needs_relogin" def test_un_redemarrage_requis_est_annonce(self) -> None: - assert Application("x", 0, FixKind.NEEDS_REBOOT).avis_differe == ( - "fix_needs_reboot" - ) + assert self._application(kind=FixKind.NEEDS_REBOOT).avis_differe == "fix_needs_reboot" def test_un_echec_n_annonce_aucun_effet_differe(self) -> None: - """Promettre « effectif après reconnexion » sur un correctif qui a raté - enverrait l'utilisateur redémarrer pour rien.""" - assert Application("x", 1, FixKind.NEEDS_REBOOT).avis_differe is None + assert self._application(reconnexion=True, code=1).avis_differe is None