Merge pull request 'localbackup: add regression test' (#1035) from localbackup into main

checks/backups/flake-module.nix

@@ -30,6 +30,7 @@
       {
         imports = [
           self.clanModules.borgbackup
+          self.clanModules.localbackup
           self.clanModules.sshd
         ];
         clan.networking.targetHost = "machine";
@@ -102,6 +103,26 @@
         };
         clan.borgbackup.destinations.test-backup.repo = "borg@machine:.";
 
+        fileSystems."/mnt/external-disk" = {
+          device = "/dev/vdb"; # created in tests with virtualisation.emptyDisks
+          autoFormat = true;
+          fsType = "ext4";
+          options = [
+            "defaults"
+            "noauto"
+          ];
+        };
+
+        clan.localbackup.targets.hdd = {
+          directory = "/mnt/external-disk";
+          mountHook = ''
+            touch /run/mount-external-disk
+          '';
+          unmountHook = ''
+            touch /run/unmount-external-disk
+          '';
+        };
+
         services.borgbackup.repos.test-backups = {
           path = "/var/lib/borgbackup/test-backups";
           authorizedKeys = [ (builtins.readFile ../lib/ssh/pubkey) ];
@@ -114,10 +135,13 @@
       checks = pkgs.lib.mkIf (pkgs.stdenv.isLinux) {
         test-backups = (import ../lib/test-base.nix) {
           name = "test-backups";
-          nodes.machine.imports = [
-            self.nixosModules.clanCore
-            self.nixosModules.test-backup
-          ];
+          nodes.machine = {
+            imports = [
+              self.nixosModules.clanCore
+              self.nixosModules.test-backup
+            ];
+            virtualisation.emptyDiskImages = [ 256 ];
+          };
 
           testScript = ''
             import json
@@ -130,16 +154,27 @@
             # create
             machine.succeed("clan --debug --flake ${self} backups create test-backup")
             machine.wait_until_succeeds("! systemctl is-active borgbackup-job-test-backup >&2")
+            machine.succeed("test -f /run/mount-external-disk")
+            machine.succeed("test -f /run/unmount-external-disk")
 
             # list
             backup_id = json.loads(machine.succeed("borg-job-test-backup list --json"))["archives"][0]["archive"]
             out = machine.succeed("clan --debug --flake ${self} backups list test-backup").strip()
             print(out)
             assert backup_id in out, f"backup {backup_id} not found in {out}"
+            localbackup_id = "hdd::/mnt/external-disk/snapshot.0"
+            assert localbackup_id in out, "localbackup not found in {out}"
 
-            # restore
+            ## borgbackup restore
             machine.succeed("rm -f /var/test-backups/somefile")
-            machine.succeed(f"clan --debug --flake ${self} backups restore test-backup borgbackup {out} >&2")
+            machine.succeed(f"clan --debug --flake ${self} backups restore test-backup borgbackup 'test-backup::borg@machine:.::{backup_id}' >&2")
+            assert machine.succeed("cat /var/test-backups/somefile").strip() == "testing", "restore failed"
+            machine.succeed("test -f /var/test-service/pre-restore-command")
+            machine.succeed("test -f /var/test-service/post-restore-command")
+
+            ## localbackup restore
+            machine.succeed("rm -f /var/test-backups/somefile /var/test-service/{pre,post}-restore-command")
+            machine.succeed(f"clan --debug --flake ${self} backups restore test-backup localbackup '{localbackup_id}' >&2")
             assert machine.succeed("cat /var/test-backups/somefile").strip() == "testing", "restore failed"
             machine.succeed("test -f /var/test-service/pre-restore-command")
             machine.succeed("test -f /var/test-service/post-restore-command")

clanModules/localbackup.nix

@@ -8,7 +8,7 @@ let
   cfg = config.clan.localbackup;
   rsnapshotConfig = target: states: ''
     config_version	1.2
-    snapshot_root	${target}
+    snapshot_root	${target.directory}
     sync_first	1
     cmd_cp	${pkgs.coreutils}/bin/cp
     cmd_rm	${pkgs.coreutils}/bin/rm
@@ -17,6 +17,19 @@ let
     cmd_logger	${pkgs.inetutils}/bin/logger
     cmd_du	${pkgs.coreutils}/bin/du
     cmd_rsnapshot_diff	${pkgs.rsnapshot}/bin/rsnapshot-diff
+    ${lib.optionalString (target.preBackupHook != null) ''
+      cmd_preexec	${pkgs.writeShellScript "preexec.sh" ''
+        set -efu -o pipefail
+        ${target.preBackupHook}
+      ''}
+    ''}
+
+    ${lib.optionalString (target.postBackupHook != null) ''
+      cmd_postexec	${pkgs.writeShellScript "postexec.sh" ''
+        set -efu -o pipefail
+        ${target.postBackupHook}
+      ''}
+    ''}
     retain	snapshot	${builtins.toString config.clan.localbackup.snapshots}
     ${lib.concatMapStringsSep "\n" (state: ''
       ${lib.concatMapStringsSep "\n" (folder: ''
@@ -34,7 +47,7 @@ in
           {
             options = {
               name = lib.mkOption {
-                type = lib.types.str;
+                type = lib.types.strMatching "^[a-zA-Z0-9._-]+$";
                 default = name;
                 description = "the name of the backup job";
               };
@@ -43,14 +56,35 @@ in
                 description = "the directory to backup";
               };
               mountpoint = lib.mkOption {
-                type = lib.types.nullOr (lib.types.strMatching "^[a-zA-Z0-9./_-]+$");
+                type = lib.types.nullOr lib.types.str;
                 default = null;
                 description = "mountpoint of the directory to backup. If set, the directory will be mounted before the backup and unmounted afterwards";
               };
+              mountHook = lib.mkOption {
+                type = lib.types.nullOr lib.types.lines;
+                default = if config.mountpoint != null then "mount ${config.mountpoint}" else null;
+                description = "Shell commands to run before the directory is mounted";
+              };
+              unmountHook = lib.mkOption {
+                type = lib.types.nullOr lib.types.lines;
+                default = if config.mountpoint != null then "umount ${config.mountpoint}" else null;
+                description = "Shell commands to run after the directory is unmounted";
+              };
+              preBackupHook = lib.mkOption {
+                type = lib.types.nullOr lib.types.lines;
+                default = null;
+                description = "Shell commands to run before the backup";
+              };
+              postBackupHook = lib.mkOption {
+                type = lib.types.nullOr lib.types.lines;
+                default = null;
+                description = "Shell commands to run after the backup";
+              };
             };
           }
         )
       );
+      default = { };
       description = "List of directories where backups are stored";
     };
 
@@ -63,83 +97,101 @@ in
 
   config =
     let
-      setupMount =
-        mountpoint:
-        lib.optionalString (mountpoint != null) ''
-          mkdir -p ${lib.escapeShellArg mountpoint}
-          if mountpoint -q ${lib.escapeShellArg mountpoint}; then
-            umount ${lib.escapeShellArg mountpoint}
-          fi
-          mount ${lib.escapeShellArg mountpoint}
-          trap "umount ${lib.escapeShellArg mountpoint}" EXIT
-        '';
+      mountHook = target: ''
+        if [[ -x /run/current-system/sw/bin/localbackup-mount-${target.name} ]]; then
+          /run/current-system/sw/bin/localbackup-mount-${target.name}
+        fi
+        if [[ -x /run/current-system/sw/bin/localbackup-unmount-${target.name} ]]; then
+          trap "/run/current-system/sw/bin/localbackup-unmount-${target.name}" EXIT
+        fi
+      '';
     in
-    lib.mkIf (cfg.targets != [ ]) {
-      environment.systemPackages = [
-        (pkgs.writeShellScriptBin "localbackup-create" ''
-          set -efu -o pipefail
-          export PATH=${
-            lib.makeBinPath [
-              pkgs.rsnapshot
-              pkgs.coreutils
-              pkgs.util-linux
-            ]
-          }
-          ${lib.concatMapStringsSep "\n" (target: ''
-            (
-              echo "Creating backup '${target.name}'"
-              ${setupMount target.mountpoint}
-              rsnapshot -c "${pkgs.writeText "rsnapshot.conf" (rsnapshotConfig target.directory (lib.attrValues config.clanCore.state))}" sync
-              rsnapshot -c "${pkgs.writeText "rsnapshot.conf" (rsnapshotConfig target.directory (lib.attrValues config.clanCore.state))}" snapshot
-            )
-          '') (builtins.attrValues cfg.targets)}
-        '')
-        (pkgs.writeShellScriptBin "localbackup-list" ''
-          set -efu -o pipefail
-          export PATH=${
-            lib.makeBinPath [
-              pkgs.jq
-              pkgs.findutils
-              pkgs.coreutils
-              pkgs.util-linux
-            ]
-          }
-          (${
-            lib.concatMapStringsSep "\n" (target: ''
+    lib.mkIf (cfg.targets != { }) {
+      environment.systemPackages =
+        [
+          (pkgs.writeShellScriptBin "localbackup-create" ''
+            set -efu -o pipefail
+            export PATH=${
+              lib.makeBinPath [
+                pkgs.rsnapshot
+                pkgs.coreutils
+                pkgs.util-linux
+              ]
+            }
+            ${lib.concatMapStringsSep "\n" (target: ''
               (
-                ${setupMount target.mountpoint}
-                find ${lib.escapeShellArg target.directory} -mindepth 1 -maxdepth 1 -name "snapshot.*" -print0 -type d \
-                  | jq -Rs 'split("\u0000") | .[] | select(. != "") | { "name": ("${target.mountpoint}::" + .)}'
+                ${mountHook target}
+                echo "Creating backup '${target.name}'"
+                rsnapshot -c "${pkgs.writeText "rsnapshot.conf" (rsnapshotConfig target (lib.attrValues config.clanCore.state))}" sync
+                rsnapshot -c "${pkgs.writeText "rsnapshot.conf" (rsnapshotConfig target (lib.attrValues config.clanCore.state))}" snapshot
               )
-            '') (builtins.attrValues cfg.targets)
-          }) | jq -s .
-        '')
-        (pkgs.writeShellScriptBin "localbackup-restore" ''
-          set -efu -o pipefail
-          export PATH=${
-            lib.makeBinPath [
-              pkgs.rsync
-              pkgs.coreutils
-              pkgs.util-linux
-              pkgs.gawk
-            ]
-          }
-          mountpoint=$(awk -F'::' '{print $1}' <<< $NAME)
-          backupname=''${NAME#$mountpoint::}
+            '') (builtins.attrValues cfg.targets)}
+          '')
+          (pkgs.writeShellScriptBin "localbackup-list" ''
+            set -efu -o pipefail
+            export PATH=${
+              lib.makeBinPath [
+                pkgs.jq
+                pkgs.findutils
+                pkgs.coreutils
+                pkgs.util-linux
+              ]
+            }
+            (${
+              lib.concatMapStringsSep "\n" (target: ''
+                (
+                  ${mountHook target}
+                  find ${lib.escapeShellArg target.directory} -mindepth 1 -maxdepth 1 -name "snapshot.*" -print0 -type d \
+                    | jq -Rs 'split("\u0000") | .[] | select(. != "") | { "name": ("${target.name}::" + .)}'
+                )
+              '') (builtins.attrValues cfg.targets)
+            }) | jq -s .
+          '')
+          (pkgs.writeShellScriptBin "localbackup-restore" ''
+            set -efu -o pipefail
+            export PATH=${
+              lib.makeBinPath [
+                pkgs.rsync
+                pkgs.coreutils
+                pkgs.util-linux
+                pkgs.gawk
+              ]
+            }
+            name=$(awk -F'::' '{print $1}' <<< $NAME)
+            backupname=''${NAME#$name::}
 
-          mkdir -p "$mountpoint"
-          if mountpoint -q "$mountpoint"; then
-            umount "$mountpoint"
-          fi
-          mount "$mountpoint"
-          trap "umount $mountpoint" EXIT
+            if command -v localbackup-mount-$name; then
+              localbackup-mount-$name
+            fi
+            if command -v localbackup-unmount-$name; then
+              trap "localbackup-unmount-$name" EXIT
+            fi
 
-          IFS=';' read -ra FOLDER <<< "$FOLDERS"
-          for folder in "''${FOLDER[@]}"; do
-            rsync -a "$backupname/${config.networking.hostName}$folder/" "$folder"
-          done
-        '')
-      ];
+            if [[ ! -d $backupname ]]; then
+              echo "No backup found $backupname"
+              exit 1
+            fi
+
+            IFS=';' read -ra FOLDER <<< "$FOLDERS"
+            for folder in "''${FOLDER[@]}"; do
+              rsync -a "$backupname/${config.networking.hostName}$folder/" "$folder"
+            done
+          '')
+        ]
+        ++ (lib.mapAttrsToList (
+          name: target:
+          pkgs.writeShellScriptBin ("localbackup-mount-" + name) ''
+            set -efu -o pipefail
+            ${target.mountHook}
+          ''
+        ) (lib.filterAttrs (_name: target: target.mountHook != null) cfg.targets))
+        ++ lib.mapAttrsToList (
+          name: target:
+          pkgs.writeShellScriptBin ("localbackup-unmount-" + name) ''
+            set -efu -o pipefail
+            ${target.unmountHook}
+          ''
+        ) (lib.filterAttrs (_name: target: target.unmountHook != null) cfg.targets);
 
       clanCore.backups.providers.localbackup = {
         # TODO list needs to run locally or on the remote machine