···

       
24
       
24
       
 
       
  # Since that service is a oneshot with RemainAfterExit,

     

       
25
       
25
       
 
       
  # the folder will exist during all renewal services.

     

       
26
       
26
       
 
       
  lockdir = "/run/acme/";

     

       
27
       
27
       
-
       
  concurrencyLockfiles = map (n: "${toString n}.lock") (lib.range 1 cfg.maxConcurrentRenewals);

     

       
28
       
28
       
-
       
  # Assign elements of `baseList` to each element of `needAssignmentList`, until the latter is exhausted.

     

       
29
       
29
       
-
       
  # returns: [{fst = "element of baseList"; snd = "element of needAssignmentList"}]

     

       
30
       
30
       
-
       
  roundRobinAssign =

     

       
31
       
31
       
-
       
    baseList: needAssignmentList:

     

       
32
       
32
       
-
       
    if baseList == [ ] then [ ] else _rrCycler baseList baseList needAssignmentList;

     

       
33
       
33
       
-
       
  _rrCycler =

     

       
34
       
34
       
-
       
    with builtins;

     

       
35
       
35
       
-
       
    origBaseList: workingBaseList: needAssignmentList:

     

       
36
       
36
       
-
       
    if (workingBaseList == [ ] || needAssignmentList == [ ]) then

     

       
37
       
37
       
-
       
      [ ]

     

       
38
       
38
       
-
       
    else

     

       
39
       
39
       
-
       
      [

     

       
40
       
40
       
-
       
        {

     

       
41
       
41
       
-
       
          fst = head workingBaseList;

     

       
42
       
42
       
-
       
          snd = head needAssignmentList;

     

       
43
       
43
       
-
       
        }

     

       
44
       
44
       
-
       
      ]

     

       
45
       
45
       
-
       
      ++ _rrCycler origBaseList (

     

       
46
       
46
       
-
       
        if (tail workingBaseList == [ ]) then origBaseList else tail workingBaseList

     

       
47
       
47
       
-
       
      ) (tail needAssignmentList);

     

       
48
       
48
       
-
       
  attrsToList = lib.mapAttrsToList (

     

       
49
       
49
       
-
       
    attrname: attrval: {

     

       
50
       
50
       
-
       
      name = attrname;

     

       
51
       
51
       
-
       
      value = attrval;

     

       
52
       
52
       
-
       
    }

     

       
53
       
53
       
-
       
  );

     

       
54
       
54
       
-
       
  # for an AttrSet `funcsAttrs` having functions as values, apply single arguments from

     

       
55
       
55
       
-
       
  # `argsList` to them in a round-robin manner.

     

       
56
       
56
       
-
       
  # Returns an attribute set with the applied functions as values.

     

       
57
       
57
       
-
       
  roundRobinApplyAttrs =

     

       
58
       
58
       
-
       
    funcsAttrs: argsList:

     

       
59
       
59
       
-
       
    lib.listToAttrs (

     

       
60
       
60
       
-
       
      map (x: {

     

       
61
       
61
       
-
       
        inherit (x.snd) name;

     

       
62
       
62
       
-
       
        value = x.snd.value x.fst;

     

       
63
       
63
       
-
       
      }) (roundRobinAssign argsList (attrsToList funcsAttrs))

     

       
64
       
64
       
-
       
    );

     

       
27
       
27
       
+
       


     

       
65
       
28
       
 
       
  wrapInFlock =

     

       
66
       
66
       
-
       
    lockfilePath: script:

     

       
29
       
29
       
+
       
    script:

     

       
67
       
30
       
 
       
    # explainer: https://stackoverflow.com/a/60896531

     

       
68
       
31
       
 
       
    ''

     

       
69
       
69
       
-
       
      exec {LOCKFD}> ${lockfilePath}

     

       
70
       
70
       
-
       
      echo "Waiting to acquire lock ${lockfilePath}"

     

       
71
       
71
       
-
       
      ${pkgs.flock}/bin/flock ''${LOCKFD} || exit 1

     

       
72
       
72
       
-
       
      echo "Acquired lock ${lockfilePath}"

     

       
32
       
32
       
+
       
      maxConcurrentRenewals=${toString cfg.maxConcurrentRenewals}

     

       
33
       
33
       
+
       


     

       
34
       
34
       
+
       
      acquireLock() {

     

       
35
       
35
       
+
       
        echo "Waiting to acquire lock in ${lockdir}"

     

       
36
       
36
       
+
       
        while true; do

     

       
37
       
37
       
+
       
          for i in $(seq 1 $maxConcurrentRenewals); do

     

       
38
       
38
       
+
       
            exec {LOCKFD}> "${lockdir}/$i.lock"

     

       
39
       
39
       
+
       
            if ${pkgs.flock}/bin/flock -n ''${LOCKFD}; then

     

       
40
       
40
       
+
       
              return 0

     

       
41
       
41
       
+
       
            fi

     

       
42
       
42
       
+
       
            exec {LOCKFD}>&-

     

       
43
       
43
       
+
       
          done

     

       
44
       
44
       
+
       
          sleep 1;

     

       
45
       
45
       
+
       
        done

     

       
46
       
46
       
+
       
      }

     

       
