Merge branch 'feature/backups' into claude/production-system-image-smcxyr
# Conflicts: # tests/conftest.py # tests/dev_server.py # web/app.py # web/templates/vm_detail.html
Этот коммит содержится в:
Claude
@@ -0,0 +1,691 @@
|
||||
"""Резервные копии виртуальных машин.
|
||||
|
||||
Копия лежит в BACKUPS_DIR/<машина>/<ГГГГММДД-ЧЧММ>/ и состоит из vm.xml
|
||||
(настройки), <диск>.qcow2 на каждый диск и meta.json. Создание и
|
||||
восстановление выполняются как фоновые операции с прогрессом и журналом.
|
||||
|
||||
`create_backup(vm_name, note)` можно вызывать без HTTP — например, из
|
||||
расписания: `python3 web/features/backups.py web01 "ночная копия"`.
|
||||
"""
|
||||
import json
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
import xml.etree.ElementTree as ET
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from typing import Any, Callable
|
||||
|
||||
if __name__ == "__main__": # запуск как скрипта: нужен web/ в sys.path
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
||||
|
||||
from fastapi import APIRouter, Form, Request # noqa: E402
|
||||
from fastapi.responses import RedirectResponse # noqa: E402
|
||||
|
||||
import core # noqa: E402
|
||||
import presenters # noqa: E402
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
BACKUP_ID_RE = re.compile(r"\d{8}-\d{4}")
|
||||
SHUTDOWN_TIMEOUT = 180.0 # секунд ждём мягкого выключения
|
||||
POLL_INTERVAL = 2.0
|
||||
SPACE_MARGIN = 256 * 1024 * 1024 # запас, чтобы не забить диск под завязку
|
||||
NOTE_MAX = 120
|
||||
MONTHS = ("января", "февраля", "марта", "апреля", "мая", "июня", "июля", "августа", "сентября", "октября", "ноября", "декабря")
|
||||
|
||||
|
||||
class BackupError(Exception):
|
||||
"""Ошибка, текст которой можно показать пользователю как есть."""
|
||||
|
||||
def __init__(self, message: str, code: str = "") -> None:
|
||||
super().__init__(message)
|
||||
self.code = code
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- helpers
|
||||
def run(cmd: list[str], timeout: int = 12) -> dict[str, Any]:
|
||||
return core.run_cmd(cmd, timeout=timeout)
|
||||
|
||||
|
||||
def stream_cmd(cmd: list[str], on_line: Callable[[str], None]) -> int:
|
||||
"""Запустить команду и отдавать каждую строку вывода (по \\r и \\n) в on_line.
|
||||
|
||||
qemu-img с ключом -p печатает прогресс через \\r, поэтому обычное чтение
|
||||
по строкам не подходит. Возвращает код завершения."""
|
||||
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
|
||||
pending = b""
|
||||
assert process.stdout is not None
|
||||
while True:
|
||||
chunk = process.stdout.read(512)
|
||||
if not chunk:
|
||||
break
|
||||
pending += chunk
|
||||
parts = re.split(rb"[\r\n]+", pending)
|
||||
pending = parts.pop()
|
||||
for part in parts:
|
||||
text = part.decode("utf-8", "replace").strip()
|
||||
if text:
|
||||
on_line(text)
|
||||
tail = pending.decode("utf-8", "replace").strip()
|
||||
if tail:
|
||||
on_line(tail)
|
||||
return process.wait()
|
||||
|
||||
|
||||
def parse_progress(line: str) -> int | None:
|
||||
"""' (12.34/100%)' → 12. None, если в строке нет прогресса qemu-img."""
|
||||
match = re.search(r"\((\d+(?:\.\d+)?)/100%\)", line or "")
|
||||
return min(100, int(float(match.group(1)))) if match else None
|
||||
|
||||
|
||||
def parse_qemu_img_info(text: str) -> dict[str, Any]:
|
||||
"""Вывод `qemu-img info --output=json` → {virtual_size, actual_size, format}."""
|
||||
empty = {"virtual_size": 0, "actual_size": 0, "format": ""}
|
||||
try:
|
||||
data = json.loads(text or "")
|
||||
except ValueError:
|
||||
return empty
|
||||
if not isinstance(data, dict):
|
||||
return empty
|
||||
try:
|
||||
return {"virtual_size": int(data.get("virtual-size") or 0), "actual_size": int(data.get("actual-size") or 0), "format": str(data.get("format") or "")}
|
||||
except (TypeError, ValueError):
|
||||
return empty
|
||||
|
||||
|
||||
def disk_info(path: str) -> dict[str, Any]:
|
||||
result = run(["qemu-img", "info", "--output=json", path], timeout=30)
|
||||
return parse_qemu_img_info(result["stdout"]) if result["ok"] else parse_qemu_img_info("")
|
||||
|
||||
|
||||
def vm_disks(name: str) -> list[dict[str, str]]:
|
||||
"""Диски машины (без приводов CD/DVD) из `virsh domblklist --details`."""
|
||||
result = run(["virsh", "domblklist", name, "--details"], timeout=10)
|
||||
if not result["ok"]:
|
||||
raise BackupError("Не удалось получить список дисков: " + core.cmd_error(result, "virsh domblklist"))
|
||||
return [disk for disk in presenters.parse_domblklist(result["stdout"]) if disk["device"] == "disk" and disk["source"]]
|
||||
|
||||
|
||||
def vm_cdroms_with_media(name: str) -> list[dict[str, str]]:
|
||||
result = run(["virsh", "domblklist", name, "--details"], timeout=10)
|
||||
if not result["ok"]:
|
||||
return []
|
||||
return [disk for disk in presenters.parse_domblklist(result["stdout"]) if disk["device"] == "cdrom" and disk["source"]]
|
||||
|
||||
|
||||
def free_bytes(path: Path) -> int:
|
||||
target = path
|
||||
while not target.exists() and target != target.parent:
|
||||
target = target.parent
|
||||
try:
|
||||
return shutil.disk_usage(target).free
|
||||
except OSError:
|
||||
return 0
|
||||
|
||||
|
||||
def format_bytes(value: int | float) -> str:
|
||||
return presenters.format_bytes(value)
|
||||
|
||||
|
||||
def format_backup_date(backup_id: str) -> str:
|
||||
try:
|
||||
moment = datetime.strptime(backup_id, "%Y%m%d-%H%M")
|
||||
except ValueError:
|
||||
return backup_id
|
||||
return f"{moment.day} {MONTHS[moment.month - 1]} {moment.year}, {moment:%H:%M}"
|
||||
|
||||
|
||||
def clean_note(note: str) -> str:
|
||||
return re.sub(r"[\x00-\x1f\x7f]+", " ", note or "").strip()[:NOTE_MAX]
|
||||
|
||||
|
||||
def existing_vm_names() -> set[str]:
|
||||
result = run(["virsh", "list", "--all", "--name"], timeout=10)
|
||||
return {line.strip() for line in (result.get("stdout") or "").splitlines() if line.strip()} if result["ok"] else set()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- storage layout
|
||||
def backup_root() -> Path:
|
||||
return core.BACKUPS_DIR
|
||||
|
||||
|
||||
def backup_path(vm: str, backup_id: str) -> Path | None:
|
||||
"""Папка копии или None, если имя машины/копии некорректно или уводит из BACKUPS_DIR."""
|
||||
if not core.valid_vm_name(vm) or not BACKUP_ID_RE.fullmatch(backup_id or ""):
|
||||
return None
|
||||
root = backup_root()
|
||||
path = root / vm / backup_id
|
||||
try:
|
||||
path.resolve().relative_to(root.resolve())
|
||||
except ValueError:
|
||||
return None
|
||||
return path
|
||||
|
||||
|
||||
def describe_backup(vm: str, backup_id: str, path: Path, meta: dict[str, Any]) -> dict[str, Any]:
|
||||
disks = [disk for disk in meta.get("disks", []) if isinstance(disk, dict) and disk.get("target")]
|
||||
size = int(meta.get("size_bytes") or 0)
|
||||
complete = (path / "vm.xml").exists() and bool(disks) and all((path / f"{disk['target']}.qcow2").exists() for disk in disks)
|
||||
return {
|
||||
"vm": vm,
|
||||
"id": backup_id,
|
||||
"path": str(path),
|
||||
"created_at": meta.get("created_at") or "",
|
||||
"created_label": format_backup_date(backup_id),
|
||||
"note": clean_note(str(meta.get("note") or "")),
|
||||
"disks": disks,
|
||||
"disk_count": len(disks),
|
||||
"size_bytes": size,
|
||||
"size": format_bytes(size),
|
||||
"version": str(meta.get("version") or ""),
|
||||
"complete": complete,
|
||||
}
|
||||
|
||||
|
||||
def read_backup(vm: str, backup_id: str) -> dict[str, Any] | None:
|
||||
path = backup_path(vm, backup_id)
|
||||
if not path or not (path / "meta.json").is_file():
|
||||
return None
|
||||
try:
|
||||
meta = json.loads((path / "meta.json").read_text())
|
||||
except (OSError, ValueError):
|
||||
return None
|
||||
if not isinstance(meta, dict):
|
||||
return None
|
||||
return describe_backup(vm, backup_id, path, meta)
|
||||
|
||||
|
||||
def list_backups(vm: str | None = None) -> list[dict[str, Any]]:
|
||||
"""Все копии (или копии одной машины), новые сверху."""
|
||||
root = backup_root()
|
||||
if not root.is_dir():
|
||||
return []
|
||||
if vm is not None:
|
||||
vm_dirs = [root / vm] if core.valid_vm_name(vm) else []
|
||||
else:
|
||||
vm_dirs = sorted(item for item in root.iterdir() if item.is_dir() and core.valid_vm_name(item.name))
|
||||
items: list[dict[str, Any]] = []
|
||||
for vm_dir in vm_dirs:
|
||||
if not vm_dir.is_dir():
|
||||
continue
|
||||
for item in vm_dir.iterdir():
|
||||
if item.is_dir() and BACKUP_ID_RE.fullmatch(item.name):
|
||||
backup = read_backup(vm_dir.name, item.name)
|
||||
if backup:
|
||||
items.append(backup)
|
||||
items.sort(key=lambda item: (item["id"], item["vm"]), reverse=True)
|
||||
return items
|
||||
|
||||
|
||||
def group_by_vm(items: list[dict[str, Any]], existing: set[str] | None = None) -> list[dict[str, Any]]:
|
||||
groups: dict[str, dict[str, Any]] = {}
|
||||
for item in items:
|
||||
group = groups.setdefault(item["vm"], {"vm": item["vm"], "backups": [], "size_bytes": 0, "exists": existing is None or item["vm"] in existing})
|
||||
group["backups"].append(item)
|
||||
group["size_bytes"] += item["size_bytes"]
|
||||
for group in groups.values():
|
||||
group["size"] = format_bytes(group["size_bytes"])
|
||||
group["count"] = len(group["backups"])
|
||||
return sorted(groups.values(), key=lambda group: group["vm"])
|
||||
|
||||
|
||||
def storage_summary(items: list[dict[str, Any]] | None = None) -> dict[str, Any]:
|
||||
items = list_backups() if items is None else items
|
||||
used = sum(item["size_bytes"] for item in items)
|
||||
free = free_bytes(backup_root())
|
||||
total = used + free
|
||||
return {
|
||||
"count": len(items),
|
||||
"used_bytes": used,
|
||||
"used": format_bytes(used),
|
||||
"free_bytes": free,
|
||||
"free": format_bytes(free),
|
||||
"used_pct": int(round(used / total * 100)) if total else 0,
|
||||
}
|
||||
|
||||
|
||||
def remove_backup_dir(path: Path) -> None:
|
||||
"""Удалить папку копии; пустую папку машины над ней — тоже."""
|
||||
shutil.rmtree(path, ignore_errors=True)
|
||||
parent = path.parent
|
||||
try:
|
||||
if parent != backup_root() and parent.is_dir() and not any(parent.iterdir()):
|
||||
parent.rmdir()
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
|
||||
def delete_backup(vm: str, backup_id: str) -> None:
|
||||
path = backup_path(vm, backup_id)
|
||||
if not path or not path.is_dir():
|
||||
raise BackupError("Копия не найдена — возможно, её уже удалили")
|
||||
for operation in core.running_operations():
|
||||
if operation.get("type") in ("backup", "restore") and operation.get("backup_id") == backup_id and operation.get("source_vm", operation.get("vm_name")) == vm:
|
||||
raise BackupError("С этой копией сейчас идёт работа — дождитесь завершения задачи")
|
||||
remove_backup_dir(path)
|
||||
|
||||
|
||||
def active_operation(vm: str) -> dict[str, Any] | None:
|
||||
"""Идущая сейчас задача копирования/восстановления, связанная с машиной."""
|
||||
for operation in core.running_operations():
|
||||
if operation.get("type") in ("backup", "restore") and vm in (operation.get("vm_name"), operation.get("source_vm")):
|
||||
return operation
|
||||
return None
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- создание копии
|
||||
def create_backup(vm_name: str, note: str = "", wait: bool = False) -> dict[str, Any]:
|
||||
"""Поставить создание копии в очередь и вернуть операцию.
|
||||
|
||||
Проверки (машина есть, диски есть, места хватает) выполняются сразу и
|
||||
поднимают BackupError с понятным текстом. С wait=True копия делается
|
||||
в текущем потоке — удобно для расписания."""
|
||||
if not core.valid_vm_name(vm_name):
|
||||
raise BackupError("Некорректное имя машины")
|
||||
note = clean_note(note)
|
||||
if not core.vm_exists(vm_name):
|
||||
raise BackupError(f"Машина {vm_name} не найдена")
|
||||
if active_operation(vm_name):
|
||||
raise BackupError("С этой машиной уже идёт копирование или восстановление — дождитесь завершения")
|
||||
disks = vm_disks(vm_name)
|
||||
if not disks:
|
||||
raise BackupError("У машины нет дисков — копировать нечего")
|
||||
plan: list[dict[str, Any]] = []
|
||||
need = 0
|
||||
for disk in disks:
|
||||
info = disk_info(disk["source"])
|
||||
size = info["actual_size"] or info["virtual_size"]
|
||||
need += size
|
||||
plan.append({"target": disk["target"], "source": disk["source"], "size": size})
|
||||
free = free_bytes(backup_root())
|
||||
if free < need + SPACE_MARGIN:
|
||||
raise BackupError(f"Недостаточно места для копии: нужно около {format_bytes(need)}, свободно {format_bytes(free)}. Удалите старые копии или освободите место на сервере.", "space")
|
||||
backup_id = datetime.now().strftime("%Y%m%d-%H%M")
|
||||
if (backup_root() / vm_name / backup_id).exists():
|
||||
raise BackupError("Копия этой машины уже создана в эту минуту. Подождите минуту и повторите.")
|
||||
operation = core.new_operation("backup", f"Резервная копия {vm_name}", "Ожидает начала", vm_name=vm_name, backup_id=backup_id, note=note, disks=plan, size_bytes=need)
|
||||
if wait:
|
||||
core.update_operation(operation, status="running", started_at=core.utc_now())
|
||||
backup_worker(operation)
|
||||
return core.read_operation(operation["id"]) or operation
|
||||
core.run_operation(operation, backup_worker)
|
||||
return operation
|
||||
|
||||
|
||||
def disk_progress_reporter(operation: dict[str, Any], index: int, total: int, label: str) -> Callable[[str], None]:
|
||||
"""on_line для qemu-img: общий прогресс = 5…95 %, разложенный по дискам."""
|
||||
state = {"last": -1, "logged": -10}
|
||||
|
||||
def on_line(line: str) -> None:
|
||||
pct = parse_progress(line)
|
||||
if pct is None:
|
||||
core.append_operation_log(operation["id"], line)
|
||||
return
|
||||
overall = int(5 + (index + pct / 100) / total * 90)
|
||||
if overall == state["last"]:
|
||||
return
|
||||
state["last"] = overall
|
||||
core.update_operation(operation, progress=overall, message=f"{label}: {pct}%")
|
||||
if pct - state["logged"] >= 10 or pct == 100:
|
||||
state["logged"] = pct
|
||||
core.append_operation_log(operation["id"], f"{label}: {pct}%")
|
||||
|
||||
return on_line
|
||||
|
||||
|
||||
def shutdown_and_wait(operation: dict[str, Any], vm: str) -> bool:
|
||||
log = lambda text: core.append_operation_log(operation["id"], text) # noqa: E731
|
||||
log("Машина работает — отправляем команду выключения (как кнопка питания, система завершит работу сама).")
|
||||
core.update_operation(operation, progress=2, message="Выключаем машину…")
|
||||
result = run(["virsh", "shutdown", vm], timeout=20)
|
||||
if not result["ok"]:
|
||||
log("Команда выключения не принята: " + core.cmd_error(result, "virsh shutdown"))
|
||||
return False
|
||||
deadline = time.monotonic() + SHUTDOWN_TIMEOUT
|
||||
polls = 0
|
||||
while time.monotonic() < deadline:
|
||||
time.sleep(POLL_INTERVAL)
|
||||
polls += 1
|
||||
if not core.vm_is_running(vm):
|
||||
log("Машина выключена.")
|
||||
return True
|
||||
if polls % 5 == 0:
|
||||
waited = int(polls * POLL_INTERVAL)
|
||||
core.update_operation(operation, message=f"Ждём выключения машины… {waited} с из {int(SHUTDOWN_TIMEOUT)}")
|
||||
log(f"Всё ещё работает, ждём ({waited} с).")
|
||||
return False
|
||||
|
||||
|
||||
def start_vm(operation: dict[str, Any], vm: str) -> str:
|
||||
"""Запустить машину обратно; вернуть текст проблемы или пустую строку."""
|
||||
result = run(["virsh", "start", vm], timeout=40)
|
||||
if result["ok"]:
|
||||
core.append_operation_log(operation["id"], "Машина запущена снова.")
|
||||
return ""
|
||||
problem = core.cmd_error(result, "virsh start")
|
||||
core.append_operation_log(operation["id"], "Не удалось запустить машину: " + problem)
|
||||
return problem
|
||||
|
||||
|
||||
def backup_worker(operation: dict[str, Any]) -> None:
|
||||
vm = operation["vm_name"]
|
||||
plan = operation["disks"]
|
||||
log = lambda text: core.append_operation_log(operation["id"], text) # noqa: E731
|
||||
was_running = core.vm_is_running(vm)
|
||||
if was_running and not shutdown_and_wait(operation, vm):
|
||||
core.finish_operation(operation, False, "Машина не выключилась за 3 минуты. Сохраните работу внутри неё, выключите её вручную и создайте копию ещё раз.")
|
||||
return
|
||||
dest = backup_root() / vm / operation["backup_id"]
|
||||
size = 0
|
||||
try:
|
||||
dest.mkdir(parents=True, exist_ok=False)
|
||||
result = run(["virsh", "dumpxml", vm, "--migratable"], timeout=20)
|
||||
if not result["ok"]:
|
||||
raise BackupError("Не удалось сохранить настройки машины: " + core.cmd_error(result, "virsh dumpxml"))
|
||||
(dest / "vm.xml").write_text(result["stdout"].rstrip() + "\n", encoding="utf-8")
|
||||
log("Настройки машины сохранены в vm.xml.")
|
||||
total = len(plan)
|
||||
for index, disk in enumerate(plan):
|
||||
target_file = dest / f"{disk['target']}.qcow2"
|
||||
label = f"Копируем диск {disk['target']} ({index + 1} из {total})"
|
||||
core.update_operation(operation, progress=int(5 + index / total * 90), message=label)
|
||||
log(f"{label}: {disk['source']} → {target_file}")
|
||||
cmd = ["qemu-img", "convert", "-p", "-O", "qcow2", "-c", disk["source"], str(target_file)]
|
||||
log(" ".join(cmd))
|
||||
code = stream_cmd(cmd, disk_progress_reporter(operation, index, total, label))
|
||||
if code != 0:
|
||||
raise BackupError(f"Не удалось скопировать диск {disk['target']} (qemu-img завершился с кодом {code})")
|
||||
size = sum(item.stat().st_size for item in dest.iterdir() if item.is_file())
|
||||
meta = {"vm": vm, "created_at": core.utc_now(), "disks": plan, "size_bytes": size, "version": core.APP_VERSION, "note": operation.get("note", "")}
|
||||
(dest / "meta.json").write_text(json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8")
|
||||
log(f"Копия готова: {format_bytes(size)} (сжатие включено).")
|
||||
except Exception as exc: # noqa: BLE001 — любая ошибка = операция с понятным текстом
|
||||
remove_backup_dir(dest)
|
||||
log(f"Ошибка: {exc}")
|
||||
problem = start_vm(operation, vm) if was_running else ""
|
||||
message = str(exc)[:200]
|
||||
if problem:
|
||||
message += f". Машину тоже не удалось запустить: {problem}"
|
||||
core.finish_operation(operation, False, message)
|
||||
return
|
||||
problem = start_vm(operation, vm) if was_running else ""
|
||||
message = f"Резервная копия создана: {format_bytes(size)}"
|
||||
if problem:
|
||||
message += f". Но машину не удалось запустить снова: {problem}"
|
||||
core.finish_operation(operation, True, message, size_bytes=size)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- восстановление
|
||||
def rewrite_xml(xml_text: str, new_name: str, disk_map: dict[str, str]) -> str:
|
||||
"""Подготовить XML копии к `virsh define` под именем new_name.
|
||||
|
||||
Меняет <name>, убирает <uuid> и id, переключает диски на новые файлы,
|
||||
удаляет <mac> (libvirt выдаст новые адреса) и <nvram> (libvirt заведёт
|
||||
свой файл под новое имя, чтобы не делить его со старой машиной)."""
|
||||
root = ET.fromstring(xml_text)
|
||||
root.attrib.pop("id", None)
|
||||
name = root.find("name")
|
||||
if name is None:
|
||||
name = ET.Element("name")
|
||||
root.insert(0, name)
|
||||
name.text = new_name
|
||||
for element in root.findall("uuid"):
|
||||
root.remove(element)
|
||||
devices = root.find("devices")
|
||||
if devices is not None:
|
||||
for disk in devices.findall("disk"):
|
||||
target = disk.find("target")
|
||||
dev = target.get("dev") if target is not None else None
|
||||
if disk.get("device") != "disk" or dev not in disk_map:
|
||||
continue
|
||||
source = disk.find("source")
|
||||
if source is None:
|
||||
source = ET.SubElement(disk, "source")
|
||||
source.attrib.clear()
|
||||
source.set("file", disk_map[dev])
|
||||
disk.set("type", "file")
|
||||
driver = disk.find("driver")
|
||||
if driver is None:
|
||||
driver = ET.SubElement(disk, "driver")
|
||||
driver.set("name", "qemu")
|
||||
driver.set("type", "qcow2")
|
||||
for interface in devices.findall("interface"):
|
||||
for mac in interface.findall("mac"):
|
||||
interface.remove(mac)
|
||||
os_element = root.find("os")
|
||||
if os_element is not None:
|
||||
for nvram in os_element.findall("nvram"):
|
||||
os_element.remove(nvram)
|
||||
return ET.tostring(root, encoding="unicode")
|
||||
|
||||
|
||||
def restore_disk_path(new_name: str, target: str, index: int) -> Path:
|
||||
images = core.IMAGES_DIR
|
||||
candidates = [images / f"{new_name}.qcow2"] if index == 0 else []
|
||||
candidates.append(images / f"{new_name}-{target}.qcow2")
|
||||
for candidate in candidates:
|
||||
if not candidate.exists():
|
||||
return candidate
|
||||
counter = 2
|
||||
while (images / f"{new_name}-{target}-{counter}.qcow2").exists():
|
||||
counter += 1
|
||||
return images / f"{new_name}-{target}-{counter}.qcow2"
|
||||
|
||||
|
||||
def plan_restore(vm: str, backup_id: str, new_name: str, replace: bool) -> dict[str, Any]:
|
||||
backup = read_backup(vm, backup_id)
|
||||
if not backup:
|
||||
raise BackupError("Копия не найдена")
|
||||
if not backup["complete"]:
|
||||
raise BackupError("Копия неполная — не хватает файлов. Восстановить из неё нельзя.")
|
||||
new_name = (new_name or "").strip() or vm
|
||||
if not core.valid_vm_name(new_name):
|
||||
raise BackupError("Название машины: латинские буквы, цифры, точка, дефис, от 2 до 63 символов", "name")
|
||||
exists = core.vm_exists(new_name)
|
||||
if exists and not replace:
|
||||
raise BackupError(f"Машина {new_name} уже есть на сервере. Укажите другое название или подтвердите замену.", "exists")
|
||||
if active_operation(new_name) or active_operation(vm):
|
||||
raise BackupError("С этой машиной уже идёт копирование или восстановление — дождитесь завершения")
|
||||
need = sum(int(disk.get("size") or 0) for disk in backup["disks"])
|
||||
reclaim = 0
|
||||
if exists:
|
||||
try:
|
||||
reclaim = sum(disk_info(disk["source"])["actual_size"] for disk in vm_disks(new_name))
|
||||
except BackupError:
|
||||
reclaim = 0
|
||||
free = free_bytes(core.IMAGES_DIR) + reclaim
|
||||
if free < need + SPACE_MARGIN:
|
||||
raise BackupError(f"Недостаточно места для дисков машины: нужно около {format_bytes(need)}, свободно {format_bytes(free)}.", "space")
|
||||
return {"backup": backup, "new_name": new_name, "replace": exists, "need": need}
|
||||
|
||||
|
||||
def start_restore(vm: str, backup_id: str, new_name: str, replace: bool) -> dict[str, Any]:
|
||||
plan = plan_restore(vm, backup_id, new_name, replace)
|
||||
backup = plan["backup"]
|
||||
title = f"Восстановление {plan['new_name']} из копии"
|
||||
operation = core.new_operation("restore", title, "Ожидает начала", vm_name=plan["new_name"], source_vm=vm, backup_id=backup_id, replace=plan["replace"], disks=backup["disks"], size_bytes=plan["need"])
|
||||
core.run_operation(operation, restore_worker)
|
||||
return operation
|
||||
|
||||
|
||||
def remove_vm(operation: dict[str, Any], name: str) -> None:
|
||||
"""Удалить существующую машину вместе с дисками перед восстановлением."""
|
||||
log = lambda text: core.append_operation_log(operation["id"], text) # noqa: E731
|
||||
if core.vm_is_running(name):
|
||||
log(f"Машина {name} работает — выключаем принудительно.")
|
||||
result = run(["virsh", "destroy", name], timeout=30)
|
||||
if not result["ok"]:
|
||||
raise BackupError("Не удалось выключить старую машину: " + core.cmd_error(result, "virsh destroy"))
|
||||
for cdrom in vm_cdroms_with_media(name):
|
||||
# Иначе `undefine --remove-all-storage` удалит и вставленный ISO-образ.
|
||||
result = run(["virsh", "change-media", name, cdrom["target"], "--eject", "--config"], timeout=20)
|
||||
if not result["ok"]:
|
||||
raise BackupError(f"Не удалось извлечь образ из привода {cdrom['target']}: " + core.cmd_error(result, "virsh change-media"))
|
||||
log(f"Образ извлечён из привода {cdrom['target']}, чтобы он не был удалён вместе с машиной.")
|
||||
result = run(["virsh", "undefine", name, "--remove-all-storage", "--nvram", "--managed-save", "--snapshots-metadata"], timeout=180)
|
||||
if not result["ok"]:
|
||||
raise BackupError("Не удалось удалить старую машину: " + core.cmd_error(result, "virsh undefine"))
|
||||
log(f"Старая машина {name} удалена вместе с дисками.")
|
||||
|
||||
|
||||
def restore_worker(operation: dict[str, Any]) -> None:
|
||||
new_name = operation["vm_name"]
|
||||
log = lambda text: core.append_operation_log(operation["id"], text) # noqa: E731
|
||||
backup = read_backup(operation["source_vm"], operation["backup_id"])
|
||||
created: list[Path] = []
|
||||
try:
|
||||
if not backup or not backup["complete"]:
|
||||
raise BackupError("Копия не найдена или неполная")
|
||||
if operation.get("replace"):
|
||||
core.update_operation(operation, progress=3, message=f"Удаляем существующую машину {new_name}…")
|
||||
remove_vm(operation, new_name)
|
||||
core.IMAGES_DIR.mkdir(parents=True, exist_ok=True)
|
||||
disk_map: dict[str, str] = {}
|
||||
total = len(backup["disks"])
|
||||
for index, disk in enumerate(backup["disks"]):
|
||||
source = Path(backup["path"]) / f"{disk['target']}.qcow2"
|
||||
target = restore_disk_path(new_name, disk["target"], index)
|
||||
created.append(target)
|
||||
label = f"Восстанавливаем диск {disk['target']} ({index + 1} из {total})"
|
||||
core.update_operation(operation, progress=int(5 + index / total * 90), message=label)
|
||||
log(f"{label}: {source} → {target}")
|
||||
cmd = ["qemu-img", "convert", "-p", "-O", "qcow2", str(source), str(target)]
|
||||
log(" ".join(cmd))
|
||||
code = stream_cmd(cmd, disk_progress_reporter(operation, index, total, label))
|
||||
if code != 0:
|
||||
raise BackupError(f"Не удалось восстановить диск {disk['target']} (qemu-img завершился с кодом {code})")
|
||||
disk_map[disk["target"]] = str(target)
|
||||
core.update_operation(operation, progress=96, message="Регистрируем машину…")
|
||||
xml = rewrite_xml((Path(backup["path"]) / "vm.xml").read_text(encoding="utf-8"), new_name, disk_map)
|
||||
with tempfile.NamedTemporaryFile("w", dir=backup["path"], prefix="restore-", suffix=".xml", delete=False, encoding="utf-8") as handle:
|
||||
handle.write(xml)
|
||||
tmp_xml = Path(handle.name)
|
||||
try:
|
||||
result = run(["virsh", "define", str(tmp_xml)], timeout=30)
|
||||
finally:
|
||||
tmp_xml.unlink(missing_ok=True)
|
||||
if not result["ok"]:
|
||||
raise BackupError("Не удалось зарегистрировать машину: " + core.cmd_error(result, "virsh define"))
|
||||
run(["virsh", "pool-refresh", core.IMAGES_POOL], timeout=20)
|
||||
log(f"Машина {new_name} зарегистрирована.")
|
||||
except Exception as exc: # noqa: BLE001
|
||||
for path in created:
|
||||
path.unlink(missing_ok=True)
|
||||
log(f"Ошибка: {exc}")
|
||||
core.finish_operation(operation, False, str(exc)[:240])
|
||||
return
|
||||
created_label = backup["created_label"] if backup else ""
|
||||
core.finish_operation(operation, True, f"Машина {new_name} восстановлена из копии от {created_label}. Она выключена — запустите её, когда будете готовы.")
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- страницы
|
||||
def page_messages(request: Request) -> dict[str, str]:
|
||||
return {"backup_message": request.query_params.get("backup_message", ""), "backup_error": request.query_params.get("backup_error", "")}
|
||||
|
||||
|
||||
def vm_summary(name: str) -> dict[str, Any]:
|
||||
dominfo = run(["virsh", "dominfo", name], timeout=10)["stdout"]
|
||||
info = presenters.parse_dominfo(dominfo)
|
||||
return {"name": name, "info": info, "state": info["state"] or core.vm_state(name)}
|
||||
|
||||
|
||||
@router.get("/backups")
|
||||
def backups_page(request: Request):
|
||||
auth = core.require_auth(request)
|
||||
if auth:
|
||||
return auth
|
||||
items = list_backups()
|
||||
context = {
|
||||
"groups": group_by_vm(items, existing_vm_names()),
|
||||
"storage": storage_summary(items),
|
||||
"running": [op for op in core.running_operations() if op.get("type") in ("backup", "restore")],
|
||||
**page_messages(request),
|
||||
}
|
||||
return core.render(request, "backups.html", context)
|
||||
|
||||
|
||||
@router.post("/backups/{vm}/{backup_id}/delete")
|
||||
def backup_delete(request: Request, vm: str, backup_id: str, back_to: str = Form("", alias="next")):
|
||||
auth = core.require_auth(request)
|
||||
if auth:
|
||||
return auth
|
||||
back = back_to if back_to == f"/vm/{vm}/backups" and core.valid_vm_name(vm) else "/backups"
|
||||
try:
|
||||
delete_backup(vm, backup_id)
|
||||
except BackupError as exc:
|
||||
return core.redirect_with_message(back, "backup_error", str(exc))
|
||||
return core.redirect_with_message(back, "backup_message", f"Копия от {format_backup_date(backup_id)} удалена")
|
||||
|
||||
|
||||
def restore_form(request: Request, backup: dict[str, Any], name: str, exists: bool, error: str = "", status_code: int = 200):
|
||||
need = sum(int(disk.get("size") or 0) for disk in backup["disks"])
|
||||
context = {"backup": backup, "name": name, "exists": exists, "error": error, "need": format_bytes(need), "free": format_bytes(free_bytes(core.IMAGES_DIR)), "images_dir": str(core.IMAGES_DIR)}
|
||||
return core.render(request, "backup_restore.html", context, status_code=status_code)
|
||||
|
||||
|
||||
@router.get("/backups/{vm}/{backup_id}/restore")
|
||||
def backup_restore_page(request: Request, vm: str, backup_id: str):
|
||||
auth = core.require_auth(request)
|
||||
if auth:
|
||||
return auth
|
||||
backup = read_backup(vm, backup_id)
|
||||
if not backup:
|
||||
return core.redirect_with_message("/backups", "backup_error", "Копия не найдена")
|
||||
return restore_form(request, backup, vm, core.vm_exists(vm))
|
||||
|
||||
|
||||
@router.post("/backups/{vm}/{backup_id}/restore")
|
||||
def backup_restore_submit(request: Request, vm: str, backup_id: str, name: str = Form(""), replace: str = Form("")):
|
||||
auth = core.require_auth(request)
|
||||
if auth:
|
||||
return auth
|
||||
backup = read_backup(vm, backup_id)
|
||||
if not backup:
|
||||
return core.redirect_with_message("/backups", "backup_error", "Копия не найдена")
|
||||
name = (name or "").strip() or vm
|
||||
try:
|
||||
operation = start_restore(vm, backup_id, name, replace == "1")
|
||||
except BackupError as exc:
|
||||
exists = exc.code == "exists" or (core.valid_vm_name(name) and core.vm_exists(name))
|
||||
return restore_form(request, backup, name, exists, str(exc), status_code=400)
|
||||
return RedirectResponse(url=f"/operations/{operation['id']}", status_code=303)
|
||||
|
||||
|
||||
@router.get("/vm/{name}/backups")
|
||||
def vm_backups_page(request: Request, name: str):
|
||||
auth = core.require_auth(request)
|
||||
if auth:
|
||||
return auth
|
||||
if not core.valid_vm_name(name) or not core.vm_exists(name):
|
||||
return RedirectResponse(url="/", status_code=303)
|
||||
items = list_backups(name)
|
||||
context = {"vm": vm_summary(name), "backups": items, "storage": storage_summary(), "active": active_operation(name), **page_messages(request)}
|
||||
return core.render(request, "vm_backups.html", context)
|
||||
|
||||
|
||||
@router.post("/vm/{name}/backups/create")
|
||||
def vm_backup_create(request: Request, name: str, note: str = Form("")):
|
||||
auth = core.require_auth(request)
|
||||
if auth:
|
||||
return auth
|
||||
if not core.valid_vm_name(name):
|
||||
return RedirectResponse(url="/", status_code=303)
|
||||
try:
|
||||
operation = create_backup(name, note)
|
||||
except BackupError as exc:
|
||||
return core.redirect_with_message(f"/vm/{name}/backups", "backup_error", str(exc))
|
||||
return RedirectResponse(url=f"/operations/{operation['id']}", status_code=303)
|
||||
|
||||
|
||||
if __name__ == "__main__": # python3 web/features/backups.py <машина> [заметка]
|
||||
try:
|
||||
finished = create_backup(sys.argv[1], " ".join(sys.argv[2:]), wait=True)
|
||||
except (IndexError, BackupError) as error:
|
||||
print(f"Ошибка: {error or 'укажите имя машины'}")
|
||||
sys.exit(2)
|
||||
print(f"{finished['status']}: {finished['message']}")
|
||||
sys.exit(0 if finished["status"] == "success" else 1)
|
||||
Ссылка в новой задаче
Block a user
© 2026 StackWorks