commit adcaf3962d5147cec7d63c1ff9e3f7a3fe4653d4 · pyrox.dev/nixpkgs

+14 -11

nixos/modules/services/backup/restic.nix

···

       113
       113
        
               };

     

       114
       114
        
       

     

       115
       115
        
               paths = mkOption {

     

       116
       116
       +
                 # This is nullable for legacy reasons only. We should consider making it a pure listOf

     

       117
       117
       +
                 # after some time has passed since this comment was added.

     

       116
       118
        
                 type = types.nullOr (types.listOf types.str);

     

       117
       117
       -
                 default = null;

     

       119
       119
       +
                 default = [ ];

     

       118
       120
        
                 description = lib.mdDoc ''

     

       119
       119
       -
                   Which paths to backup.  If null or an empty array, no

     

       120
       120
       -
                   backup command will be run.  This can be used to create a

     

       121
       121
       -
                   prune-only job.

     

       121
       121
       +
                   Which paths to backup, in addition to ones specified via

     

       122
       122
       +
                   `dynamicFilesFrom`.  If null or an empty array and

     

       123
       123
       +
                   `dynamicFilesFrom` is also null, no backup command will be run.

     

       124
       124
       +
                    This can be used to create a prune-only job.

     

       122
       125
        
                 '';

     

       123
       126
        
                 example = [

     

       124
       127
        
                   "/var/lib/postgresql"

     
···

       231
       234
        
                 description = lib.mdDoc ''

     

       232
       235
        
                   A script that produces a list of files to back up.  The

     

       233
       236
        
                   results of this command are given to the '--files-from'

     

       234
       234
       -
                   option.

     

       237
       237
       +
                   option. The result is merged with paths specified via `paths`.

     

       235
       238
        
                 '';

     

       236
       239
        
                 example = "find /home/matt/git -type d -name .git";

     

       237
       240
        
               };

     
···

       310
       313
        
                   resticCmd = "${backup.package}/bin/restic${extraOptions}";

     

       311
       314
        
                   excludeFlags = optional (backup.exclude != []) "--exclude-file=${pkgs.writeText "exclude-patterns" (concatStringsSep "\n" backup.exclude)}";

     

       312
       315
        
                   filesFromTmpFile = "/run/restic-backups-${name}/includes";

     

       313
       313
       -
                   backupPaths =

     

       314
       314
       -
                     if (backup.dynamicFilesFrom == null)

     

       315
       315
       -
                     then optionalString (backup.paths != null) (concatStringsSep " " backup.paths)

     

       316
       316
       -
                     else "--files-from ${filesFromTmpFile}";

     

       316
       316
       +
                   doBackup = (backup.dynamicFilesFrom != null) || (backup.paths != null && backup.paths != []);

     

       317
       317
        
                   pruneCmd = optionals (builtins.length backup.pruneOpts > 0) [

     

       318
       318
        
                     (resticCmd + " forget --prune " + (concatStringsSep " " backup.pruneOpts))

     

       319
       319
        
                     (resticCmd + " check " + (concatStringsSep " " backup.checkOpts))

     
···

       348
       348
        
                   after = [ "network-online.target" ];

     

       349
       349
        
                   serviceConfig = {

     

       350
       350
        
                     Type = "oneshot";

     

       351
       351
       -
                     ExecStart = (optionals (backupPaths != "") [ "${resticCmd} backup ${concatStringsSep " " (backup.extraBackupArgs ++ excludeFlags)} ${backupPaths}" ])

     

       351
       351
       +
                     ExecStart = (optionals doBackup [ "${resticCmd} backup ${concatStringsSep " " (backup.extraBackupArgs ++ excludeFlags)} --files-from=${filesFromTmpFile}" ])

     

       352
       352
        
                       ++ pruneCmd;

     

       353
       353
        
                     User = backup.user;

     

       354
       354
        
                     RuntimeDirectory = "restic-backups-${name}";

     
···

       366
       366
        
                     ${optionalString (backup.initialize) ''

     

       367
       367
        
                       ${resticCmd} snapshots || ${resticCmd} init

     

       368
       368
        
                     ''}

     

       369
       369
       +
                     ${optionalString (backup.paths != null && backup.paths != []) ''

     

       370
       370
       +
                       cat ${pkgs.writeText "staticPaths" (concatStringsSep "\n" backup.paths)} >> ${filesFromTmpFile}

     

       371
       371
       +
                     ''}

     

       369
       372
        
                     ${optionalString (backup.dynamicFilesFrom != null) ''

     

       370
       370
       -
                       ${pkgs.writeScript "dynamicFilesFromScript" backup.dynamicFilesFrom} > ${filesFromTmpFile}

     

       373
       373
       +
                       ${pkgs.writeScript "dynamicFilesFromScript" backup.dynamicFilesFrom} >> ${filesFromTmpFile}

     

       371
       374
        
                     ''}

     

       372
       375
        
                   '';

     

       373
       376
        
                 } // optionalAttrs (backup.dynamicFilesFrom != null || backup.backupCleanupCommand != null) {

+15 -3

nixos/tests/restic.nix

···

       21
       21
        
             unpackPhase = "true";

     

       22
       22
        
             installPhase = ''

     

       23
       23
        
               mkdir $out

     

       24
       24
       -
               touch $out/some_file

     

       24
       24
       +
               echo some_file > $out/some_file

     

       25
       25
       +
               echo some_other_file > $out/some_other_file

     

       26
       26
       +
               mkdir $out/a_dir

     

       27
       27
       +
               echo a_file > $out/a_dir/a_file

     

       25
       28
        
             '';

     

       26
       29
        
           };

     

       27
       30
        
       

     
···

       53
       56
        
                     initialize = true;

     

       54
       57
        
                   };

     

       55
       58
        
                   remote-from-file-backup = {

     

       56
       56
       -
                     inherit passwordFile paths exclude pruneOpts;

     

       59
       59
       +
                     inherit passwordFile exclude pruneOpts;

     

       57
       60
        
                     initialize = true;

     

       58
       61
        
                     repositoryFile = pkgs.writeText "repositoryFile" remoteFromFileRepository;

     

       62
       62
       +
                     paths = [ "/opt/a_dir" ];

     

       63
       63
       +
                     dynamicFilesFrom = ''

     

       64
       64
       +
                       find /opt -mindepth 1 -maxdepth 1 ! -name a_dir # all files in /opt except for a_dir

     

       65
       65
       +
                     '';

     

       59
       66
        
                   };

     

       60
       67
        
                   rclonebackup = {

     

       61
       68
        
                     inherit passwordFile paths exclude pruneOpts;

     
···

       123
       130
        
                 "systemctl start restic-backups-remote-from-file-backup.service",

     

       124
       131
        
                 'restic-remote-from-file-backup snapshots --json | ${pkgs.jq}/bin/jq "length | . == 1"',

     

       125
       132
        
       

     

       133
       133
       +
                 # test that restoring that snapshot produces the same directory

     

       134
       134
       +
                 "mkdir /tmp/restore-2",

     

       135
       135
       +
                 "${pkgs.restic}/bin/restic -r ${remoteRepository} -p ${passwordFile} restore latest -t /tmp/restore-2",

     

       136
       136
       +
                 "diff -ru ${testDir} /tmp/restore-2/opt",

     

       137
       137
       +
       

     

       126
       138
        
                 # test that rclonebackup produces a snapshot

     

       127
       139
        
                 "systemctl start restic-backups-rclonebackup.service",

     

       128
       140
        
                 'restic-rclonebackup snapshots --json | ${pkgs.jq}/bin/jq "length | . == 1"',

     

       129
       141
        
       

     

       130
       142
        
                 # test that custompackage runs both `restic backup` and `restic check` with reasonable commandlines

     

       131
       143
        
                 "systemctl start restic-backups-custompackage.service",

     

       132
       132
       -
                 "grep 'backup.* /opt' /root/fake-restic.log",

     

       144
       144
       +
                 "grep 'backup' /root/fake-restic.log",

     

       133
       145
        
                 "grep 'check.* --some-check-option' /root/fake-restic.log",

     

       134
       146
        
       

     

       135
       147
        
                 # test that we can create four snapshots in remotebackup and rclonebackup