commit 9258f57625b474c542938a295ee0e85c9c5533ff · pyrox.dev/nixpkgs

+55 -20

nixos/lib/systemd-lib.nix

···

       1
       1
       -
       { config, lib, pkgs }:

     

       1
       1
       +
       { config, lib, pkgs, utils }:

     

       2
       2
        
       

     

       3
       3
        
       let

     

       4
       4
        
         inherit (lib)

     
···

       381
       381
        
           };

     

       382
       382
        
         };

     

       383
       383
        
       

     

       384
       384
       -
         serviceConfig = { config, ... }: {

     

       385
       385
       -
           config.environment.PATH = mkIf (config.path != []) "${makeBinPath config.path}:${makeSearchPathOutput "bin" "sbin" config.path}";

     

       384
       384
       +
         serviceConfig = { name, config, ... }: {

     

       385
       385
       +
           config = {

     

       386
       386
       +
             name = "${name}.service";

     

       387
       387
       +
             environment.PATH = mkIf (config.path != []) "${makeBinPath config.path}:${makeSearchPathOutput "bin" "sbin" config.path}";

     

       388
       388
       +
           };

     

       389
       389
       +
         };

     

       390
       390
       +
       

     

       391
       391
       +
         pathConfig = { name, config, ... }: {

     

       392
       392
       +
           config = {

     

       393
       393
       +
             name = "${name}.path";

     

       394
       394
       +
           };

     

       395
       395
       +
         };

     

       396
       396
       +
       

     

       397
       397
       +
         socketConfig = { name, config, ... }: {

     

       398
       398
       +
           config = {

     

       399
       399
       +
             name = "${name}.socket";

     

       400
       400
       +
           };

     

       401
       401
       +
         };

     

       402
       402
       +
       

     

       403
       403
       +
         sliceConfig = { name, config, ... }: {

     

       404
       404
       +
           config = {

     

       405
       405
       +
             name = "${name}.slice";

     

       406
       406
       +
           };

     

       407
       407
       +
         };

     

       408
       408
       +
       

     

       409
       409
       +
         targetConfig = { name, config, ... }: {

     

       410
       410
       +
           config = {

     

       411
       411
       +
             name = "${name}.target";

     

       412
       412
       +
           };

     

       413
       413
       +
         };

     

       414
       414
       +
       

     

       415
       415
       +
         timerConfig = { name, config, ... }: {

     

       416
       416
       +
           config = {

     

       417
       417
       +
             name = "${name}.timer";

     

       418
       418
       +
           };

     

       386
       419
        
         };

     

       387
       420
        
       

     

       388
       421
        
         stage2ServiceConfig = {

     
···

       401
       434
        
       

     

       402
       435
        
         mountConfig = { config, ... }: {

     

       403
       436
        
           config = {

     

       437
       437
       +
             name = "${utils.escapeSystemdPath config.where}.mount";

     

       404
       438
        
             mountConfig =

     

       405
       439
        
               { What = config.what;

     

       406
       440
        
                 Where = config.where;

     
···

       414
       448
        
       

     

       415
       449
        
         automountConfig = { config, ... }: {

     

       416
       450
        
           config = {

     

       451
       451
       +
             name = "${utils.escapeSystemdPath config.where}.automount";

     

       417
       452
        
             automountConfig =

     

       418
       453
        
               { Where = config.where;

     

       419
       454
        
               };

     
···

       429
       464
        
             WantedBy=${concatStringsSep " " def.wantedBy}

     

       430
       465
        
           '';

     

       431
       466
        
       

     

       432
       432
       -
         targetToUnit = name: def:

     

       433
       433
       -
           { inherit (def) aliases wantedBy requiredBy upheldBy enable overrideStrategy;

     

       467
       467
       +
         targetToUnit = def:

     

       468
       468
       +
           { inherit (def) name aliases wantedBy requiredBy upheldBy enable overrideStrategy;

     

       434
       469
        
             text =

     

       435
       470
        
               ''

     

       436
       471
        
                 [Unit]

     
···

       438
       473
        
               '';

     

       439
       474
        
           };

     

       440
       475
        
       

     

       441
       441
       -
         serviceToUnit = name: def:

     

       442
       442
       -
           { inherit (def) aliases wantedBy requiredBy upheldBy enable overrideStrategy;

     

       476
       476
       +
         serviceToUnit = def:

     

       477
       477
       +
           { inherit (def) name aliases wantedBy requiredBy upheldBy enable overrideStrategy;

     

       443
       478
        
             text = commonUnitText def (''

     

       444
       479
        
               [Service]

     

       445
       480
        
             '' + (let env = cfg.globalEnvironment // def.environment;

     
···

       448
       483
        
                   "Environment=${toJSON "${n}=${env.${n}}"}\n";

     

       449
       484
        
                 # systemd max line length is now 1MiB

     

       450
       485
        
                 # https://github.com/systemd/systemd/commit/e6dde451a51dc5aaa7f4d98d39b8fe735f73d2af

     

       451
       451
       -
                 in if stringLength s >= 1048576 then throw "The value of the environment variable ‘${n}’ in systemd service ‘${name}.service’ is too long." else s) (attrNames env))

     

       486
       486
       +
                 in if stringLength s >= 1048576 then throw "The value of the environment variable ‘${n}’ in systemd service ‘${def.name}.service’ is too long." else s) (attrNames env))

     

       452
       487
        
             + (if def ? reloadIfChanged && def.reloadIfChanged then ''

     

       453
       488
        
               X-ReloadIfChanged=true

     

       454
       489
        
             '' else if (def ? restartIfChanged && !def.restartIfChanged) then ''

     
···

       459
       494
        
             '' + attrsToSection def.serviceConfig);

     

       460
       495
        
           };

     

       461
       496
        
       

     

       462
       462
       -
         socketToUnit = name: def:

     

       463
       463
       -
           { inherit (def) aliases wantedBy requiredBy upheldBy enable overrideStrategy;

     

       497
       497
       +
         socketToUnit = def:

     

       498
       498
       +
           { inherit (def) name aliases wantedBy requiredBy upheldBy enable overrideStrategy;

     

       464
       499
        
             text = commonUnitText def ''

     

       465
       500
        
               [Socket]

     

       466
       501
        
               ${attrsToSection def.socketConfig}

     
···

       469
       504
        
             '';

     

       470
       505
        
           };

     

       471
       506
        
       

     

       472
       472
       -
         timerToUnit = name: def:

     

       473
       473
       -
           { inherit (def) aliases wantedBy requiredBy upheldBy enable overrideStrategy;

     

       507
       507
       +
         timerToUnit = def:

     

       508
       508
       +
           { inherit (def) name aliases wantedBy requiredBy upheldBy enable overrideStrategy;

     

       474
       509
        
             text = commonUnitText def ''

     

       475
       510
        
               [Timer]

     

       476
       511
        
               ${attrsToSection def.timerConfig}

     

       477
       512
        
             '';

     

       478
       513
        
           };

     

       479
       514
        
       

     

       480
       480
       -
         pathToUnit = name: def:

     

       481
       481
       -
           { inherit (def) aliases wantedBy requiredBy upheldBy enable overrideStrategy;

     

       515
       515
       +
         pathToUnit = def:

     

       516
       516
       +
           { inherit (def) name aliases wantedBy requiredBy upheldBy enable overrideStrategy;

     

       482
       517
        
             text = commonUnitText def ''

     

       483
       518
        
               [Path]

     

       484
       519
        
               ${attrsToSection def.pathConfig}

     

       485
       520
        
             '';

     

       486
       521
        
           };

     

       487
       522
        
       

     

       488
       488
       -
         mountToUnit = name: def:

     

       489
       489
       -
           { inherit (def) aliases wantedBy requiredBy upheldBy enable overrideStrategy;

     

       523
       523
       +
         mountToUnit = def:

     

       524
       524
       +
           { inherit (def) name aliases wantedBy requiredBy upheldBy enable overrideStrategy;

     

       490
       525
        
             text = commonUnitText def ''

     

       491
       526
        
               [Mount]

     

       492
       527
        
               ${attrsToSection def.mountConfig}

     

       493
       528
        
             '';

     

       494
       529
        
           };

     

       495
       530
        
       

     

       496
       496
       -
         automountToUnit = name: def:

     

       497
       497
       -
           { inherit (def) aliases wantedBy requiredBy upheldBy enable overrideStrategy;

     

       531
       531
       +
         automountToUnit = def:

     

       532
       532
       +
           { inherit (def) name aliases wantedBy requiredBy upheldBy enable overrideStrategy;

     

       498
       533
        
             text = commonUnitText def ''

     

       499
       534
        
               [Automount]

     

       500
       535
        
               ${attrsToSection def.automountConfig}

     

       501
       536
        
             '';

     

       502
       537
        
           };

     

       503
       538
        
       

     

       504
       504
       -
         sliceToUnit = name: def:

     

       505
       505
       -
           { inherit (def) aliases wantedBy requiredBy upheldBy enable overrideStrategy;

     

       539
       539
       +
         sliceToUnit = def:

     

       540
       540
       +
           { inherit (def) name aliases wantedBy requiredBy upheldBy enable overrideStrategy;

     

       506
       541
        
             text = commonUnitText def ''

     

       507
       542
        
               [Slice]

     

       508
       543
        
               ${attrsToSection def.sliceConfig}

+20 -12

nixos/lib/systemd-types.nix

···

       5
       5
        
           automountConfig

     

       6
       6
        
           makeUnit

     

       7
       7
        
           mountConfig

     

       8
       8
       +
           pathConfig

     

       9
       9
       +
           sliceConfig

     

       10
       10
       +
           socketConfig

     

       8
       11
        
           stage1ServiceConfig

     

       9
       12
        
           stage2ServiceConfig

     

       13
       13
       +
           targetConfig

     

       14
       14
       +
           timerConfig

     

       10
       15
        
           unitConfig

     

       11
       16
        
           ;

     

       12
       17
        
       

     
···

       48
       53
        
           ;

     

       49
       54
        
       in

     

       50
       55
        
       

     

       51
       51
       -
       rec {

     

       56
       56
       +
       {

     

       52
       57
        
         units = attrsOf (submodule ({ name, config, ... }: {

     

       53
       58
        
           options = concreteUnitOptions;

     

       54
       54
       -
           config = { unit = mkDefault (makeUnit name config); };

     

       59
       59
       +
           config = {

     

       60
       60
       +
             name = mkDefault name;

     

       61
       61
       +
             unit = mkDefault (makeUnit name config);

     

       62
       62
       +
           };

     

       55
       63
        
         }));

     

       56
       64
        
       

     

       57
       65
        
         services = attrsOf (submodule [ stage2ServiceOptions unitConfig stage2ServiceConfig ]);

     

       58
       66
        
         initrdServices = attrsOf (submodule [ stage1ServiceOptions unitConfig stage1ServiceConfig ]);

     

       59
       67
        
       

     

       60
       60
       -
         targets = attrsOf (submodule [ stage2CommonUnitOptions unitConfig ]);

     

       61
       61
       -
         initrdTargets = attrsOf (submodule [ stage1CommonUnitOptions unitConfig ]);

     

       68
       68
       +
         targets = attrsOf (submodule [ stage2CommonUnitOptions unitConfig targetConfig ]);

     

       69
       69
       +
         initrdTargets = attrsOf (submodule [ stage1CommonUnitOptions unitConfig targetConfig ]);

     

       62
       70
        
       

     

       63
       63
       -
         sockets = attrsOf (submodule [ stage2SocketOptions unitConfig ]);

     

       64
       64
       -
         initrdSockets = attrsOf (submodule [ stage1SocketOptions unitConfig ]);

     

       71
       71
       +
         sockets = attrsOf (submodule [ stage2SocketOptions unitConfig socketConfig]);

     

       72
       72
       +
         initrdSockets = attrsOf (submodule [ stage1SocketOptions unitConfig socketConfig ]);

     

       65
       73
        
       

     

       66
       66
       -
         timers = attrsOf (submodule [ stage2TimerOptions unitConfig ]);

     

       67
       67
       -
         initrdTimers = attrsOf (submodule [ stage1TimerOptions unitConfig ]);

     

       74
       74
       +
         timers = attrsOf (submodule [ stage2TimerOptions unitConfig timerConfig ]);

     

       75
       75
       +
         initrdTimers = attrsOf (submodule [ stage1TimerOptions unitConfig timerConfig ]);

     

       68
       76
        
       

     

       69
       69
       -
         paths = attrsOf (submodule [ stage2PathOptions unitConfig ]);

     

       70
       70
       -
         initrdPaths = attrsOf (submodule [ stage1PathOptions unitConfig ]);

     

       77
       77
       +
         paths = attrsOf (submodule [ stage2PathOptions unitConfig pathConfig ]);

     

       78
       78
       +
         initrdPaths = attrsOf (submodule [ stage1PathOptions unitConfig pathConfig ]);

     

       71
       79
        
       

     

       72
       72
       -
         slices = attrsOf (submodule [ stage2SliceOptions unitConfig ]);

     

       73
       73
       -
         initrdSlices = attrsOf (submodule [ stage1SliceOptions unitConfig ]);

     

       80
       80
       +
         slices = attrsOf (submodule [ stage2SliceOptions unitConfig sliceConfig ]);

     

       81
       81
       +
         initrdSlices = attrsOf (submodule [ stage1SliceOptions unitConfig sliceConfig ]);

     

       74
       82
        
       

     

       75
       83
        
         mounts = listOf (submodule [ stage2MountOptions unitConfig mountConfig ]);

     

       76
       84
        
         initrdMounts = listOf (submodule [ stage1MountOptions unitConfig mountConfig ]);

nixos/lib/systemd-unit-options.nix

···

       65
       65
        
             '';

     

       66
       66
        
           };

     

       67
       67
        
       

     

       68
       68
       +
           name = lib.mkOption {

     

       69
       69
       +
             type = lib.types.str;

     

       70
       70
       +
             description = ''

     

       71
       71
       +
               The name of this systemd unit, including its extension.

     

       72
       72
       +
               This can be used to refer to this unit from other systemd units.

     

       73
       73
       +
             '';

     

       74
       74
       +
           };

     

       75
       75
       +
       

     

       68
       76
        
           overrideStrategy = mkOption {

     

       69
       77
        
             default = "asDropinIfExists";

     

       70
       78
        
             type = types.enum [ "asDropinIfExists" "asDropin" ];

+5 -3

nixos/lib/utils.nix

···

       35
       35
        
         inherit (lib.strings) toJSON normalizePath escapeC;

     

       36
       36
        
       in

     

       37
       37
        
       

     

       38
       38
       -
       rec {

     

       38
       38
       +
       let

     

       39
       39
       +
       utils = rec {

     

       39
       40
        
       

     

       40
       41
        
         # Copy configuration files to avoid having the entire sources in the system closure

     

       41
       42
        
         copyFile = filePath: pkgs.runCommand (builtins.unsafeDiscardStringContext (baseNameOf filePath)) {} ''

     
···

       262
       263
        
             filter (x: !(elem (getName x) namesToRemove)) packages;

     

       263
       264
        
       

     

       264
       265
        
         systemdUtils = {

     

       265
       265
       -
           lib = import ./systemd-lib.nix { inherit lib config pkgs; };

     

       266
       266
       +
           lib = import ./systemd-lib.nix { inherit lib config pkgs utils; };

     

       266
       267
        
           unitOptions = import ./systemd-unit-options.nix { inherit lib systemdUtils; };

     

       267
       268
        
           types = import ./systemd-types.nix { inherit lib systemdUtils pkgs; };

     

       268
       269
        
           network = {

     

       269
       270
        
             units = import ./systemd-network-units.nix { inherit lib systemdUtils; };

     

       270
       271
        
           };

     

       271
       272
        
         };

     

       272
       272
       -
       }

     

       273
       273
       +
       };

     

       274
       274
       +
       in utils

+11 -12

nixos/modules/system/boot/systemd.nix

···

       595
       595
        
           };

     

       596
       596
        
       

     

       597
       597
        
           systemd.units =

     

       598
       598
       -
                mapAttrs' (n: v: nameValuePair "${n}.path"    (pathToUnit    n v)) cfg.paths

     

       599
       599
       -
             // mapAttrs' (n: v: nameValuePair "${n}.service" (serviceToUnit n v)) cfg.services

     

       600
       600
       -
             // mapAttrs' (n: v: nameValuePair "${n}.slice"   (sliceToUnit   n v)) cfg.slices

     

       601
       601
       -
             // mapAttrs' (n: v: nameValuePair "${n}.socket"  (socketToUnit  n v)) cfg.sockets

     

       602
       602
       -
             // mapAttrs' (n: v: nameValuePair "${n}.target"  (targetToUnit  n v)) cfg.targets

     

       603
       603
       -
             // mapAttrs' (n: v: nameValuePair "${n}.timer"   (timerToUnit   n v)) cfg.timers

     

       604
       604
       -
             // listToAttrs (map

     

       605
       605
       -
                          (v: let n = escapeSystemdPath v.where;

     

       606
       606
       -
                              in nameValuePair "${n}.mount" (mountToUnit n v)) cfg.mounts)

     

       607
       607
       -
             // listToAttrs (map

     

       608
       608
       -
                          (v: let n = escapeSystemdPath v.where;

     

       609
       609
       -
                              in nameValuePair "${n}.automount" (automountToUnit n v)) cfg.automounts);

     

       598
       598
       +
             let

     

       599
       599
       +
               withName = cfgToUnit: cfg: lib.nameValuePair cfg.name (cfgToUnit cfg);

     

       600
       600
       +
             in

     

       601
       601
       +
                mapAttrs' (_: withName pathToUnit) cfg.paths

     

       602
       602
       +
             // mapAttrs' (_: withName serviceToUnit) cfg.services

     

       603
       603
       +
             // mapAttrs' (_: withName sliceToUnit) cfg.slices

     

       604
       604
       +
             // mapAttrs' (_: withName socketToUnit) cfg.sockets

     

       605
       605
       +
             // mapAttrs' (_: withName targetToUnit) cfg.targets

     

       606
       606
       +
             // mapAttrs' (_: withName timerToUnit) cfg.timers

     

       607
       607
       +
             // listToAttrs (map (withName mountToUnit) cfg.mounts)

     

       608
       608
       +
             // listToAttrs (map (withName automountToUnit) cfg.automounts);

     

       610
       609
        
       

     

       611
       610
        
             # Environment of PID 1

     

       612
       611
        
             systemd.managerEnvironment = {

+8 -8

nixos/modules/system/boot/systemd/initrd.nix

···

       490
       490
        
       

     

       491
       491
        
             targets.initrd.aliases = ["default.target"];

     

       492
       492
        
             units =

     

       493
       493
       -
                  mapAttrs' (n: v: nameValuePair "${n}.path"    (pathToUnit    n v)) cfg.paths

     

       494
       494
       -
               // mapAttrs' (n: v: nameValuePair "${n}.service" (serviceToUnit n v)) cfg.services

     

       495
       495
       -
               // mapAttrs' (n: v: nameValuePair "${n}.slice"   (sliceToUnit   n v)) cfg.slices

     

       496
       496
       -
               // mapAttrs' (n: v: nameValuePair "${n}.socket"  (socketToUnit  n v)) cfg.sockets

     

       497
       497
       -
               // mapAttrs' (n: v: nameValuePair "${n}.target"  (targetToUnit  n v)) cfg.targets

     

       498
       498
       -
               // mapAttrs' (n: v: nameValuePair "${n}.timer"   (timerToUnit   n v)) cfg.timers

     

       493
       493
       +
                  mapAttrs' (n: v: nameValuePair "${n}.path"    (pathToUnit    v)) cfg.paths

     

       494
       494
       +
               // mapAttrs' (n: v: nameValuePair "${n}.service" (serviceToUnit v)) cfg.services

     

       495
       495
       +
               // mapAttrs' (n: v: nameValuePair "${n}.slice"   (sliceToUnit   v)) cfg.slices

     

       496
       496
       +
               // mapAttrs' (n: v: nameValuePair "${n}.socket"  (socketToUnit  v)) cfg.sockets

     

       497
       497
       +
               // mapAttrs' (n: v: nameValuePair "${n}.target"  (targetToUnit  v)) cfg.targets

     

       498
       498
       +
               // mapAttrs' (n: v: nameValuePair "${n}.timer"   (timerToUnit   v)) cfg.timers

     

       499
       499
        
               // listToAttrs (map

     

       500
       500
        
                            (v: let n = escapeSystemdPath v.where;

     

       501
       501
       -
                                in nameValuePair "${n}.mount" (mountToUnit n v)) cfg.mounts)

     

       501
       501
       +
                                in nameValuePair "${n}.mount" (mountToUnit v)) cfg.mounts)

     

       502
       502
        
               // listToAttrs (map

     

       503
       503
        
                            (v: let n = escapeSystemdPath v.where;

     

       504
       504
       -
                                in nameValuePair "${n}.automount" (automountToUnit n v)) cfg.automounts);

     

       504
       504
       +
                                in nameValuePair "${n}.automount" (automountToUnit v)) cfg.automounts);

     

       505
       505
        
       

     

       506
       506
        
             # make sure all the /dev nodes are set up

     

       507
       507
        
             services.systemd-tmpfiles-setup-dev.wantedBy = ["sysinit.target"];

+6 -6

nixos/modules/system/boot/systemd/user.nix

···

       175
       175
        
           };

     

       176
       176
        
       

     

       177
       177
        
           systemd.user.units =

     

       178
       178
       -
                mapAttrs' (n: v: nameValuePair "${n}.path"    (pathToUnit    n v)) cfg.paths

     

       179
       179
       -
             // mapAttrs' (n: v: nameValuePair "${n}.service" (serviceToUnit n v)) cfg.services

     

       180
       180
       -
             // mapAttrs' (n: v: nameValuePair "${n}.slice"   (sliceToUnit   n v)) cfg.slices

     

       181
       181
       -
             // mapAttrs' (n: v: nameValuePair "${n}.socket"  (socketToUnit  n v)) cfg.sockets

     

       182
       182
       -
             // mapAttrs' (n: v: nameValuePair "${n}.target"  (targetToUnit  n v)) cfg.targets

     

       183
       183
       -
             // mapAttrs' (n: v: nameValuePair "${n}.timer"   (timerToUnit   n v)) cfg.timers;

     

       178
       178
       +
                mapAttrs' (n: v: nameValuePair "${n}.path"    (pathToUnit    v)) cfg.paths

     

       179
       179
       +
             // mapAttrs' (n: v: nameValuePair "${n}.service" (serviceToUnit v)) cfg.services

     

       180
       180
       +
             // mapAttrs' (n: v: nameValuePair "${n}.slice"   (sliceToUnit   v)) cfg.slices

     

       181
       181
       +
             // mapAttrs' (n: v: nameValuePair "${n}.socket"  (socketToUnit  v)) cfg.sockets

     

       182
       182
       +
             // mapAttrs' (n: v: nameValuePair "${n}.target"  (targetToUnit  v)) cfg.targets

     

       183
       183
       +
             // mapAttrs' (n: v: nameValuePair "${n}.timer"   (timerToUnit   v)) cfg.timers;

     

       184
       184
        
       

     

       185
       185
        
           # Generate timer units for all services that have a ‘startAt’ value.

     

       186
       186
        
           systemd.user.timers =

+11 -2

nixos/tests/systemd.nix

···

       1
       1
        
       import ./make-test-python.nix ({ pkgs, ... }: {

     

       2
       2
        
         name = "systemd";

     

       3
       3
        
       

     

       4
       4
       -
         nodes.machine = { lib, ... }: {

     

       4
       4
       +
         nodes.machine = { config, lib, ... }: {

     

       5
       5
        
           imports = [ common/user-account.nix common/x11.nix ];

     

       6
       6
        
       

     

       7
       7
        
           virtualisation.emptyDiskImages = [ 512 512 ];

     
···

       38
       38
        
             script = "true";

     

       39
       39
        
           };

     

       40
       40
        
       

     

       41
       41
       +
           systemd.services.testDependency1 = {

     

       42
       42
       +
             description = "Test Dependency 1";

     

       43
       43
       +
             wantedBy = [ config.systemd.services."testservice1".name ];

     

       44
       44
       +
             serviceConfig.Type = "oneshot";

     

       45
       45
       +
             script = ''

     

       46
       46
       +
               true

     

       47
       47
       +
             '';

     

       48
       48
       +
           };

     

       49
       49
       +
       

     

       41
       50
        
           systemd.services.testservice1 = {

     

       42
       51
        
             description = "Test Service 1";

     

       43
       43
       -
             wantedBy = [ "multi-user.target" ];

     

       52
       52
       +
             wantedBy = [ config.systemd.targets.multi-user.name ];

     

       44
       53
        
             serviceConfig.Type = "oneshot";

     

       45
       54
        
             script = ''

     

       46
       55
        
               if [ "$XXX_SYSTEM" = foo ]; then