#!/usr/bin/env python3 # © 2026 TechnoLibre (http://www.technolibre.ca) # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl) """Menu QEMU/KVM : récupérer des fichiers dans le disque d'une VM. Une VM qui ne démarre plus garde ses fichiers : le qcow2 est là, et libguestfs sait le monter SANS la machine. Le chemin complet : poser les outils selon la distribution de l'hôte, lister les systèmes de fichiers du disque, en choisir un, parcourir un répertoire, puis extraire vers l'hôte. Frontière claire : ici on LIT un disque, on n'y écrit jamais. Toute commande porte « --ro » — c'est ce qui rend l'opération sûre même sur une VM allumée, et c'est aussi pourquoi rien de ce fichier ne peut abîmer une machine. """ import os import shlex import shutil import subprocess from script.todo.qemu_privilege import ( install_cmd_for, system_env, system_path, ) from script.todo.todo_i18n import t # Le paquet qui apporte guestfish, par gestionnaire de paquets. Il ne vit pas # dans la table du déploiement : ces outils ne servent QU'À la récupération, # et les poser sur chaque hôte qui déploie une VM serait du poids pour rien. # # Les noms diffèrent d'une distribution à l'autre et le nom Debian ne marche # nulle part ailleurs : « libguestfs-tools » sur apt, « guestfs-tools » sur # dnf et zypper depuis que le paquet a été scindé, « libguestfs » sur pacman. GUESTFS_PACKAGES = { "apt": "libguestfs-tools", "dnf": "guestfs-tools", "pacman": "libguestfs", "zypper": "guestfs-tools", } # guestfish suffit à tout faire ; les deux autres ne font que présenter mieux # ce qu'il montre déjà. Les distinguer évite d'exiger un paquet complet là où # l'essentiel est présent. GUESTFS_BIN_ESSENTIEL = "guestfish" GUESTFS_BIN_CONFORT = ("virt-filesystems", "virt-df") def guestfs_install_cmd(): """(commande d'installation, paquet) pour cet hôte, ou (None, None). macOS y rend None comme tout hôte au gestionnaire inconnu, et c'est juste : libguestfs n'y tourne pas. """ return install_cmd_for(GUESTFS_PACKAGES) class QemuRecoverMixin: """Menu QEMU/KVM : récupérer des fichiers dans le disque d'une VM. Une VM qui ne démarre plus garde ses fichiers : le qcow2 est là, et libguestfs sait le monter SANS la machine. Le chemin complet : poser les outils selon la distribution de l'hôte, lister les systèmes de fichiers du disque, en choisir un, parcourir un répertoire, puis extraire vers l'hôte. Frontière claire : ici on LIT un disque, on n'y écrit jamais. """ def _qemu_guestfish_cmd(self, disk, *commandes): """Commande guestfish en LECTURE SEULE sur ce disque. « --ro » n'est pas une précaution parmi d'autres : sans lui, ouvrir le disque d'une VM allumée corrompt son système de fichiers. Avec lui, la lecture est sûre à tout moment — au pire elle voit un instantané incohérent, ce que le menu annonce. """ parties = " : ".join(commandes) return ( f"guestfish --ro -a {shlex.quote(str(disk))}" f"{' ' + parties if parties else ''}" ) def _qemu_guestfish_lines(self, disk, *commandes, timeout=180): """Lignes rendues par guestfish, ou [] s'il échoue. L'appliance libguestfs démarre un noyau : compter en secondes, pas en dixièmes. Un timeout généreux vaut mieux qu'un échec sur une machine chargée. """ cmd = self._qemu_guestfish_cmd(disk, *commandes) try: res = subprocess.run( cmd, shell=True, capture_output=True, text=True, timeout=timeout, env=system_env(), ) except (OSError, subprocess.SubprocessError): return [] if res.returncode != 0: if res.stderr: print(f" ⚠ {res.stderr.strip()[:300]}") return [] return [ln for ln in (res.stdout or "").splitlines() if ln.strip()] def _qemu_recover_ensure_tools(self): """guestfish est-il là ? Sinon, proposer de l'installer. Rend un bool. L'installation est PROPOSÉE et la commande montrée avant : elle pose un paquet de plusieurs centaines de mégaoctets, avec une image noyau. """ manque_essentiel = shutil.which(GUESTFS_BIN_ESSENTIEL) is None confort = [b for b in GUESTFS_BIN_CONFORT if shutil.which(b) is None] if not manque_essentiel and not confort: return True install, paquet = guestfs_install_cmd() if manque_essentiel: print(f"\n⚠ {t('guestfish is missing: libguestfs is not here.')}") else: print(f"\n⚠ {t('Some libguestfs helpers are missing:')}") print(f" {' '.join(confort)}") if not install: print(f" {t('Unknown package manager: install libguestfs.')}") return not manque_essentiel print(f" {t('Will execute:')} {install}") if not self._is_yes_default_yes( input(t("Install libguestfs now? (Y/n): ")) ): return not manque_essentiel self.execute.exec_command_live( install, source_erplibre=False, new_env={"PATH": system_path()} ) return shutil.which(GUESTFS_BIN_ESSENTIEL) is not None def _qemu_recover_ready(self, name): """La VM est-elle dans un état où la lecture a du sens ? Rend un bool. Une VM ALLUMÉE écrit pendant qu'on lit : la copie voit un instantané qui peut être incohérent — un fichier à moitié écrit, un journal non rejoué. Ce n'est pas dangereux en « --ro », mais il faut le dire, et proposer l'arrêt propre qui rend la lecture fidèle. """ etat = self._qemu_domstate(name) if etat != "running": return True print(f"\n⚠ {t('This VM is running.')}") print(f" {t('Reading a live disk sees a possibly torn state:')}") print(f" {t('a half-written file, an unreplayed journal.')}") choix = self._qemu_pick( t("What do you want to do?"), ["read", "shutdown", "cancel"], "shutdown", [ t("Read anyway (read-only, no risk for the VM)"), t("Shut the VM down cleanly, then read"), t("Cancel"), ], ) if choix == "cancel": return False if choix == "read": return True return self._qemu_shutdown_wait(name) def _qemu_recover_pick_filesystem(self, disk): """Système de fichiers choisi dans le disque, ou "" si aucun. « list-filesystems » les rend tous, y compris ceux qu'on ne peut pas monter — swap, partitions vides. Les montrer quand même : leur absence de la liste inquiéterait plus qu'elle n'aiderait. """ cmd = self._qemu_guestfish_cmd(disk, "run", "list-filesystems") print(f"\n{t('Will execute:')} {cmd}") lignes = self._qemu_guestfish_lines(disk, "run", "list-filesystems") if not lignes: print(f" {t('No filesystem found on this disk.')}") return "" parts, labels = [], [] for ligne in lignes: # « /dev/sda3: ext4 » — le nom, puis son type. dev, _, typ = ligne.partition(":") dev, typ = dev.strip(), typ.strip() if not dev: continue parts.append(dev) labels.append(f"{dev} {typ}") if not parts: return "" # Le plus grand système de fichiers non-swap est presque toujours la # racine : le proposer par défaut épargne un choix à qui ne connaît # pas le partitionnement de sa VM. defaut = next( (p for p, lab in zip(parts, labels) if "swap" not in lab), parts[0], ) return self._qemu_pick(t("Filesystem to mount"), parts, defaut, labels) def _qemu_recover_browse(self, disk, part, chemin): """Liste un répertoire du système de fichiers monté. Rend les entrées trouvées.""" cmd = self._qemu_guestfish_cmd( disk, "run", f"mount {part} /", f"ls {shlex.quote(chemin)}" ) print(f"\n{t('Will execute:')} {cmd}") entrees = self._qemu_guestfish_lines( disk, "run", f"mount {part} /", f"ls {shlex.quote(chemin)}" ) if not entrees: print(f" {t('Empty or unreadable directory.')}") return [] for entree in entrees: print(f" {entree}") print(f" {t('Total:')} {len(entrees)}") return entrees def _qemu_recover_copy_out(self, disk, part, source, dest): """Extrait un chemin de la VM vers l'hôte. Rend un bool. « copy-out » écrit DANS le répertoire de destination : il faut donc qu'il existe, sinon guestfish s'arrête sur une erreur qui ne dit pas laquelle des deux extrémités manque. """ try: os.makedirs(dest, exist_ok=True) except OSError as exc: print(f" ⚠ {t('Cannot create the destination: ')}{exc}") return False cmd = self._qemu_guestfish_cmd( disk, "run", f"mount {part} /", f"copy-out {shlex.quote(source)} {shlex.quote(dest)}", ) print(f"\n{t('Will execute:')} {cmd}") code = self.execute.exec_command_live( cmd, source_erplibre=False, new_env={"PATH": system_path()} ) if code: print(f" ⚠ {t('Extraction failed.')}") return False cible = os.path.join(dest, os.path.basename(source.rstrip("/"))) print(f"\n✅ {t('Extracted to: ')}{cible}") return True def _qemu_recover_diagnostics(self, disk): """Commandes de diagnostic sur le disque, sans rien monter à la main. Chacune répond à une question précise qu'on se pose quand la lecture ne donne pas ce qu'on attend : les partitions existent-elles, restent- elles de la place, le système est-il reconnu, l'appliance démarre-t-elle. """ q = shlex.quote(str(disk)) sondes = [ ( t("Partitions and sizes"), f"virt-filesystems -a {q} --long -h --all", ), (t("Free space per filesystem"), f"virt-df -a {q} -h"), ( t("Detected operating system"), self._qemu_guestfish_cmd(disk, "run", "inspect-os"), ), ( t("Does the libguestfs appliance boot?"), "libguestfs-test-tool", ), ] for titre, cmd in sondes: print(f"\n── {titre} ──") print(f"{t('Will execute:')} {cmd}") self.execute.exec_command_live( cmd, source_erplibre=False, new_env={"PATH": system_path()} ) def _qemu_recover_files(self): """Récupère des fichiers dans le disque d'une VM, sans la démarrer.""" print(f"\n💾 {t('Recover files from a VM disk (libguestfs)')}") if not self._qemu_recover_ensure_tools(): return self._qemu_list_vms() print() name = input(t("VM name or ID: ")).strip() if not name: print(t("VM name is required!")) return name = self._qemu_domname(name) disk = self._qemu_main_disk(name) if not disk: print(f" ⚠ {t('No disk found for this VM.')}") return print(f" {t('Disk:')} {disk}") if not self._qemu_recover_ready(name): print(t("Cancelled.")) return if self._is_yes(input(t("Run the diagnostics first? (y/N): "))): self._qemu_recover_diagnostics(disk) part = self._qemu_recover_pick_filesystem(disk) if not part: return chemin = input(t("Directory to list [/]: ")).strip() or "/" while True: self._qemu_recover_browse(disk, part, chemin) suite = input( t("Another directory, or Enter to extract: ") ).strip() if not suite: break chemin = suite source = input(f"{t('Path to extract')} [{chemin}] : ").strip() source = source or chemin defaut_dest = f"/tmp/{name}-backup" dest = input(f"{t('Destination on the host')} [{defaut_dest}] : ") dest = dest.strip() or defaut_dest self._qemu_recover_copy_out(disk, part, source, dest)