backups: implement list the easy way

clanModules/borgbackup.nix

@@ -1,4 +1,4 @@
-{ config, lib, ... }:
+{ config, lib, pkgs, ... }:
 let
   cfg = config.clan.borgbackup;
 in
@@ -19,7 +19,7 @@ in
           };
           rsh = lib.mkOption {
             type = lib.types.str;
-            default = "";
+            default = "ssh -i ${config.clanCore.secrets.borgbackup.secrets."borgbackup.ssh".path} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null";
             description = "the rsh to use for the backup";
           };
 
@@ -55,15 +55,23 @@ in
       })
       cfg.destinations;
 
+    clanCore.secrets.borgbackup = {
+      facts."borgbackup.ssh.pub" = { };
+      secrets."borgbackup.ssh" = { };
+      generator.path = [ pkgs.openssh pkgs.coreutils ];
+      generator.script = ''
+        ssh-keygen -t ed25519 -N "" -f "$secrets"/borgbackup.ssh
+        mv "$secrets"/borgbackup.ssh.pub "$facts"/borgbackup.ssh.pub
+      '';
+    };
+
     clanCore.backups.providers.borgbackup = {
       list = ''
-        ${lib.concatMapStringsSep "\n" (dest: ''
+        ssh ${config.clan.networking.deploymentAddress} -- '
-          (
+          ${lib.concatMapStringsSep "\n" (dest: ''
-            export BORG_REPO=${lib.escapeShellArg dest.repo}
+            borg-job-${dest.name} list --json
-            export BORG_RSH=${lib.escapeShellArg dest.rsh}
+          '') (lib.attrValues cfg.destinations)}
-            ${lib.getExe config.services.borgbackup.package} list
+        '
-          )
-        '') (lib.attrValues cfg.destinations)}
       '';
       start = ''
         ssh ${config.clan.networking.deploymentAddress} -- '

nixosModules/clanCore/backups.nix

@@ -54,7 +54,7 @@
           };
         };
       }));
-      default = [ ];
+      default = { };
       description = ''
         Configured backup providers which are used by this machine
       '';

pkgs/clan-cli/clan_cli/backups/list.py

@@ -1,57 +1,47 @@
 import argparse
-import pprint
+import json
-from pathlib import Path
+import subprocess
+from typing import Any
 
 from ..errors import ClanError
+from ..machines.machines import Machine
 
 
-def list_backups(
+def list_backups(machine: Machine, provider: str | None = None) -> list[dict[str, Any]]:
-    flake_dir: Path, machine: str, provider: str | None = None
+    backup_scripts = json.loads(
-) -> dict[str, dict[str, list[dict[str, str]]]]:
+        machine.eval_nix(f"nixosConfigurations.{machine.name}.config.clanCore.backups")
-    dummy_data = {
+    )
-        "testhostname": {
+    results = []
-            "borgbackup": [
+    if provider is None:
-                {"date": "2021-01-01T00:00:00Z", "id": "1"},
+        for provider in backup_scripts["providers"]:
-                {"date": "2022-01-01T00:00:00Z", "id": "2"},
+            proc = subprocess.run(
-                {"date": "2023-01-01T00:00:00Z", "id": "3"},
+                ["bash", "-c", backup_scripts["providers"][provider]["list"]],
-            ],
+                stdout=subprocess.PIPE,
-            "restic": [
+            )
-                {"date": "2021-01-01T00:00:00Z", "id": "1"},
+            if proc.returncode != 0:
-                {"date": "2022-01-01T00:00:00Z", "id": "2"},
+                # TODO this should be a warning, only raise exception if no providers succeed
-                {"date": "2023-01-01T00:00:00Z", "id": "3"},
+                raise ClanError("failed to list backups")
-            ],
+            else:
-        },
+                results.append(proc.stdout)
-        "another host": {
-            "borgbackup": [
-                {"date": "2021-01-01T00:00:00Z", "id": "1"},
-                {"date": "2022-01-01T00:00:00Z", "id": "2"},
-                {"date": "2023-01-01T00:00:00Z", "id": "3"},
-            ],
-        },
-    }
-
-    if provider is not None:
-        new_data = {}
-        for machine_ in dummy_data:
-            if provider in dummy_data[machine_]:
-                new_data[machine_] = {provider: dummy_data[machine_][provider]}
-        dummy_data = new_data
-
-    if machine is None:
-        return dummy_data
     else:
-        return {machine: dummy_data[machine]}
+        if provider not in backup_scripts["providers"]:
+            raise ClanError(f"provider {provider} not found")
+        proc = subprocess.run(
+            ["bash", "-c", backup_scripts["providers"][provider]["list"]],
+            stdout=subprocess.PIPE,
+        )
+        if proc.returncode != 0:
+            raise ClanError("failed to list backup")
+        else:
+            results.append(proc.stdout)
+
+    return list(map(json.loads, results))
 
 
 def list_command(args: argparse.Namespace) -> None:
-    if args.flake is None:
+    machine = Machine(name=args.machine, flake_dir=args.flake)
-        raise ClanError("Could not find clan flake toplevel directory")
+    backups_data = list_backups(machine=machine, provider=args.provider)
-    backups = list_backups(
+    print(list(backups_data))
-        Path(args.flake), machine=args.machine, provider=args.provider
-    )
-    if len(backups) > 0:
-        pp = pprint.PrettyPrinter(depth=4)
-        pp.pprint(backups)
 
 
 def register_list_parser(parser: argparse.ArgumentParser) -> None:

pkgs/clan-cli/tests/test_backups.py

@@ -1,22 +1,20 @@
-import logging
+import pytest
-
 from cli import Cli
 from fixtures_flakes import FlakeForTest
 
-log = logging.getLogger(__name__)
-
 
+@pytest.mark.impure
 def test_backups(
-    test_flake: FlakeForTest,
+    test_flake_with_core: FlakeForTest,
 ) -> None:
     cli = Cli()
 
     cli.run(
         [
             "--flake",
-            str(test_flake.path),
+            str(test_flake_with_core.path),
             "backups",
             "list",
-            "testhostname",
+            "vm1",
         ]
     )