From 1b81cdce94f534588af48131f71a3f42449fdcd8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?St=C3=A9phane=20ROBERT?= Date: Mon, 16 Nov 2026 10:42:27 +0100 Subject: [PATCH 1/4] feat(doctor): un diagnostic qui guide jusqu'au bout, et un --fix qui montre son plan MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Parcours mesurés le 2026-11-16 sur deux machines vides (Ubuntu 24.04, AlmaLinux 10) : il fallait relancer doctor après chaque geste pour voir le suivant, trois remèdes n'étaient que des liens, et provision échouait encore après un doctor vert (clé SSH, firmware EFI, Include ssh jamais contrôlés). Maquettes et sept décisions validées par Stéphane le même jour. - Étapes numérotées dans l'ordre des dépendances, une commande par ligne, regroupées par remède ; « À savoir », déjà prêt, commande unique. - Aucun contrôle caché : pool, groupes, EFI attendent libvirt ; collections attendent Ansible ; provider non choisi = diagnostic avec le recommandé. - Nouveaux contrôles : groupes kvm/libvirt, firmware EFI, clé SSH du catalogue, ligne Include de ~/.ssh/config. - Table unique des remèdes par famille (/etc/os-release) : git, Terraform, Docker depuis les dépôts officiels ; enable --now libvirtd ; pas d'incus sur RHEL. La doc learner est tenue contre cette table par un test. - --fix : plan affiché, [y/N] ou --yes, étapes root par un playbook généré et un seul ansible-playbook --ask-become-pass, repli à coller sans terminal, revérification après chaque étape, arrêt au premier échec, Docker/Incus seulement avec --clients. - RAM de tout le catalogue : « À savoir », non bloquante ; start reste bloquant pour son lab. - JSON : champs commands, after, warning ajoutés, rien retiré. Le test qui joue la commande Include telle qu'affichée a trouvé qu'elle échouait sur un ~/.ssh/config absent (cat en échec, && coupé) : corrigé. 28 mutations, 28 font tomber un test. Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.fr.md | 49 ++ CHANGELOG.md | 47 ++ docs/learner.fr.md | 130 ++++- docs/learner.md | 124 ++++- docs/machine-output.fr.md | 24 +- docs/machine-output.md | 24 +- src/dsoxlab/cli/diagnostic.py | 295 +++++++++--- src/dsoxlab/cli/instructeur.py | 27 +- src/dsoxlab/i18n/strings/en.py | 106 +++- src/dsoxlab/i18n/strings/fr.py | 108 ++++- src/dsoxlab/infra/inventory.py | 26 + src/dsoxlab/reporting/console.py | 87 +--- src/dsoxlab/reporting/doctor_rendu.py | 191 ++++++++ src/dsoxlab/reporting/machine.py | 10 +- src/dsoxlab/services/doctor.py | 194 ++++++-- .../services/doctor_controles/catalogue.py | 65 ++- .../services/doctor_controles/conteneurs.py | 3 +- .../services/doctor_controles/incus.py | 12 +- src/dsoxlab/services/doctor_controles/kvm.py | 130 ++++- .../services/doctor_controles/modele.py | 76 ++- .../services/doctor_controles/outillage.py | 45 +- .../services/doctor_controles/remedes.py | 270 +++++++++++ src/dsoxlab/services/doctor_etapes.py | 128 +++++ src/dsoxlab/services/remediation.py | 277 +++++++---- tests/test_doc_installation.py | 56 +++ tests/test_doctor.py | 43 +- tests/test_doctor_fix.py | 275 +++++++---- tests/test_doctor_guide.py | 452 ++++++++++++++++++ tests/test_doctor_installation.py | 47 +- tests/test_doctor_prerequis_vm.py | 59 ++- tests/test_remediation.py | 303 +++++++----- 31 files changed, 3024 insertions(+), 659 deletions(-) create mode 100644 src/dsoxlab/reporting/doctor_rendu.py create mode 100644 src/dsoxlab/services/doctor_controles/remedes.py create mode 100644 src/dsoxlab/services/doctor_etapes.py create mode 100644 tests/test_doc_installation.py create mode 100644 tests/test_doctor_guide.py 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..24bd1a5 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,243 @@ 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 - for label, correctif in plan.manuels: - info(_("fix_manual", label=label, command=correctif.display)) + +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 plan.manuelles: + console.print(Text(" " + _("fix_plan_manuelles"))) + for etape in plan.manuelles: + console.print(Text(f" {etape.numero:>2}. {titre_etape(etape)}"), soft_wrap=True) + for check in report.a_savoir: + console.print(Text(" " + _("fix_plan_a_savoir", label=check.label))) + + +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 + + +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, - ) - info(_("fix_rerun")) + 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: + _jouer_root(plan.root, ansible, chemin, remesurer, restantes) 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 _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 _preauthentifier(combien: int) -> None: - """Un seul mot de passe pour toute la cascade. +def _jouer_root( + etapes: list[Etape], ansible: list[str], chemin: Path, + remesurer: Callable[[], DoctorReport], restantes: list[Etape], +) -> None: + """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 + if not _playbook_jouable(ansible[0]): + warn(_("fix_pas_d_ansible")) + _bloc_root(etapes) + return + 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 + if any(e.remede is not None and e.remede.reconnexion for e in etapes): + warn(_("fix_reconnexion_finale")) + info(_("fix_rerun")) - 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. - """ - 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) + +def _playbook_jouable(binaire: str) -> bool: + return Path(binaire).is_file() and os.access(binaire, os.X_OK) + + +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 +508,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..2466057 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,33 @@ "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_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..7a00d42 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,27 @@ "é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_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 +1852,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..186b0cc 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" @@ -223,6 +225,11 @@ def _check_hw_virt() -> Check: ["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 +270,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..e2e44bd --- /dev/null +++ b/src/dsoxlab/services/doctor_etapes.py @@ -0,0 +1,128 @@ +"""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 + + +@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] + facultatifs = [c for c in report.optional if not c.ok and c.remede is not None] + plan.facultatives = _regrouper(facultatifs, facultative=True) + return plan diff --git a/src/dsoxlab/services/remediation.py b/src/dsoxlab/services/remediation.py index 74fb6fe..a11df71 100644 --- a/src/dsoxlab/services/remediation.py +++ b/src/dsoxlab/services/remediation.py @@ -1,129 +1,218 @@ -"""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, + "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..bba6c65 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,212 @@ 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", ) - appels, resultat = _doctor_fix(monkeypatch, correctif) + 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, + ) + + 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, -) -> None: - """Un correctif en plusieurs commandes ne poursuit pas après un échec. +_ROOT = Remede("composant_0", ("sudo apt install libvirt-clients",), root=True, tag="libvirt") - 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. - """ - appels: list[list[str]] = [] - - def run_qui_echoue(cmd: list[str], **kwargs: object) -> CommandResult: - appels.append(list(cmd)) - return CommandResult(returncode=3, stdout="", stderr="boom") - correctif = Fix((("premiere", "etape"), ("seconde", "etape"))) - monkeypatch.setattr(diagnostic, "run_command", run_qui_echoue) - monkeypatch.setattr( - diagnostic, "collect_checks", lambda root, meta: _rapport(correctif) - ) +def test_sans_terminal_les_etapes_root_s_affichent_a_coller( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch, +) -> None: + """Personne ne peut taper le mot de passe : rien n'est lancé, le bloc s'affiche. - resultat = runner.invoke(app, ["doctor", "--fix"]) + ansible-playbook est bien là : c'est l'absence de terminal, et elle seule, + qui doit empêcher le lancement. + """ + 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)) - assert appels == [["premiere", "etape"]], "la seconde étape ne doit pas partir" - assert "remediation failed (code 3)" in resultat.stderr + appels, resultat = _doctor_fix(monkeypatch, Diagnostics([None], [_ROOT]), "--yes") + assert appels == [] and lancements == [] + assert "Paste these sudo steps" in _texte(resultat) + assert "sudo apt install libvirt-clients" in _texte(resultat) -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 +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_plus_aucun_shell_true_dans_les_sources() -> None: @@ -189,3 +263,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..4f5709d --- /dev/null +++ b/tests/test_doctor_guide.py @@ -0,0 +1,452 @@ +"""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",) + + +# ── 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"]} 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..2bc6091 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: @@ -565,19 +566,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 +602,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 From 39e0e3bae0c015f164c642325148d9c8241ee66b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?St=C3=A9phane=20ROBERT?= Date: Mon, 16 Nov 2026 10:52:45 +0100 Subject: [PATCH 2/4] =?UTF-8?q?fix(doctor):=20/dev/kvm=20ferm=C3=A9=20mais?= =?UTF-8?q?=20compte=20d=C3=A9j=C3=A0=20dans=20kvm,=20seule=20la=20reconne?= =?UTF-8?q?xion=20compte?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Réévaluation du 2026-11-16 sur une Ubuntu 24.04 neuve : juste après le usermod du playbook, /dev/kvm reste fermé dans la session, et hw_virt proposait encore usermod ; --fix jugeait donc sa propre étape en échec et s arrêtait, alors que pool et Terraform étaient faits. hw_virt distingue désormais « inscrit, reconnectez-vous » comme le contrôle des groupes. Co-Authored-By: Claude Opus 5.5 --- src/dsoxlab/services/doctor_controles/kvm.py | 11 +++++++++++ tests/test_doctor_guide.py | 16 ++++++++++++++++ tests/test_doctor_prerequis_vm.py | 2 ++ 3 files changed, 29 insertions(+) diff --git a/src/dsoxlab/services/doctor_controles/kvm.py b/src/dsoxlab/services/doctor_controles/kvm.py index 186b0cc..0922137 100644 --- a/src/dsoxlab/services/doctor_controles/kvm.py +++ b/src/dsoxlab/services/doctor_controles/kvm.py @@ -219,6 +219,17 @@ 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( diff --git a/tests/test_doctor_guide.py b/tests/test_doctor_guide.py index 4f5709d..0c645a9 100644 --- a/tests/test_doctor_guide.py +++ b/tests/test_doctor_guide.py @@ -240,6 +240,22 @@ def test_un_dev_kvm_ferme_ajoute_le_groupe_kvm( 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: diff --git a/tests/test_doctor_prerequis_vm.py b/tests/test_doctor_prerequis_vm.py index 2bc6091..33b6652 100644 --- a/tests/test_doctor_prerequis_vm.py +++ b/tests/test_doctor_prerequis_vm.py @@ -265,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() From 98027b814f7e9a46402e6a6cde61f34b91aa4bf4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?St=C3=A9phane=20ROBERT?= Date: Mon, 16 Nov 2026 11:01:07 +0100 Subject: [PATCH 3/4] fix(doctor): --clients ne vise que Docker et Incus, et --fix installe Ansible avant le playbook MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Réévaluation du 2026-11-16 sur une AlmaLinux 10 neuve, sans git ni catalogue : KVM, facultatif hors catalogue, aurait été installé par --clients ; et la seule étape (git, root) tombait dans le repli « à coller », faute d Ansible au plan. Décisions 1 et 3 du même jour. Co-Authored-By: Claude Opus 5.5 --- src/dsoxlab/cli/diagnostic.py | 20 ++++++++++++- src/dsoxlab/i18n/strings/en.py | 2 ++ src/dsoxlab/i18n/strings/fr.py | 2 ++ src/dsoxlab/services/doctor_etapes.py | 11 ++++++- tests/test_doctor_fix.py | 41 +++++++++++++++++++++++++++ tests/test_doctor_guide.py | 13 +++++++++ 6 files changed, 87 insertions(+), 2 deletions(-) diff --git a/src/dsoxlab/cli/diagnostic.py b/src/dsoxlab/cli/diagnostic.py index 24bd1a5..4a87a02 100644 --- a/src/dsoxlab/cli/diagnostic.py +++ b/src/dsoxlab/cli/diagnostic.py @@ -332,6 +332,8 @@ def _afficher_plan(plan: PlanCorrection, report: DoctorReport, ansible: list[str 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) if plan.manuelles: console.print(Text(" " + _("fix_plan_manuelles"))) for etape in plan.manuelles: @@ -425,7 +427,7 @@ def _jouer_root( # root s'affichent en bloc à coller (décision 2). _bloc_root(etapes) return - if not _playbook_jouable(ansible[0]): + if not _playbook_jouable(ansible[0]) and not _installer_ansible(): warn(_("fix_pas_d_ansible")) _bloc_root(etapes) return @@ -449,6 +451,22 @@ def _playbook_jouable(binaire: str) -> bool: return Path(binaire).is_file() and os.access(binaire, os.X_OK) +def _installer_ansible() -> bool: + """Le playbook du poste a besoin d'Ansible : `--fix` l'installe d'abord, sans sudo. + + 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`. + """ + 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) diff --git a/src/dsoxlab/i18n/strings/en.py b/src/dsoxlab/i18n/strings/en.py index 2466057..60ca3e0 100644 --- a/src/dsoxlab/i18n/strings/en.py +++ b/src/dsoxlab/i18n/strings/en.py @@ -1796,6 +1796,8 @@ "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_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.", diff --git a/src/dsoxlab/i18n/strings/fr.py b/src/dsoxlab/i18n/strings/fr.py index 7a00d42..212be61 100644 --- a/src/dsoxlab/i18n/strings/fr.py +++ b/src/dsoxlab/i18n/strings/fr.py @@ -1844,6 +1844,8 @@ "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_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 " diff --git a/src/dsoxlab/services/doctor_etapes.py b/src/dsoxlab/services/doctor_etapes.py index e2e44bd..b7e94bf 100644 --- a/src/dsoxlab/services/doctor_etapes.py +++ b/src/dsoxlab/services/doctor_etapes.py @@ -22,6 +22,9 @@ 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: @@ -123,6 +126,12 @@ def construire(report: DoctorReport) -> Plan: 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] - facultatifs = [c for c in report.optional if not c.ok and c.remede is not None] + # `--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/tests/test_doctor_fix.py b/tests/test_doctor_fix.py index bba6c65..39692b6 100644 --- a/tests/test_doctor_fix.py +++ b/tests/test_doctor_fix.py @@ -254,6 +254,47 @@ class Fini: 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]] = [] + + class Fini: + returncode = 0 + + 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_plus_aucun_shell_true_dans_les_sources() -> None: """Le contrat de l'issue #89 : zéro ``shell=True`` dans ``src/dsoxlab/``.""" racine = Path(__file__).resolve().parent.parent / "src" / "dsoxlab" diff --git a/tests/test_doctor_guide.py b/tests/test_doctor_guide.py index 0c645a9..4cb21e4 100644 --- a/tests/test_doctor_guide.py +++ b/tests/test_doctor_guide.py @@ -466,3 +466,16 @@ def test_le_json_porte_les_commandes_l_attente_et_la_mise_en_garde( # 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"] From 192b4f5416e4df1f95da6e6f3c2e4e9ef29048f9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?St=C3=A9phane=20ROBERT?= Date: Mon, 16 Nov 2026 11:08:33 +0100 Subject: [PATCH 4/4] =?UTF-8?q?fix(doctor):=20un=20contr=C3=B4le=20qui=20a?= =?UTF-8?q?ttendait=20le=20playbook=20est=20rev=C3=A9rifi=C3=A9=20apr?= =?UTF-8?q?=C3=A8s,=20et=20Ansible=20se=20tait?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Réévaluation du 2026-11-16 sur AlmaLinux 10 : le firmware EFI, qui n attend que libvirt, était rangé en « à faire vous-même » et jamais redit ; il est désormais revérifié après le playbook. Le playbook pose ansible_python_interpreter=auto_silent : l avertissement de découverte de python3 était la seule ligne jaune de --fix. Co-Authored-By: Claude Opus 5.5 --- src/dsoxlab/cli/diagnostic.py | 45 ++++++++++++++++++++++------- src/dsoxlab/i18n/strings/en.py | 3 ++ src/dsoxlab/i18n/strings/fr.py | 3 ++ src/dsoxlab/services/remediation.py | 4 +++ tests/test_doctor_fix.py | 38 ++++++++++++++++++++++++ 5 files changed, 83 insertions(+), 10 deletions(-) diff --git a/src/dsoxlab/cli/diagnostic.py b/src/dsoxlab/cli/diagnostic.py index 4a87a02..9108c60 100644 --- a/src/dsoxlab/cli/diagnostic.py +++ b/src/dsoxlab/cli/diagnostic.py @@ -334,14 +334,20 @@ def _afficher_plan(plan: PlanCorrection, report: DoctorReport, ansible: list[str 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) - if plan.manuelles: - console.print(Text(" " + _("fix_plan_manuelles"))) - for etape in plan.manuelles: - console.print(Text(f" {etape.numero:>2}. {titre_etape(etape)}"), 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") @@ -394,11 +400,29 @@ 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: - _jouer_root(plan.root, ansible, chemin, remesurer, restantes) + 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], @@ -420,17 +444,17 @@ def _jouer_sans_sudo( def _jouer_root( etapes: list[Etape], ansible: list[str], chemin: Path, remesurer: Callable[[], DoctorReport], restantes: list[Etape], -) -> None: +) -> 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 + return False if not _playbook_jouable(ansible[0]) and not _installer_ansible(): warn(_("fix_pas_d_ansible")) _bloc_root(etapes) - return + 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))) @@ -441,10 +465,11 @@ def _jouer_root( _dire_le_resultat(application) if not application.ok: _arreter(restantes[restantes.index(etape):]) - return + 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 _playbook_jouable(binaire: str) -> bool: diff --git a/src/dsoxlab/i18n/strings/en.py b/src/dsoxlab/i18n/strings/en.py index 60ca3e0..0b448bb 100644 --- a/src/dsoxlab/i18n/strings/en.py +++ b/src/dsoxlab/i18n/strings/en.py @@ -1798,6 +1798,9 @@ "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.", diff --git a/src/dsoxlab/i18n/strings/fr.py b/src/dsoxlab/i18n/strings/fr.py index 212be61..aadd6ae 100644 --- a/src/dsoxlab/i18n/strings/fr.py +++ b/src/dsoxlab/i18n/strings/fr.py @@ -1846,6 +1846,9 @@ "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 " diff --git a/src/dsoxlab/services/remediation.py b/src/dsoxlab/services/remediation.py index a11df71..a82dcab 100644 --- a/src/dsoxlab/services/remediation.py +++ b/src/dsoxlab/services/remediation.py @@ -158,6 +158,10 @@ def playbook_du_poste(etapes: list[Etape], utilisateur: str) -> str: "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) diff --git a/tests/test_doctor_fix.py b/tests/test_doctor_fix.py index 39692b6..302e931 100644 --- a/tests/test_doctor_fix.py +++ b/tests/test_doctor_fix.py @@ -295,6 +295,44 @@ def faux_run_command(cmd: list[str], **kwargs: object) -> CommandResult: 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: """Le contrat de l'issue #89 : zéro ``shell=True`` dans ``src/dsoxlab/``.""" racine = Path(__file__).resolve().parent.parent / "src" / "dsoxlab"