commit 59cb7a87d74813a06866f7b9a2058c7dc5c9bacc · pyrox.dev/nixpkgs

+32 -4

nixos/modules/system/activation/switch-to-configuration.pl

···

       2
       2
        
       

     

       3
       3
        
       use strict;

     

       4
       4
        
       use warnings;

     

       5
       5
       +
       use File::Path qw(make_path);

     

       5
       6
        
       use File::Basename;

     

       6
       7
        
       use File::Slurp;

     

       7
       8
        
       use Net::DBus;

     
···

       14
       15
        
       my $curSystemd = abs_path("/run/current-system/sw/bin");

     

       15
       16
        
       

     

       16
       17
        
       # To be robust against interruption, record what units need to be started etc.

     

       17
       17
       -
       my $startListFile = "/run/systemd/start-list";

     

       18
       18
       -
       my $restartListFile = "/run/systemd/restart-list";

     

       19
       19
       -
       my $reloadListFile = "/run/systemd/reload-list";

     

       18
       18
       +
       my $startListFile = "/run/nixos/start-list";

     

       19
       19
       +
       my $restartListFile = "/run/nixos/restart-list";

     

       20
       20
       +
       my $reloadListFile = "/run/nixos/reload-list";

     

       21
       21
       +
       

     

       22
       22
       +
       # Parse restart/reload requests by the activation script

     

       23
       23
       +
       my $restartByActivationFile = "/run/nixos/activation-restart-list";

     

       24
       24
       +
       my $reloadByActivationFile = "/run/nixos/activation-reload-list";

     

       25
       25
       +
       my $dryRestartByActivationFile = "/run/nixos/dry-activation-restart-list";

     

       26
       26
       +
       my $dryReloadByActivationFile = "/run/nixos/dry-activation-reload-list";

     

       27
       27
       +
       

     

       28
       28
       +
       make_path("/run/nixos", { mode => 0755 });

     

       20
       29
        
       

     

       21
       30
        
       my $action = shift @ARGV;

     

       22
       31
        
       

     
