summary refs log tree commit diff
path: root/nixos/modules/services/backup/syncoid.nix
blob: 53787a0182af9dc09be3c5557cd6136e52df0778 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
{ config, lib, pkgs, ... }:

with lib;

let
  cfg = config.services.syncoid;
in {

    # Interface

    options.services.syncoid = {
      enable = mkEnableOption "Syncoid ZFS synchronization service";

      interval = mkOption {
        type = types.str;
        default = "hourly";
        example = "*-*-* *:15:00";
        description = ''
          Run syncoid at this interval. The default is to run hourly.

          The format is described in
          <citerefentry><refentrytitle>systemd.time</refentrytitle>
          <manvolnum>7</manvolnum></citerefentry>.
        '';
      };

      user = mkOption {
        type = types.str;
        default = "root";
        example = "backup";
        description = ''
          The user for the service. Sudo or ZFS privilege delegation must be
          configured to use a user other than root.
        '';
      };

      sshKey = mkOption {
        type = types.nullOr types.path;
        # Prevent key from being copied to store
        apply = mapNullable toString;
        default = null;
        description = ''
          SSH private key file to use to login to the remote system. Can be
          overridden in individual commands.
        '';
      };

      commonArgs = mkOption {
        type = types.listOf types.str;
        default = [];
        example = [ "--no-sync-snap" ];
        description = ''
          Arguments to add to every syncoid command, unless disabled for that
          command. See
          <link xlink:href="https://github.com/jimsalterjrs/sanoid/#syncoid-command-line-options"/>
          for available options.
        '';
      };

      commands = mkOption {
        type = types.attrsOf (types.submodule ({ name, ... }: {
          options = {
            source = mkOption {
              type = types.str;
              example = "pool/dataset";
              description = ''
                Source ZFS dataset. Can be either local or remote. Defaults to
                the attribute name.
              '';
            };

            target = mkOption {
              type = types.str;
              example = "user@server:pool/dataset";
              description = ''
                Target ZFS dataset. Can be either local
                (<replaceable>pool/dataset</replaceable>) or remote
                (<replaceable>user@server:pool/dataset</replaceable>).
              '';
            };

            recursive = mkOption {
              type = types.bool;
              default = false;
              description = ''
                Whether to also transfer child datasets.
              '';
            };

            sshKey = mkOption {
              type = types.nullOr types.path;
              # Prevent key from being copied to store
              apply = mapNullable toString;
              description = ''
                SSH private key file to use to login to the remote system.
                Defaults to <option>services.syncoid.sshKey</option> option.
              '';
            };

            sendOptions = mkOption {
              type = types.separatedString " ";
              default = "";
              example = "Lc e";
              description = ''
                Advanced options to pass to zfs send. Options are specified
                without their leading dashes and separated by spaces.
              '';
            };

            recvOptions = mkOption {
              type = types.separatedString " ";
              default = "";
              example = "ux recordsize o compression=lz4";
              description = ''
                Advanced options to pass to zfs recv. Options are specified
                without their leading dashes and separated by spaces.
              '';
            };

            useCommonArgs = mkOption {
              type = types.bool;
              default = true;
              description = ''
                Whether to add the configured common arguments to this command.
              '';
            };

            extraArgs = mkOption {
              type = types.listOf types.str;
              default = [];
              example = [ "--sshport 2222" ];
              description = "Extra syncoid arguments for this command.";
            };
          };
          config = {
            source = mkDefault name;
            sshKey = mkDefault cfg.sshKey;
          };
        }));
        default = {};
        example."pool/test".target = "root@target:pool/test";
        description = "Syncoid commands to run.";
      };
    };

    # Implementation

    config = mkIf cfg.enable {
      systemd.services.syncoid = {
        description = "Syncoid ZFS synchronization service";
        script = concatMapStringsSep "\n" (c: lib.escapeShellArgs
          ([ "${pkgs.sanoid}/bin/syncoid" ]
            ++ (optionals c.useCommonArgs cfg.commonArgs)
            ++ (optional c.recursive "-r")
            ++ (optionals (c.sshKey != null) [ "--sshkey" c.sshKey ])
            ++ c.extraArgs
            ++ [ "--sendoptions" c.sendOptions
                 "--recvoptions" c.recvOptions
                 c.source c.target
               ])) (attrValues cfg.commands);
        after = [ "zfs.target" ];
        serviceConfig.User = cfg.user;
        startAt = cfg.interval;
      };
    };

    meta.maintainers = with maintainers; [ lopsided98 ];
  }