lts-backup-cli 2.0.0__py3-none-any.whl

lts_backup_cli/wizard.py

@@ -0,0 +1,419 @@
+"""Interactive `discover` flow. Prompts go through an Asker so answers can be preset or scripted."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from pathlib import Path
+from typing import Any, Callable, Protocol
+
+from . import apache, sshconfig
+from . import config as c
+from . import schedule as sch
+from . import validation as v
+from .services import DiscoverRequest, DiscoverService, Echo
+
+Validator = Callable[[str], Any]
+
+NONE = "(none - use ssh defaults)"
+ALL = "(all)"  # checkbox preset: every choice offered
+OTHER = "(other path...)"
+
+
+class WizardError(RuntimeError):
+    pass
+
+
+class Asker(Protocol):
+    def text(
+        self, key: str, message: str, default: str = "", validate: Validator | None = None
+    ) -> str: ...
+    def password(self, key: str, message: str) -> str: ...
+    def confirm(self, key: str, message: str, default: bool = True) -> bool: ...
+    def select(
+        self, key: str, message: str, choices: Sequence[str], default: str | None = None
+    ) -> str: ...
+    def checkbox(
+        self, key: str, message: str, choices: Mapping[str, str], defaults: Sequence[str] = ()
+    ) -> list[str]: ...
+
+
+def _checked(validate: Validator | None, value: str) -> str:
+    return str(validate(value)) if validate else value
+
+
+class ScriptedAsker:
+    """Answers from a dict; falls back to defaults. Used by --non-interactive and tests."""
+
+    def __init__(self, answers: Mapping[str, Any]) -> None:
+        self.answers = dict(answers)
+
+    def _get(self, key: str, default: Any) -> Any:
+        if key in self.answers:
+            return self.answers[key]
+        wildcard = "*." + key.split(".", 1)[1] if "." in key else None
+        if wildcard in self.answers:  # "*.every_hours" answers it for every repo
+            return self.answers[wildcard]
+        if default is None or default == "":
+            raise WizardError(f"missing value for '{key}' (required in non-interactive mode)")
+        return default
+
+    def text(
+        self, key: str, message: str, default: str = "", validate: Validator | None = None
+    ) -> str:
+        return _checked(validate, str(self._get(key, default)))
+
+    def password(self, key: str, message: str) -> str:
+        return str(self._get(key, None))
+
+    def confirm(self, key: str, message: str, default: bool = True) -> bool:
+        return bool(self._get(key, default))
+
+    def select(
+        self, key: str, message: str, choices: Sequence[str], default: str | None = None
+    ) -> str:
+        return str(self._get(key, default))
+
+    def checkbox(
+        self, key: str, message: str, choices: Mapping[str, str], defaults: Sequence[str] = ()
+    ) -> list[str]:
+        raw = self.answers.get(key, defaults)
+        picked = list(choices) if raw == ALL else list(raw)
+        unknown = [x for x in picked if x not in choices]
+        if unknown:
+            raise WizardError(
+                f"{key}: unknown choice(s) {', '.join(unknown)} (have: {', '.join(choices)})"
+            )
+        return picked
+
+
+class QuestionaryAsker:
+    """Interactive prompts; any preset answer (from CLI options) skips its prompt."""
+
+    def __init__(self, presets: Mapping[str, Any] | None = None) -> None:
+        self.presets = ScriptedAsker(presets or {})
+
+    def _has(self, key: str) -> bool:
+        wildcard = "*." + key.split(".", 1)[1] if "." in key else None
+        return key in self.presets.answers or wildcard in self.presets.answers
+
+    @staticmethod
+    def _ask(question: Any) -> Any:
+        ans = question.ask()
+        if ans is None:  # Ctrl-C / Ctrl-D
+            raise KeyboardInterrupt
+        return ans
+
+    def text(
+        self, key: str, message: str, default: str = "", validate: Validator | None = None
+    ) -> str:
+        if self._has(key):
+            return self.presets.text(key, message, default, validate)
+        import questionary
+
+        def qv(s: str) -> Any:
+            if not validate:
+                return True
+            try:
+                validate(s)
+                return True
+            except v.ValidationError as e:
+                return str(e)
+
+        return _checked(
+            validate, self._ask(questionary.text(message, default=default, validate=qv))
+        )
+
+    def password(self, key: str, message: str) -> str:
+        if self._has(key):
+            return self.presets.password(key, message)
+        import questionary
+
+        while True:
+            first = self._ask(questionary.password(message))
+            if not first:
+                print("  password must not be empty")
+                continue
+            if self._ask(questionary.password("Repeat password:")) == first:
+                return str(first)
+            print("  passwords do not match, try again")
+
+    def confirm(self, key: str, message: str, default: bool = True) -> bool:
+        if self._has(key):
+            return self.presets.confirm(key, message, default)
+        import questionary
+
+        return bool(self._ask(questionary.confirm(message, default=default)))
+
+    def select(
+        self, key: str, message: str, choices: Sequence[str], default: str | None = None
+    ) -> str:
+        if self._has(key):
+            return self.presets.select(key, message, choices, default)
+        import questionary
+
+        return str(self._ask(questionary.select(message, choices=list(choices), default=default)))
+
+    def checkbox(
+        self, key: str, message: str, choices: Mapping[str, str], defaults: Sequence[str] = ()
+    ) -> list[str]:
+        if self._has(key):
+            return self.presets.checkbox(key, message, choices, defaults)
+        import questionary
+
+        qchoices = [
+            questionary.Choice(title, value=val, checked=val in defaults)
+            for val, title in choices.items()
+        ]
+        return list(self._ask(questionary.checkbox(message, choices=qchoices)))
+
+
+def _int_ge0(s: str) -> int:
+    try:
+        n = int(s)
+    except ValueError:
+        raise v.ValidationError(f"not a number: {s!r}") from None
+    v.keep(n)
+    return n
+
+
+def _identity(ask: Asker, key: str, default: str | None) -> str | None:
+    keys = sorted(
+        str(p) for p in (Path.home() / ".ssh").glob("id_*") if p.suffix != ".pub" and p.is_file()
+    )
+    choice = ask.select(
+        key,
+        "SSH private key (admin box -> server):",
+        [*keys, NONE, OTHER],
+        default=default if default in keys else (keys[0] if keys else NONE),
+    )
+    if choice == OTHER:
+        choice = ask.text(f"{key}_path", "Path to private key:")
+    return None if choice == NONE else v.abs_path(choice, must_exist=True, kind="file")
+
+
+def _connection(
+    ask: Asker, host: str, label: str, old: c.ServerConfig | None, ssh_text: str
+) -> c.ServerConfig:
+    storage_old = old.storage if old else None
+    alias = host in sshconfig.defined_hosts(ssh_text) or (old is not None and old.use_ssh_config)
+    use_alias = host == "localhost" or (
+        alias
+        and ask.confirm("use_ssh_config", f"Use your ~/.ssh/config entry '{host}' as is?", True)
+    )
+    user, port, identity = None, 22, None
+    if not use_alias:
+        user = ask.text(
+            "ssh_user", "SSH user on the server:", (old and old.ssh_user) or "", v.unix_user
+        )
+        port = int(ask.text("ssh_port", "SSH port:", str(old.ssh_port if old else 22), v.port))
+        identity = _identity(ask, "identity", old.ssh_identity if old else None)
+    st_identity = ask.text(
+        "storage_identity",
+        "Private key ON THE SERVER for the storage host (empty = server's default keys):",
+        (storage_old and storage_old.identity) or "-",
+    ).strip()
+    storage = c.StorageConfig(
+        host=ask.text("storage_host", "Storage (SFTP) host, as seen from the server:",
+                      storage_old.host if storage_old else "", v.hostname),
+        user=ask.text("storage_user", "Storage SSH user:",
+                      storage_old.user if storage_old else "", v.unix_user),
+        port=int(ask.text("storage_port", "Storage SSH port:",
+                          str(storage_old.port if storage_old else 22), v.port)),
+        base_path=ask.text("storage_path", "Base path on the storage host:",
+                           storage_old.base_path if storage_old else "/srv/restic", v.remote_path),
+        identity=None if st_identity in ("", "-") else v.remote_abs_path(st_identity),
+    )  # fmt: skip
+    return c.ServerConfig(
+        label=label,
+        ssh_host=host,
+        ssh_user=user,
+        use_ssh_config=use_alias and host != "localhost",
+        ssh_port=port,
+        ssh_identity=identity,
+        secrets_dir=old.secrets_dir if old else "/",  # set from the probed home below
+        storage=storage,
+        db_login=old.db_login if old else False,
+        repos=dict(old.repos) if old else {},
+    )
+
+
+def _db_login(
+    ask: Asker, svc: DiscoverService, runner: Any, server: c.ServerConfig, echo: Echo
+) -> list[str] | None:
+    if not ask.confirm(
+        "db_login",
+        f"No working MariaDB login on {server.label}. Enter the admin (sa) login now?",
+        True,
+    ):
+        return None
+    for _ in range(3):
+        user = ask.text("db_user", "MariaDB admin user:", "root", v.db_user)
+        if svc.set_db_login(runner, server, user, ask.password("db_password", "MariaDB password:")):
+            echo(f"MariaDB login verified and saved to {server.label}:{server.mycnf_path} (0600)")
+            return svc.databases(runner, server)[0]
+        echo("  MariaDB login failed, try again")
+    echo(f"warning: no working MariaDB login; database backups skipped for {server.label}")
+    return None
+
+
+def _folder_name(path: str) -> str:
+    return apache.repo_name_for(path.strip("/").replace("/", "-") or "root")
+
+
+def _tune(ask: Asker, repo: c.RepoConfig) -> None:
+    n, s, k = repo.name, repo.schedule, repo.keep
+    s.every_hours = int(
+        ask.text(
+            f"{n}.every_hours", f"[{n}] backup every N hours:", str(s.every_hours), v.every_hours
+        )
+    )
+    s.weekly_day = ask.text(f"{n}.weekly_day", f"[{n}] weekly run day:", s.weekly_day, v.weekday)
+    s.weekly_time = ask.text(
+        f"{n}.weekly_time", f"[{n}] weekly run time (HH:MM):", s.weekly_time, v.hhmm
+    )
+    for attr in ("hourly", "daily", "weekly", "monthly"):
+        cur = getattr(k, attr)
+        val = ask.text(
+            f"{n}.keep_{attr}",
+            f"[{n}] keep {attr} snapshots:",
+            "" if cur is None else str(cur),
+            _int_ge0,
+        )
+        setattr(k, attr, int(val))
+
+
+def run(
+    ask: Asker, svc: DiscoverService, cfg: c.Config, host: str, label: str, echo: Echo
+) -> DiscoverRequest:
+    host = v.hostname(host)
+    known = next((s.label for s in cfg.servers.values() if s.ssh_host == host), None)
+    label = label or ask.text(
+        "server", "Server label:", known or v.label(host.split(".")[0]), v.label
+    )
+    old = cfg.servers.get(label)
+    echo(f"{'editing' if old else 'new'} server {label} ({host})")
+    server = _connection(ask, host, label, old, sshconfig.read(svc.ssh_config_path))
+
+    runner = svc.connect(server)
+    found = svc.probe(runner, server)
+    if not old:
+        server.secrets_dir = f"{found.home}/.config/ltsbu"
+    databases = (
+        found.databases
+        if found.databases is not None
+        else _db_login(ask, svc, runner, server, echo)
+    )
+    for name in found.skipped_databases:
+        echo(f"warning: database {name!r} has characters ltsbu does not handle; skipped")
+
+    existing = {r.name: r for r in server.repos.values()}
+    wanted: dict[str, c.RepoConfig] = {}
+    pw_dir = c.config_dir() / "servers" / label
+
+    def new_repo(name: str, kind: str, **kw: Any) -> c.RepoConfig:
+        return existing.get(name) or c.RepoConfig(
+            name=name, kind=kind, password_file=str(pw_dir / f"{name}.pass"), **kw
+        )
+
+    # --- vhosts ---
+    vhosts = {apache.repo_name_for(h.server_name): h for h in found.vhosts}
+    choices = {n: f"{h.server_name}  ({h.document_root})" for n, h in vhosts.items()}
+    choices |= {
+        n: f"{r.vhost}  ({', '.join(r.paths)}) [configured]"
+        for n, r in existing.items()
+        if r.kind == "vhost" and n not in choices
+    }
+    defaults = [n for n in choices if n in existing] if old else list(choices)
+    for n in ask.checkbox(
+        "vhosts", "Apache/httpd vhosts to back up (one repo each):", choices, defaults
+    ):
+        h = vhosts.get(n)
+        wanted[n] = new_repo(
+            n, "vhost", vhost=h.server_name if h else None, paths=[h.document_root] if h else []
+        )
+        if h:  # docroot may have moved since last discover
+            wanted[n].paths = [h.document_root]
+
+    # --- databases (one repo per server) ---
+    if databases is not None:
+        current = existing["db"].databases if "db" in existing else []
+        db_choices = {d: d for d in sorted({*databases, *current})}
+        picked = ask.checkbox(
+            "databases",
+            "MariaDB databases to back up (repo 'db'):",
+            db_choices,
+            current if old else list(db_choices),
+        )
+        if picked:
+            wanted["db"] = new_repo("db", "db")
+            wanted["db"].databases = sorted(picked)
+    elif "db" in existing:
+        echo("warning: cannot list databases; keeping repo 'db' unchanged")
+        wanted["db"] = existing["db"]
+
+    # --- extra folders (one repo each) ---
+    folder_paths = [p for r in existing.values() if r.kind == "folder" for p in r.paths]
+    raw = ask.text(
+        "folders",
+        "Extra folders on the server (space separated, empty for none):",
+        " ".join(folder_paths) or "-",
+    )
+    for path in (p for p in raw.split() if p != "-"):
+        path = v.remote_abs_path(path)
+        n = _folder_name(path)
+        wanted[n] = new_repo(n, "folder", paths=[path])
+
+    # --- schedule & retention ---
+    taken = {
+        (r.schedule.weekly_day, r.schedule.weekly_time)
+        for s in cfg.servers.values()
+        if s.storage.host == server.storage.host and s.label != label
+        for r in s.repos.values()
+    } | {
+        (r.schedule.weekly_day, r.schedule.weekly_time)
+        for r in wanted.values()
+        if r.name in existing
+    }
+    for repo in sorted(wanted.values(), key=lambda r: r.name):
+        if repo.name not in existing:
+            repo.schedule = sch.default_schedule(label, repo.name, taken)
+            taken.add((repo.schedule.weekly_day, repo.schedule.weekly_time))
+    if wanted and ask.confirm(
+        "customize",
+        "Customise schedule/retention per repo? (default: every 2h + weekly, rotated)",
+        False,
+    ):
+        for repo in sorted(wanted.values(), key=lambda r: r.name):
+            _tune(ask, repo)
+
+    # --- removals need an explicit yes; restic data is never deleted ---
+    removed = sorted(set(existing) - set(wanted))
+    if removed and not ask.confirm(
+        "confirm_remove", f"Stop backing up {', '.join(removed)}? (restic data is kept)", False
+    ):
+        wanted |= {n: existing[n] for n in removed}
+        removed = []
+    server.repos = dict(sorted(wanted.items()))
+
+    echo(
+        f"\nserver {label}: {len(server.repos)} repo(s) -> {server.storage.host}:{server.storage.base_path}/{label}/"
+    )
+    for r in server.repos.values():
+        what = ", ".join(r.databases or r.paths)
+        echo(
+            f"  {r.name:<24} {r.kind:<6} {what}  [every {r.schedule.every_hours}h, weekly {r.schedule.weekly_day} {r.schedule.weekly_time}]"
+        )
+    for n in removed:
+        echo(f"  {n:<24} REMOVE (timers off, restic data kept)")
+    actions = ask.checkbox(
+        "actions",
+        "Actions:",
+        {
+            "restic_init": "Initialise missing restic repositories",
+            "timers": "Install/refresh systemd timers",
+        },
+        defaults=["restic_init", "timers"],
+    )
+    if not ask.confirm("apply", "Apply?", True):
+        raise WizardError("aborted")
+    return DiscoverRequest(server, removed, "restic_init" in actions, "timers" in actions)