···

       150
       159
        
           split('\n', read_file($restartListFile, err_mode => 'quiet') // "");

     

       151
       160
        
       

     

       152
       161
        
       $unitsToReload{$_} = 1 foreach

     

       153
       153
       -
           split '\n', read_file($reloadListFile, err_mode => 'quiet') // "";

     

       162
       162
       +
           split('\n', read_file($reloadListFile, err_mode => 'quiet') // "");

     

       154
       163
        
       

     

       155
       164
        
       my $activePrev = getActiveUnits;

     

       156
       165
        
       while (my ($unit, $state) = each %{$activePrev}) {

     
···

       366
       375
        
           print STDERR "would activate the configuration...\n";

     

       367
       376
        
           system("$out/dry-activate", "$out");

     

       368
       377
        
       

     

       378
       378
       +
           $unitsToRestart{$_} = 1 foreach

     

       379
       379
       +
               split('\n', read_file($dryRestartByActivationFile, err_mode => 'quiet') // "");

     

       380
       380
       +
       

     

       381
       381
       +
           $unitsToReload{$_} = 1 foreach

     

       382
       382
       +
               split('\n', read_file($dryReloadByActivationFile, err_mode => 'quiet') // "");

     

       383
       383
       +
       

     

       369
       384
        
           print STDERR "would restart systemd\n" if $restartSystemd;

     

       370
       385
        
           print STDERR "would restart the following units: ", join(", ", sort(keys %unitsToRestart)), "\n"

     

       371
       386
        
               if scalar(keys %unitsToRestart) > 0;

     
···

       373
       388
        
               if scalar @unitsToStartFiltered;

     

       374
       389
        
           print STDERR "would reload the following units: ", join(", ", sort(keys %unitsToReload)), "\n"

     

       375
       390
        
               if scalar(keys %unitsToReload) > 0;

     

       391
       391
       +
           unlink($dryRestartByActivationFile);

     

       392
       392
       +
           unlink($dryReloadByActivationFile);

     

       376
       393
        
           exit 0;

     

       377
       394
        
       }

     

       378
       395
        
       

     
···

       395
       412
        
       print STDERR "activating the configuration...\n";

     

       396
       413
        
       system("$out/activate", "$out") == 0 or $res = 2;

     

       397
       414
        
       

     

       415
       415
       +
       # Handle the activation script requesting the restart or reload of a unit.

     

       416
       416
       +
       # We can only restart and reload (not stop/start) because the units to be

     

       417
       417
       +
       # stopped are already stopped before the activation script is run.

     

       418
       418
       +
       $unitsToRestart{$_} = 1 foreach

     

       419
       419
       +
           split('\n', read_file($restartByActivationFile, err_mode => 'quiet') // "");

     

       420
       420
       +
       

     

       421
       421
       +
       $unitsToReload{$_} = 1 foreach

     

       422
       422
       +
           split('\n', read_file($reloadByActivationFile, err_mode => 'quiet') // "");

     

       423
       423
       +
       

     

       398
       424
        
       # Restart systemd if necessary. Note that this is done using the

     

       399
       425
        
       # current version of systemd, just in case the new one has trouble

     

       400
       426
        
       # communicating with the running pid 1.

     
···

       434
       460
        
           print STDERR "reloading the following units: ", join(", ", sort(keys %unitsToReload)), "\n";

     

       435
       461
        
           system("@systemd@/bin/systemctl", "reload", "--", sort(keys %unitsToReload)) == 0 or $res = 4;

     

       436
       462
        
           unlink($reloadListFile);

     

       463
       463
       +
           unlink($reloadByActivationFile);

     

       437
       464
        
       }

     

       438
       465
        
       

     

       439
       466
        
       # Restart changed services (those that have to be restarted rather

     
···

       442
       469
        
           print STDERR "restarting the following units: ", join(", ", sort(keys %unitsToRestart)), "\n";

     

       443
       470
        
           system("@systemd@/bin/systemctl", "restart", "--", sort(keys %unitsToRestart)) == 0 or $res = 4;

     

       444
       471
        
           unlink($restartListFile);

     

       472
       472
       +
           unlink($restartByActivationFile);

     

       445
       473
        
       }

     

       446
       474
        
       

     

       447
       475
        
       # Start all active targets, as well as changed units we stopped above.

nixos/tests/all-tests.nix

···

       382
       382
        
         radicale = handleTest ./radicale.nix {};

     

       383
       383
        
         redis = handleTest ./redis.nix {};

     

       384
       384
        
         redmine = handleTest ./redmine.nix {};

     

       385
       385
       +
         restartByActivationScript = handleTest ./restart-by-activation-script.nix {};

     

       385
       386
        
         restic = handleTest ./restic.nix {};

     

       386
       387
        
         robustirc-bridge = handleTest ./robustirc-bridge.nix {};

     

       387
       388
        
         roundcube = handleTest ./roundcube.nix {};

+73

nixos/tests/restart-by-activation-script.nix

···

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

     

       2
       2
       +
         name = "restart-by-activation-script";

     

       3
       3
       +
         meta = with pkgs.lib.maintainers; {

     

       4
       4
       +
           maintainers = [ das_j ];

     

       5
       5
       +
         };

     

       6
       6
       +
       

     

       7
       7
       +
         machine = { pkgs, ... }: {

     

       8
       8
       +
           imports = [ ../modules/profiles/minimal.nix ];

     

       9
       9
       +
       

     

       10
       10
       +
           systemd.services.restart-me = {

     

       11
       11
       +
             wantedBy = [ "multi-user.target" ];

     

       12
       12
       +
             serviceConfig = {

     

       13
       13
       +
               Type = "oneshot";

     

       14
       14
       +
               RemainAfterExit = true;

     

       15
       15
       +
               ExecStart = "${pkgs.coreutils}/bin/true";

     

       16
       16
       +
             };

     

       17
       17
       +
           };

     

       18
       18
       +
       

     

       19
       19
       +
           systemd.services.reload-me = {

     

       20
       20
       +
             wantedBy = [ "multi-user.target" ];

     

       21
       21
       +
             serviceConfig = rec {

     

       22
       22
       +
               Type = "oneshot";

     

       23
       23
       +
               RemainAfterExit = true;

     

       24
       24
       +
               ExecStart = "${pkgs.coreutils}/bin/true";

     

       25
       25
       +
               ExecReload = ExecStart;

     

       26
       26
       +
             };

     

       27
       27
       +
           };

     

       28
       28
       +
       

     

       29
       29
       +
           system.activationScripts.test = {

     

       30
       30
       +
             supportsDryActivation = true;

     

       31
       31
       +
             text = ''

     

       32
       32
       +
               if [ -e /test-the-activation-script ]; then

     

       33
       33
       +
                 if [ "$NIXOS_ACTION" != dry-activate ]; then

     

       34
       34
       +
                   touch /activation-was-run

     

       35
       35
       +
                   echo restart-me.service > /run/nixos/activation-restart-list

     

       36
       36
       +
                   echo reload-me.service > /run/nixos/activation-reload-list

     

       37
       37
       +
                 else

     

       38
       38
       +
                   echo restart-me.service > /run/nixos/dry-activation-restart-list

     

       39
       39
       +
                   echo reload-me.service > /run/nixos/dry-activation-reload-list

     

       40
       40
       +
                 fi

     

       41
       41
       +
               fi

     

       42
       42
       +
             '';

     

       43
       43
       +
           };

     

       44
       44
       +
         };

     

       45
       45
       +
       

     

       46
       46
       +
         testScript = /* python */ ''

     

       47
       47
       +
           machine.wait_for_unit("multi-user.target")

     

       48
       48
       +
       

     

       49
       49
       +
           with subtest("nothing happens when the activation script does nothing"):

     

       50
       50
       +
               out = machine.succeed("/run/current-system/bin/switch-to-configuration dry-activate 2>&1")

     

       51
       51
       +
               assert 'restart' not in out

     

       52
       52
       +
               assert 'reload' not in out

     

       53
       53
       +
               out = machine.succeed("/run/current-system/bin/switch-to-configuration test")

     

       54
       54
       +
               assert 'restart' not in out

     

       55
       55
       +
               assert 'reload' not in out

     

       56
       56
       +
       

     

       57
       57
       +
           machine.succeed("touch /test-the-activation-script")

     

       58
       58
       +
       

     

       59
       59
       +
           with subtest("dry activation"):

     

       60
       60
       +
               out = machine.succeed("/run/current-system/bin/switch-to-configuration dry-activate 2>&1")

     

       61
       61
       +
               assert 'would restart the following units: restart-me.service' in out

     

       62
       62
       +
               assert 'would reload the following units: reload-me.service' in out

     

       63
       63
       +
               machine.fail("test -f /run/nixos/dry-activation-restart-list")

     

       64
       64
       +
               machine.fail("test -f /run/nixos/dry-activation-reload-list")

     

       65
       65
       +
       

     

       66
       66
       +
           with subtest("real activation"):

     

       67
       67
       +
               out = machine.succeed("/run/current-system/bin/switch-to-configuration test 2>&1")

     

       68
       68
       +
               assert 'restarting the following units: restart-me.service' in out

     

       69
       69
       +
               assert 'reloading the following units: reload-me.service' in out

     

       70
       70
       +
               machine.fail("test -f /run/nixos/activation-restart-list")

     

       71
       71
       +
               machine.fail("test -f /run/nixos/activation-reload-list")

     

       72
       72
       +
         '';

     

       73
       73
       +
       })