commit 50eb816d2994682b3269205b5cf7a4bdeb4a482c · pyrox.dev/nixpkgs

+52 -50

nixos/modules/services/backup/btrbk.nix

···

       1
       1
        
       { config, pkgs, lib, ... }:

     

       2
       2
        
       let

     

       3
       3
        
         inherit (lib)

     

       4
       4
       +
           concatLists

     

       5
       5
       +
           concatMap

     

       4
       6
        
           concatMapStringsSep

     

       5
       7
        
           concatStringsSep

     

       6
       8
        
           filterAttrs

     

       7
       7
       -
           flatten

     

       8
       9
        
           isAttrs

     

       9
       9
       -
           isString

     

       10
       10
        
           literalExpression

     

       11
       11
        
           mapAttrs'

     

       12
       12
        
           mapAttrsToList

     

       13
       13
        
           mkIf

     

       14
       14
        
           mkOption

     

       15
       15
        
           optionalString

     

       16
       16
       -
           partition

     

       17
       17
       -
           typeOf

     

       16
       16
       +
           sort

     

       18
       17
        
           types

     

       19
       18
        
           ;

     

       20
       19
        
       

     

       21
       21
       -
         cfg = config.services.btrbk;

     

       22
       22
       -
         sshEnabled = cfg.sshAccess != [ ];

     

       23
       23
       -
         serviceEnabled = cfg.instances != { };

     

       24
       24
       -
         attr2Lines = attr:

     

       20
       20
       +
         # The priority of an option or section.

     

       21
       21
       +
         # The configurations format are order-sensitive. Pairs are added as children of

     

       22
       22
       +
         # the last sections if possible, otherwise, they start a new section.

     

       23
       23
       +
         # We sort them in topological order:

     

       24
       24
       +
         # 1. Leaf pairs.

     

       25
       25
       +
         # 2. Sections that may contain (1).

     

       26
       26
       +
         # 3. Sections that may contain (1) or (2).

     

       27
       27
       +
         # 4. Etc.

     

       28
       28
       +
         prioOf = { name, value }:

     

       29
       29
       +
           if !isAttrs value then 0 # Leaf options.

     

       30
       30
       +
           else {

     

       31
       31
       +
             target = 1; # Contains: options.

     

       32
       32
       +
             subvolume = 2; # Contains: options, target.

     

       33
       33
       +
             volume = 3; # Contains: options, target, subvolume.

     

       34
       34
       +
           }.${name} or (throw "Unknow section '${name}'");

     

       35
       35
       +
       

     

       36
       36
       +
         genConfig' = set: concatStringsSep "\n" (genConfig set);

     

       37
       37
       +
         genConfig = set:

     

       25
       38
        
           let

     

       26
       26
       -
             pairs = mapAttrsToList (name: value: { inherit name value; }) attr;

     

       27
       27
       -
             isSubsection = value:

     

       28
       28
       -
               if isAttrs value then true

     

       29
       29
       -
               else if isString value then false

     

       30
       30
       -
               else throw "invalid type in btrbk config ${typeOf value}";

     

       31
       31
       -
             sortedPairs = partition (x: isSubsection x.value) pairs;

     

       39
       39
       +
             pairs = mapAttrsToList (name: value: { inherit name value; }) set;

     

       40
       40
       +
             sortedPairs = sort (a: b: prioOf a < prioOf b) pairs;

     

       32
       41
        
           in

     

       33
       33
       -
           flatten (

     

       34
       34
       -
             # non subsections go first

     

       35
       35
       -
             (

     

       36
       36
       -
               map (pair: [ "${pair.name} ${pair.value}" ]) sortedPairs.wrong

     

       37
       37
       -
             )

     

       38
       38
       -
             ++ # subsections go last

     

       39
       39
       -
             (

     

       40
       40
       -
               map

     

       41
       41
       -
                 (

     

       42
       42
       -
                   pair:

     

       43
       43
       -
                   mapAttrsToList

     

       44
       44
       -
                     (

     

       45
       45
       -
                       childname: value:

     

       46
       46
       -
                         [ "${pair.name} ${childname}" ] ++ (map (x: " " + x) (attr2Lines value))

     

       47
       47
       -
                     )

     

       48
       48
       -
                     pair.value

     

       49
       49
       -
                 )

     

       50
       50
       -
                 sortedPairs.right

     

       51
       51
       -
             )

     

       52
       52
       -
           )

     

       53
       53
       -
         ;

     

       42
       42
       +
             concatMap genPair sortedPairs;

     

       43
       43
       +
         genSection = sec: secName: value:

     

       44
       44
       +
           [ "${sec} ${secName}" ] ++ map (x: " " + x) (genConfig value);

     

       45
       45
       +
         genPair = { name, value }:

     

       46
       46
       +
           if !isAttrs value

     

       47
       47
       +
           then [ "${name} ${value}" ]

     

       48
       48
       +
           else concatLists (mapAttrsToList (genSection name) value);

     

       49
       49
       +
       

     

       54
       50
        
         addDefaults = settings: { backend = "btrfs-progs-sudo"; } // settings;

     

       55
       55
       -
         mkConfigFile = settings: concatStringsSep "\n" (attr2Lines (addDefaults settings));

     

       56
       56
       -
         mkTestedConfigFile = name: settings:

     

       57
       57
       -
           let

     

       58
       58
       -
             configFile = pkgs.writeText "btrbk-${name}.conf" (mkConfigFile settings);

     

       59
       59
       -
           in

     

       60
       60
       -
           pkgs.runCommand "btrbk-${name}-tested.conf" { } ''

     

       61
       61
       -
             mkdir foo

     

       62
       62
       -
             cp ${configFile} $out

     

       63
       63
       -
             if (set +o pipefail; ${pkgs.btrbk}/bin/btrbk -c $out ls foo 2>&1 | grep $out);

     

       64
       64
       -
             then

     

       65
       65
       -
             echo btrbk configuration is invalid

     

       66
       66
       -
             cat $out

     

       67
       67
       -
             exit 1

     

       68
       68
       -
             fi;

     

       51
       51
       +
       

     

       52
       52
       +
         mkConfigFile = name: settings: pkgs.writeTextFile {

     

       53
       53
       +
           name = "btrbk-${name}.conf";

     

       54
       54
       +
           text = genConfig' (addDefaults settings);

     

       55
       55
       +
           checkPhase = ''

     

       56
       56
       +
             set +e

     

       57
       57
       +
             ${pkgs.btrbk}/bin/btrbk -c $out dryrun

     

       58
       58
       +
             # According to btrbk(1), exit status 2 means parse error

     

       59
       59
       +
             # for CLI options or the config file.

     

       60
       60
       +
             if [[ $? == 2 ]]; then

     

       61
       61
       +
               echo "Btrbk configuration is invalid:"

     

       62
       62
       +
               cat $out

     

       63
       63
       +
               exit 1

     

       64
       64
       +
             fi

     

       65
       65
       +
             set -e

     

       69
       66
        
           '';

     

       67
       67
       +
         };

     

       68
       68
       +
       

     

       69
       69
       +
         cfg = config.services.btrbk;

     

       70
       70
       +
         sshEnabled = cfg.sshAccess != [ ];

     

       71
       71
       +
         serviceEnabled = cfg.instances != { };

     

       70
       72
        
       in

     

       71
       73
        
       {

     

       72
       74
        
         meta.maintainers = with lib.maintainers; [ oxalica ];

     
···

       196
       198
        
             (

     

       197
       199
        
               name: instance: {

     

       198
       200
        
                 name = "btrbk/${name}.conf";

     

       199
       199
       -
                 value.source = mkTestedConfigFile name instance.settings;

     

       201
       201
       +
                 value.source = mkConfigFile name instance.settings;

     

       200
       202
        
               }

     

       201
       203
        
             )

     

       202
       204
        
             cfg.instances;

nixos/tests/all-tests.nix

···

       102
       102
        
         brscan5 = handleTest ./brscan5.nix {};

     

       103
       103
        
         btrbk = handleTest ./btrbk.nix {};

     

       104
       104
        
         btrbk-no-timer = handleTest ./btrbk-no-timer.nix {};

     

       105
       105
       +
         btrbk-section-order = handleTest ./btrbk-section-order.nix {};

     

       105
       106
        
         buildbot = handleTest ./buildbot.nix {};

     

       106
       107
        
         buildkite-agents = handleTest ./buildkite-agents.nix {};

     

       107
       108
        
         caddy = handleTest ./caddy.nix {};

+51

nixos/tests/btrbk-section-order.nix

···

       1
       1
       +
       # This tests validates the order of generated sections that may contain

     

       2
       2
       +
       # other sections.

     

       3
       3
       +
       # When a `volume` section has both `subvolume` and `target` children,

     

       4
       4
       +
       # `target` must go before `subvolume`. Otherwise, `target` will become

     

       5
       5
       +
       # a child of the last `subvolume` instead of `volume`, due to the

     

       6
       6
       +
       # order-sensitive config format.

     

       7
       7
       +
       #

     

       8
       8
       +
       # Issue: https://github.com/NixOS/nixpkgs/issues/195660

     

       9
       9
       +
       import ./make-test-python.nix ({ lib, pkgs, ... }: {

     

       10
       10
       +
         name = "btrbk-section-order";

     

       11
       11
       +
         meta.maintainers = with lib.maintainers; [ oxalica ];

     

       12
       12
       +
       

     

       13
       13
       +
         nodes.machine = { ... }: {

     

       14
       14
       +
           services.btrbk.instances.local = {

     

       15
       15
       +
             onCalendar = null;

     

       16
       16
       +
             settings = {

     

       17
       17
       +
               timestamp_format = "long";

     

       18
       18
       +
               target."ssh://global-target/".ssh_user = "root";

     

       19
       19
       +
               volume."/btrfs" = {

     

       20
       20
       +
                 snapshot_dir = "/volume-snapshots";

     

       21
       21
       +
                 target."ssh://volume-target/".ssh_user = "root";

     

       22
       22
       +
                 subvolume."@subvolume" = {

     

       23
       23
       +
                   snapshot_dir = "/subvolume-snapshots";

     

       24
       24
       +
                   target."ssh://subvolume-target/".ssh_user = "root";

     

       25
       25
       +
                 };

     

       26
       26
       +
               };

     

       27
       27
       +
             };

     

       28
       28
       +
           };

     

       29
       29
       +
         };

     

       30
       30
       +
       

     

       31
       31
       +
         testScript = ''

     

       32
       32
       +
           machine.wait_for_unit("basic.target")

     

       33
       33
       +
           got = machine.succeed("cat /etc/btrbk/local.conf")

     

       34
       34
       +
           expect = """

     

       35
       35
       +
           backend btrfs-progs-sudo

     

       36
       36
       +
           timestamp_format long

     

       37
       37
       +
           target ssh://global-target/

     

       38
       38
       +
            ssh_user root

     

       39
       39
       +
           volume /btrfs

     

       40
       40
       +
            snapshot_dir /volume-snapshots

     

       41
       41
       +
            target ssh://volume-target/

     

       42
       42
       +
             ssh_user root

     

       43
       43
       +
            subvolume @subvolume

     

       44
       44
       +
             snapshot_dir /subvolume-snapshots

     

       45
       45
       +
             target ssh://subvolume-target/

     

       46
       46
       +
              ssh_user root

     

       47
       47
       +
           """.strip()

     

       48
       48
       +
           print(got)

     

       49
       49
       +
           assert got == expect

     

       50
       50
       +
         '';

     

       51
       51
       +
       })