47
       
47
       
+
       


     

       
48
       
48
       
+
       
      if [ "$maxConcurrentRenewals" -gt "0" ]; then

     

       
49
       
49
       
+
       
        acquireLock

     

       
50
       
50
       
+
       
      fi

     

       
73
       
51
       
 
       
    ''

     

       
74
       
74
       
-
       
    + script

     

       
75
       
75
       
-
       
    + "\n"

     

       
76
       
76
       
-
       
    + ''echo "Releasing lock ${lockfilePath}"  # only released after process exit'';

     

       
52
       
52
       
+
       
    + script;

     

       
77
       
53
       
 
       


     

       
78
       
54
       
 
       
  # There are many services required to make cert renewals work.

     

       
79
       
55
       
 
       
  # They all follow a common structure:

     
···

       
356
       
332
       
 
       
        };

     

       
357
       
333
       
 
       
      };

     

       
358
       
334
       
 
       


     

       
359
       
359
       
-
       
      baseService = lockfileName: {

     

       
335
       
335
       
+
       
      baseService = {

     

       
360
       
336
       
 
       
        description = "Ensure certificate for ${cert}";

     

       
361
       
337
       
 
       


     

       
362
       
338
       
 
       
        wantedBy = [ "multi-user.target" ];

     
···

       
399
       
375
       
 
       
        # Working directory will be /tmp

     

       
400
       
376
       
 
       
        # minica will output to a folder sharing the name of the first domain

     

       
401
       
377
       
 
       
        # in the list, which will be ${data.domain}

     

       
402
       
402
       
-
       
        script = (if (lockfileName == null) then lib.id else wrapInFlock "${lockdir}${lockfileName}") ''

     

       
378
       
378
       
+
       
        script = wrapInFlock ''

     

       
403
       
379
       
 
       
          set -ex

     

       
404
       
380
       
 
       


     

       
405
       
381
       
 
       
          # Regenerate self-signed certificates (in case the SANs change) until we

     
···

       
447
       
423
       
 
       
        '';

     

       
448
       
424
       
 
       
      };

     

       
449
       
425
       
 
       


     

       
450
       
450
       
-
       
      orderRenewService = lockfileName: {

     

       
426
       
426
       
+
       
      orderRenewService = {

     

       
451
       
427
       
 
       
        description = "Order (and renew) ACME certificate for ${cert}";

     

       
452
       
428
       
 
       
        after = [

     

       
453
       
429
       
 
       
          "network.target"

     
···

       
528
       
504
       
 
       
              };

     

       
529
       
505
       
 
       


     

       
530
       
506
       
 
       
        # Working directory will be /tmp

     

       
531
       
531
       
-
       
        script = (if (lockfileName == null) then lib.id else wrapInFlock "${lockdir}${lockfileName}") ''

     

       
507
       
507
       
+
       
        script = wrapInFlock ''

     

       
532
       
508
       
 
       
          ${lib.optionalString data.enableDebugLogs "set -x"}

     

       
533
       
509
       
 
       
          set -euo pipefail

     

       
534
       
510
       
 
       


     
···

       
1179
       
1155
       
 
       


     

       
1180
       
1156
       
 
       
      systemd.services =

     

       
1181
       
1157
       
 
       
        let

     

       
1182
       
1182
       
-
       
          orderRenewServiceFunctions = lib.mapAttrs' (

     

       
1158
       
1158
       
+
       
          orderRenewServices = lib.mapAttrs' (

     

       
1183
       
1159
       
 
       
            cert: conf: lib.nameValuePair "acme-order-renew-${cert}" conf.orderRenewService

     

       
1184
       
1160
       
 
       
          ) certConfigs;

     

       
1185
       
1185
       
-
       
          orderRenewServices =

     

       
1186
       
1186
       
-
       
            if cfg.maxConcurrentRenewals > 0 then

     

       
1187
       
1187
       
-
       
              roundRobinApplyAttrs orderRenewServiceFunctions concurrencyLockfiles

     

       
1188
       
1188
       
-
       
            else

     

       
1189
       
1189
       
-
       
              lib.mapAttrs (_: f: f null) orderRenewServiceFunctions;

     

       
1190
       
1190
       
-
       
          baseServiceFunctions = lib.mapAttrs' (

     

       
1161
       
1161
       
+
       
          baseServices = lib.mapAttrs' (

     

       
1191
       
1162
       
 
       
            cert: conf: lib.nameValuePair "acme-${cert}" conf.baseService

     

       
1192
       
1163
       
 
       
          ) certConfigs;

     

       
1193
       
1193
       
-
       
          baseServices =

     

       
1194
       
1194
       
-
       
            if cfg.maxConcurrentRenewals > 0 then

     

       
1195
       
1195
       
-
       
              roundRobinApplyAttrs baseServiceFunctions concurrencyLockfiles

     

       
1196
       
1196
       
-
       
            else

     

       
1197
       
1197
       
-
       
              lib.mapAttrs (_: f: f null) baseServiceFunctions;

     

       
1198
       
1164
       
 
       
        in

     

       
1199
       
1165
       
 
       
        {

     

       
1200
       
1166
       
 
       
          acme-setup = setupService;