pyrox.dev
1# Test configuration switching.
2
3import ./make-test-python.nix ({ lib, pkgs, ...} : let
4
5 # Simple service that can either be socket-activated or that will
6 # listen on port 1234 if not socket-activated.
7 # A connection to the socket causes 'hello' to be written to the client.
8 socketTest = pkgs.writeScript "socket-test.py" /* python */ ''
9 #!${pkgs.python3}/bin/python3
10
11 from socketserver import TCPServer, StreamRequestHandler
12 import socket
13 import os
14
15
16 class Handler(StreamRequestHandler):
17 def handle(self):
18 self.wfile.write("hello".encode("utf-8"))
19
20
21 class Server(TCPServer):
22 def __init__(self, server_address, handler_cls):
23 listenFds = os.getenv('LISTEN_FDS')
24 if listenFds is None or int(listenFds) < 1:
25 print(f'Binding to {server_address}')
26 TCPServer.__init__(
27 self, server_address, handler_cls, bind_and_activate=True)
28 else:
29 TCPServer.__init__(
30 self, server_address, handler_cls, bind_and_activate=False)
31 # Override socket
32 print(f'Got activated by {os.getenv("LISTEN_FDNAMES")} '
33 f'with {listenFds} FDs')
34 self.socket = socket.fromfd(3, self.address_family,
35 self.socket_type)
36
37
38 if __name__ == "__main__":
39 server = Server(("localhost", 1234), Handler)
40 server.serve_forever()
41 '';
42
43in {
44 name = "switch-test";
45 meta = with pkgs.lib.maintainers; {
46 maintainers = [ gleber das_j ];
47 };
48
49 nodes = {
50 machine = { pkgs, lib, ... }: {
51 environment.systemPackages = [ pkgs.socat ]; # for the socket activation stuff
52 users.mutableUsers = false;
53
54 # For boot/switch testing
55 system.build.installBootLoader = lib.mkForce (pkgs.writeShellScript "install-dummy-loader" ''
56 echo "installing dummy bootloader"
57 touch /tmp/bootloader-installed
58 '');
59
60 specialisation = rec {
61 brokenInitInterface.configuration.config.system.extraSystemBuilderCmds = ''
62 echo "systemd 0" > $out/init-interface-version
63 '';
64
65 modifiedSystemConf.configuration.systemd.extraConfig = ''
66 # Hello world!
67 '';
68
69 addedMount.configuration.virtualisation.fileSystems."/test" = {
70 device = "tmpfs";
71 fsType = "tmpfs";
72 };
73
74 addedMountOptsModified.configuration = {
75 imports = [ addedMount.configuration ];
76 virtualisation.fileSystems."/test".options = [ "x-test" ];
77 };
78
79 addedMountDevModified.configuration = {
80 imports = [ addedMountOptsModified.configuration ];
81 virtualisation.fileSystems."/test".device = lib.mkForce "ramfs";
82 };
83
84 storeMountModified.configuration = {
85 virtualisation.fileSystems."/".device = lib.mkForce "auto";
86 };
87
88 swap.configuration.swapDevices = lib.mkVMOverride [
89 { device = "/swapfile"; size = 1; }
90 ];
91
92 simpleService.configuration = {
93 systemd.services.test = {
94 wantedBy = [ "multi-user.target" ];
95 serviceConfig = {
96 Type = "oneshot";
97 RemainAfterExit = true;
98 ExecStart = "${pkgs.coreutils}/bin/true";
99 ExecReload = "${pkgs.coreutils}/bin/true";
100 };
101 };
102 };
103
104 simpleServiceSeparateActivationScript.configuration = {
105 system.activatable = false;
106 systemd.services.test = {
107 wantedBy = [ "multi-user.target" ];
108 serviceConfig = {
109 Type = "oneshot";
110 RemainAfterExit = true;
111 ExecStart = "${pkgs.coreutils}/bin/true";
112 ExecReload = "${pkgs.coreutils}/bin/true";
113 };
114 };
115 };
116
117 simpleServiceDifferentDescription.configuration = {
118 imports = [ simpleService.configuration ];
119 systemd.services.test.description = "Test unit";
120 };
121
122 simpleServiceModified.configuration = {
123 imports = [ simpleService.configuration ];
124 systemd.services.test.serviceConfig.X-Test = true;
125 };
126
127 simpleServiceNostop.configuration = {
128 imports = [ simpleService.configuration ];
129 systemd.services.test.stopIfChanged = false;
130 };
131
132 simpleServiceReload.configuration = {
133 imports = [ simpleService.configuration ];
134 systemd.services.test = {
135 reloadIfChanged = true;
136 serviceConfig.ExecReload = "${pkgs.coreutils}/bin/true";
137 };
138 };
139
140 simpleServiceNorestart.configuration = {
141 imports = [ simpleService.configuration ];
142 systemd.services.test.restartIfChanged = false;
143 };
144
145 simpleServiceFailing.configuration = {
146 imports = [ simpleServiceModified.configuration ];
147 systemd.services.test.serviceConfig.ExecStart = lib.mkForce "${pkgs.coreutils}/bin/false";
148 };
149
150 autorestartService.configuration = {
151 # A service that immediately goes into restarting (but without failing)
152 systemd.services.autorestart = {
153 wantedBy = [ "multi-user.target" ];
154 serviceConfig = {
155 Type = "simple";
156 Restart = "always";
157 RestartSec = "20y"; # Should be long enough
158 ExecStart = "${pkgs.coreutils}/bin/true";
159 };
160 };
161 };
162
163 autorestartServiceFailing.configuration = {
164 imports = [ autorestartService.configuration ];
165 systemd.services.autorestart.serviceConfig = {
166 ExecStart = lib.mkForce "${pkgs.coreutils}/bin/false";
167 };
168 };
169
170 simpleServiceWithExtraSection.configuration = {
171 imports = [ simpleServiceNostop.configuration ];
172 systemd.packages = [ (pkgs.writeTextFile {
173 name = "systemd-extra-section";
174 destination = "/etc/systemd/system/test.service";
175 text = ''
176 [X-Test]
177 X-Test-Value=a
178 '';
179 }) ];
180 };
181
182 simpleServiceWithExtraSectionOtherName.configuration = {
183 imports = [ simpleServiceNostop.configuration ];
184 systemd.packages = [ (pkgs.writeTextFile {
185 name = "systemd-extra-section";
186 destination = "/etc/systemd/system/test.service";
187 text = ''
188 [X-Test2]
189 X-Test-Value=a
190 '';
191 }) ];
192 };
193
194 simpleServiceWithInstallSection.configuration = {
195 imports = [ simpleServiceNostop.configuration ];
196 systemd.packages = [ (pkgs.writeTextFile {
197 name = "systemd-extra-section";
198 destination = "/etc/systemd/system/test.service";
199 text = ''
200 [Install]
201 WantedBy=multi-user.target
202 '';
203 }) ];
204 };
205
206 simpleServiceWithExtraKey.configuration = {
207 imports = [ simpleServiceNostop.configuration ];
208 systemd.services.test.serviceConfig."X-Test" = "test";
209 };
210
211 simpleServiceWithExtraKeyOtherValue.configuration = {
212 imports = [ simpleServiceNostop.configuration ];
213 systemd.services.test.serviceConfig."X-Test" = "test2";
214 };
215
216 simpleServiceWithExtraKeyOtherName.configuration = {
217 imports = [ simpleServiceNostop.configuration ];
218 systemd.services.test.serviceConfig."X-Test2" = "test";
219 };
220
221 simpleServiceReloadTrigger.configuration = {
222 imports = [ simpleServiceNostop.configuration ];
223 systemd.services.test.reloadTriggers = [ "/dev/null" ];
224 };
225
226 simpleServiceReloadTriggerModified.configuration = {
227 imports = [ simpleServiceNostop.configuration ];
228 systemd.services.test.reloadTriggers = [ "/dev/zero" ];
229 };
230
231 simpleServiceReloadTriggerModifiedAndSomethingElse.configuration = {
232 imports = [ simpleServiceNostop.configuration ];
233 systemd.services.test = {
234 reloadTriggers = [ "/dev/zero" ];
235 serviceConfig."X-Test" = "test";
236 };
237 };
238
239 simpleServiceReloadTriggerModifiedSomethingElse.configuration = {
240 imports = [ simpleServiceNostop.configuration ];
241 systemd.services.test.serviceConfig."X-Test" = "test";
242 };
243
244 unitWithBackslash.configuration = {
245 systemd.services."escaped\\x2ddash" = {
246 wantedBy = [ "multi-user.target" ];
247 serviceConfig = {
248 Type = "oneshot";
249 RemainAfterExit = true;
250 ExecStart = "${pkgs.coreutils}/bin/true";
251 ExecReload = "${pkgs.coreutils}/bin/true";
252 };
253 };
254 };
255
256 unitWithBackslashModified.configuration = {
257 imports = [ unitWithBackslash.configuration ];
258 systemd.services."escaped\\x2ddash".serviceConfig.X-Test = "test";
259 };
260
261 unitStartingWithDash.configuration = {
262 systemd.services."-" = {
263 wantedBy = [ "multi-user.target" ];
264 serviceConfig = {
265 Type = "oneshot";
266 RemainAfterExit = true;
267 ExecStart = "${pkgs.coreutils}/bin/true";
268 };
269 };
270 };
271
272 unitStartingWithDashModified.configuration = {
273 imports = [ unitStartingWithDash.configuration ];
274 systemd.services."-" = {
275 reloadIfChanged = true;
276 serviceConfig.ExecReload = "${pkgs.coreutils}/bin/true";
277 };
278 };
279
280 unitWithRequirement.configuration = {
281 systemd.services.required-service = {
282 wantedBy = [ "multi-user.target" ];
283 serviceConfig = {
284 Type = "oneshot";
285 RemainAfterExit = true;
286 ExecStart = "${pkgs.coreutils}/bin/true";
287 ExecReload = "${pkgs.coreutils}/bin/true";
288 };
289 };
290 systemd.services.test-service = {
291 wantedBy = [ "multi-user.target" ];
292 requires = [ "required-service.service" ];
293 serviceConfig = {
294 Type = "oneshot";
295 RemainAfterExit = true;
296 ExecStart = "${pkgs.coreutils}/bin/true";
297 ExecReload = "${pkgs.coreutils}/bin/true";
298 };
299 };
300 };
301
302 unitWithRequirementModified.configuration = {
303 imports = [ unitWithRequirement.configuration ];
304 systemd.services.required-service.serviceConfig.X-Test = "test";
305 systemd.services.test-service.reloadTriggers = [ "test" ];
306 };
307
308 unitWithRequirementModifiedNostart.configuration = {
309 imports = [ unitWithRequirement.configuration ];
310 systemd.services.test-service.unitConfig.RefuseManualStart = true;
311 };
312
313 unitWithTemplate.configuration = {
314 systemd.services."instantiated@".serviceConfig = {
315 Type = "oneshot";
316 RemainAfterExit = true;
317 ExecStart = "${pkgs.coreutils}/bin/true";
318 ExecReload = "${pkgs.coreutils}/bin/true";
319 };
320 systemd.services."instantiated@one" = {
321 wantedBy = [ "multi-user.target" ];
322 overrideStrategy = "asDropin";
323 };
324 systemd.services."instantiated@two" = {
325 wantedBy = [ "multi-user.target" ];
326 overrideStrategy = "asDropin";
327 };
328 };
329
330 unitWithTemplateModified.configuration = {
331 imports = [ unitWithTemplate.configuration ];
332 systemd.services."instantiated@".serviceConfig.X-Test = "test";
333 };
334
335 restart-and-reload-by-activation-script.configuration = {
336 systemd.services = rec {
337 simple-service = {
338 # No wantedBy so we can check if the activation script restart triggers them
339 serviceConfig = {
340 Type = "oneshot";
341 RemainAfterExit = true;
342 ExecStart = "${pkgs.coreutils}/bin/true";
343 ExecReload = "${pkgs.coreutils}/bin/true";
344 };
345 };
346 "templated-simple-service@" = simple-service;
347 "templated-simple-service@instance".overrideStrategy = "asDropin";
348
349 simple-restart-service = simple-service // {
350 stopIfChanged = false;
351 };
352 "templated-simple-restart-service@" = simple-restart-service;
353 "templated-simple-restart-service@instance".overrideStrategy = "asDropin";
354
355 simple-reload-service = simple-service // {
356 reloadIfChanged = true;
357 };
358 "templated-simple-reload-service@" = simple-reload-service;
359 "templated-simple-reload-service@instance".overrideStrategy = "asDropin";
360
361 no-restart-service = simple-service // {
362 restartIfChanged = false;
363 };
364 "templated-no-restart-service@" = no-restart-service;
365 "templated-no-restart-service@instance".overrideStrategy = "asDropin";
366
367 reload-triggers = simple-service // {
368 wantedBy = [ "multi-user.target" ];
369 };
370 "templated-reload-triggers@" = simple-service;
371 "templated-reload-triggers@instance" = {
372 overrideStrategy = "asDropin";
373 wantedBy = [ "multi-user.target" ];
374 };
375
376 reload-triggers-and-restart-by-as = simple-service;
377 "templated-reload-triggers-and-restart-by-as@" = reload-triggers-and-restart-by-as;
378 "templated-reload-triggers-and-restart-by-as@instance".overrideStrategy = "asDropin";
379
380 reload-triggers-and-restart = simple-service // {
381 stopIfChanged = false; # easier to check for this
382 wantedBy = [ "multi-user.target" ];
383 };
384 "templated-reload-triggers-and-restart@" = simple-service;
385 "templated-reload-triggers-and-restart@instance" = {
386 overrideStrategy = "asDropin";
387 stopIfChanged = false; # easier to check for this
388 wantedBy = [ "multi-user.target" ];
389 };
390 };
391
392 system.activationScripts.restart-and-reload-test = {
393 supportsDryActivation = true;
394 deps = [];
395 text = ''
396 if [ "$NIXOS_ACTION" = dry-activate ]; then
397 f=/run/nixos/dry-activation-restart-list
398 g=/run/nixos/dry-activation-reload-list
399 else
400 f=/run/nixos/activation-restart-list
401 g=/run/nixos/activation-reload-list
402 fi
403 cat <<EOF >> "$f"
404 simple-service.service
405 simple-restart-service.service
406 simple-reload-service.service
407 no-restart-service.service
408 reload-triggers-and-restart-by-as.service
409 templated-simple-service@instance.service
410 templated-simple-restart-service@instance.service
411 templated-simple-reload-service@instance.service
412 templated-no-restart-service@instance.service
413 templated-reload-triggers-and-restart-by-as@instance.service
414 EOF
415
416 cat <<EOF >> "$g"
417 reload-triggers.service
418 reload-triggers-and-restart-by-as.service
419 reload-triggers-and-restart.service
420 templated-reload-triggers@instance.service
421 templated-reload-triggers-and-restart-by-as@instance.service
422 templated-reload-triggers-and-restart@instance.service
423 EOF
424 '';
425 };
426 };
427
428 restart-and-reload-by-activation-script-modified.configuration = {
429 imports = [ restart-and-reload-by-activation-script.configuration ];
430 systemd.services.reload-triggers-and-restart.serviceConfig.X-Modified = "test";
431 systemd.services."templated-reload-triggers-and-restart@instance" = {
432 overrideStrategy = "asDropin";
433 serviceConfig.X-Modified = "test";
434 };
435 };
436
437 simple-socket.configuration = {
438 systemd.services.socket-activated = {
439 description = "A socket-activated service";
440 stopIfChanged = lib.mkDefault false;
441 serviceConfig = {
442 ExecStart = socketTest;
443 ExecReload = "${pkgs.coreutils}/bin/true";
444 };
445 };
446 systemd.sockets.socket-activated = {
447 wantedBy = [ "sockets.target" ];
448 listenStreams = [ "/run/test.sock" ];
449 socketConfig.SocketMode = lib.mkDefault "0777";
450 };
451 };
452
453 simple-socket-service-modified.configuration = {
454 imports = [ simple-socket.configuration ];
455 systemd.services.socket-activated.serviceConfig.X-Test = "test";
456 };
457
458 simple-socket-stop-if-changed.configuration = {
459 imports = [ simple-socket.configuration ];
460 systemd.services.socket-activated.stopIfChanged = true;
461 };
462
463 simple-socket-stop-if-changed-and-reloadtrigger.configuration = {
464 imports = [ simple-socket.configuration ];
465 systemd.services.socket-activated = {
466 stopIfChanged = true;
467 reloadTriggers = [ "test" ];
468 };
469 };
470
471 mount.configuration = {
472 systemd.mounts = [
473 {
474 description = "Testmount";
475 what = "tmpfs";
476 type = "tmpfs";
477 where = "/testmount";
478 options = "size=1M";
479 wantedBy = [ "local-fs.target" ];
480 }
481 ];
482 };
483
484 mountOptionsModified.configuration = {
485 systemd.mounts = [
486 {
487 description = "Testmount";
488 what = "tmpfs";
489 type = "tmpfs";
490 where = "/testmount";
491 options = "size=10M";
492 wantedBy = [ "local-fs.target" ];
493 }
494 ];
495 };
496
497 mountModified.configuration = {
498 systemd.mounts = [
499 {
500 description = "Testmount";
501 what = "ramfs";
502 type = "ramfs";
503 where = "/testmount";
504 options = "size=10M";
505 wantedBy = [ "local-fs.target" ];
506 }
507 ];
508 };
509
510 timer.configuration = {
511 systemd.timers.test-timer = {
512 wantedBy = [ "timers.target" ];
513 timerConfig.OnCalendar = "@1395716396"; # chosen by fair dice roll
514 };
515 systemd.services.test-timer = {
516 serviceConfig = {
517 Type = "oneshot";
518 ExecStart = "${pkgs.coreutils}/bin/true";
519 };
520 };
521 };
522
523 timerModified.configuration = {
524 imports = [ timer.configuration ];
525 systemd.timers.test-timer.timerConfig.OnCalendar = lib.mkForce "Fri 2012-11-23 16:00:00";
526 };
527
528 hybridSleepModified.configuration = {
529 systemd.targets.hybrid-sleep.unitConfig.X-Test = true;
530 };
531
532 target.configuration = {
533 systemd.targets.test-target.wantedBy = [ "multi-user.target" ];
534 # We use this service to figure out whether the target was modified.
535 # This is the only way because targets are filtered and therefore not
536 # printed when they are started/stopped.
537 systemd.services.test-service = {
538 bindsTo = [ "test-target.target" ];
539 serviceConfig.ExecStart = "${pkgs.coreutils}/bin/sleep infinity";
540 };
541 };
542
543 targetModified.configuration = {
544 imports = [ target.configuration ];
545 systemd.targets.test-target.unitConfig.X-Test = true;
546 };
547
548 targetModifiedStopOnReconfig.configuration = {
549 imports = [ target.configuration ];
550 systemd.targets.test-target.unitConfig.X-StopOnReconfiguration = true;
551 };
552
553 path.configuration = {
554 systemd.paths.test-watch = {
555 wantedBy = [ "paths.target" ];
556 pathConfig.PathExists = "/testpath";
557 };
558 systemd.services.test-watch = {
559 serviceConfig = {
560 Type = "oneshot";
561 RemainAfterExit = true;
562 ExecStart = "${pkgs.coreutils}/bin/touch /testpath-modified";
563 };
564 };
565 };
566
567 pathModified.configuration = {
568 imports = [ path.configuration ];
569 systemd.paths.test-watch.pathConfig.PathExists = lib.mkForce "/testpath2";
570 };
571
572 slice.configuration = {
573 systemd.slices.testslice.sliceConfig.MemoryMax = "1"; # don't allow memory allocation
574 systemd.services.testservice = {
575 serviceConfig = {
576 Type = "oneshot";
577 RemainAfterExit = true;
578 ExecStart = "${pkgs.coreutils}/bin/true";
579 Slice = "testslice.slice";
580 };
581 };
582 };
583
584 sliceModified.configuration = {
585 imports = [ slice.configuration ];
586 systemd.slices.testslice.sliceConfig.MemoryMax = lib.mkForce null;
587 };
588 };
589 };
590
591 other = {
592 users.mutableUsers = true;
593 };
594 };
595
596 testScript = { nodes, ... }: let
597 originalSystem = nodes.machine.system.build.toplevel;
598 otherSystem = nodes.other.system.build.toplevel;
599 machine = nodes.machine.system.build.toplevel;
600
601 # Ensures failures pass through using pipefail, otherwise failing to
602 # switch-to-configuration is hidden by the success of `tee`.
603 stderrRunner = pkgs.writeScript "stderr-runner" ''
604 #! ${pkgs.runtimeShell}
605 set -e
606 set -o pipefail
607 exec env -i "$@" | tee /dev/stderr
608 '';
609
610 # Returns a comma separated representation of the given list in sorted
611 # order, that matches the output format of switch-to-configuration.pl
612 sortedUnits = xs: lib.concatStringsSep ", " (builtins.sort builtins.lessThan xs);
613 in /* python */ ''
614 def switch_to_specialisation(system, name, action="test", fail=False):
615 if name == "":
616 switcher = f"{system}/bin/switch-to-configuration"
617 else:
618 switcher = f"{system}/specialisation/{name}/bin/switch-to-configuration"
619 return run_switch(switcher, action, fail)
620
621 # like above but stc = switcher
622 def run_switch(switcher, action="test", fail=False):
623 out = machine.fail(f"{switcher} {action} 2>&1") if fail \
624 else machine.succeed(f"{switcher} {action} 2>&1")
625 assert_lacks(out, "switch-to-configuration line") # Perl warnings
626 return out
627
628 def assert_contains(haystack, needle):
629 if needle not in haystack:
630 print("The haystack that will cause the following exception is:")
631 print("---")
632 print(haystack)
633 print("---")
634 raise Exception(f"Expected string '{needle}' was not found")
635
636 def assert_lacks(haystack, needle):
637 if needle in haystack:
638 print("The haystack that will cause the following exception is:")
639 print("---")
640 print(haystack, end="")
641 print("---")
642 raise Exception(f"Unexpected string '{needle}' was found")
643
644
645 machine.wait_for_unit("multi-user.target")
646
647 machine.succeed(
648 "${stderrRunner} ${originalSystem}/bin/switch-to-configuration test"
649 )
650 # This tests whether the /etc/os-release parser works which is a fallback
651 # when /etc/NIXOS is missing. If the parser does not work, switch-to-configuration
652 # would fail.
653 machine.succeed("rm /etc/NIXOS")
654 machine.succeed(
655 "${stderrRunner} ${otherSystem}/bin/switch-to-configuration test"
656 )
657
658
659 with subtest("actions"):
660 # boot action
661 machine.fail("test -f /tmp/bootloader-installed")
662 out = switch_to_specialisation("${machine}", "simpleService", action="boot")
663 assert_contains(out, "installing dummy bootloader")
664 assert_lacks(out, "activating the configuration...") # good indicator of a system activation
665 machine.succeed("test -f /tmp/bootloader-installed")
666 machine.succeed("rm /tmp/bootloader-installed")
667
668 # switch action
669 machine.fail("test -f /tmp/bootloader-installed")
670 out = switch_to_specialisation("${machine}", "", action="switch")
671 assert_contains(out, "installing dummy bootloader")
672 assert_contains(out, "activating the configuration...") # good indicator of a system activation
673 machine.succeed("test -f /tmp/bootloader-installed")
674
675 # test and dry-activate actions are tested further down below
676
677 # invalid action fails the script
678 switch_to_specialisation("${machine}", "", action="broken-action", fail=True)
679 # no action fails the script
680 assert "Usage:" in machine.fail("${machine}/bin/switch-to-configuration 2>&1")
681
682 with subtest("init interface version"):
683 # Do not try to switch to an invalid init interface version
684 assert "incompatible" in switch_to_specialisation("${machine}", "brokenInitInterface", fail=True)
685
686 with subtest("systemd restarts"):
687 # systemd is restarted when its system.conf changes
688 out = switch_to_specialisation("${machine}", "modifiedSystemConf")
689 assert_contains(out, "restarting systemd...")
690
691 with subtest("continuing from an aborted switch"):
692 # An aborted switch will write into a file what it tried to start
693 # and a second switch should continue from this
694 machine.succeed("echo dbus.service > /run/nixos/start-list")
695 out = switch_to_specialisation("${machine}", "modifiedSystemConf")
696 assert_contains(out, "starting the following units: dbus.service\n")
697
698 with subtest("fstab mounts"):
699 switch_to_specialisation("${machine}", "")
700 # add a mountpoint
701 out = switch_to_specialisation("${machine}", "addedMount")
702 assert_lacks(out, "stopping the following units:")
703 assert_lacks(out, "NOT restarting the following changed units:")
704 assert_lacks(out, "\nrestarting the following units:")
705 assert_lacks(out, "\nstarting the following units:")
706 assert_contains(out, "the following new units were started: test.mount\n")
707 # modify the mountpoint's options
708 out = switch_to_specialisation("${machine}", "addedMountOptsModified")
709 assert_lacks(out, "stopping the following units:")
710 assert_lacks(out, "NOT restarting the following changed units:")
711 assert_contains(out, "reloading the following units: test.mount\n")
712 assert_lacks(out, "\nrestarting the following units:")
713 assert_lacks(out, "\nstarting the following units:")
714 assert_lacks(out, "the following new units were started:")
715 # modify the device
716 out = switch_to_specialisation("${machine}", "addedMountDevModified")
717 assert_lacks(out, "stopping the following units:")
718 assert_lacks(out, "NOT restarting the following changed units:")
719 assert_lacks(out, "reloading the following units:")
720 assert_contains(out, "\nrestarting the following units: test.mount\n")
721 assert_lacks(out, "\nstarting the following units:")
722 assert_lacks(out, "the following new units were started:")
723 # modify both
724 out = switch_to_specialisation("${machine}", "addedMount")
725 assert_lacks(out, "stopping the following units:")
726 assert_lacks(out, "NOT restarting the following changed units:")
727 assert_lacks(out, "reloading the following units:")
728 assert_contains(out, "\nrestarting the following units: test.mount\n")
729 assert_lacks(out, "\nstarting the following units:")
730 assert_lacks(out, "the following new units were started:")
731 # remove the mount
732 out = switch_to_specialisation("${machine}", "")
733 assert_contains(out, "stopping the following units: test.mount\n")
734 assert_lacks(out, "NOT restarting the following changed units:")
735 assert_contains(out, "reloading the following units: dbus.service\n")
736 assert_lacks(out, "\nrestarting the following units:")
737 assert_lacks(out, "\nstarting the following units:")
738 assert_lacks(out, "the following new units were started:")
739 # change something about the / mount
740 out = switch_to_specialisation("${machine}", "storeMountModified")
741 assert_lacks(out, "stopping the following units:")
742 assert_contains(out, "NOT restarting the following changed units: -.mount")
743 assert_contains(out, "reloading the following units: dbus.service\n")
744 assert_lacks(out, "\nrestarting the following units:")
745 assert_lacks(out, "\nstarting the following units:")
746 assert_lacks(out, "the following new units were started:")
747
748 with subtest("swaps"):
749 switch_to_specialisation("${machine}", "")
750 # add a swap
751 out = switch_to_specialisation("${machine}", "swap")
752 assert_lacks(out, "stopping the following units:")
753 assert_lacks(out, "NOT restarting the following changed units:")
754 assert_contains(out, "reloading the following units: dbus.service\n")
755 assert_lacks(out, "\nrestarting the following units:")
756 assert_lacks(out, "\nstarting the following units:")
757 assert_contains(out, "the following new units were started: swapfile.swap")
758 # remove it
759 out = switch_to_specialisation("${machine}", "")
760 assert_contains(out, "stopping swap device: /swapfile")
761 assert_lacks(out, "stopping the following units:")
762 assert_lacks(out, "NOT restarting the following changed units:")
763 assert_contains(out, "reloading the following units: dbus.service\n")
764 assert_lacks(out, "\nrestarting the following units:")
765 assert_lacks(out, "\nstarting the following units:")
766 assert_lacks(out, "the following new units were started:")
767
768 with subtest("services"):
769 switch_to_specialisation("${machine}", "")
770 # Nothing happens when nothing is changed
771 out = switch_to_specialisation("${machine}", "")
772 assert_lacks(out, "stopping the following units:")
773 assert_lacks(out, "NOT restarting the following changed units:")
774 assert_lacks(out, "reloading the following units:")
775 assert_lacks(out, "\nrestarting the following units:")
776 assert_lacks(out, "\nstarting the following units:")
777 assert_lacks(out, "the following new units were started:")
778
779 # Start a simple service
780 out = switch_to_specialisation("${machine}", "simpleService")
781 assert_lacks(out, "installing dummy bootloader") # test does not install a bootloader
782 assert_lacks(out, "stopping the following units:")
783 assert_lacks(out, "NOT restarting the following changed units:")
784 assert_contains(out, "reloading the following units: dbus.service\n") # huh
785 assert_lacks(out, "\nrestarting the following units:")
786 assert_lacks(out, "\nstarting the following units:")
787 assert_contains(out, "the following new units were started: test.service\n")
788
789 # Not changing anything doesn't do anything
790 out = switch_to_specialisation("${machine}", "simpleService")
791 assert_lacks(out, "stopping the following units:")
792 assert_lacks(out, "NOT restarting the following changed units:")
793 assert_lacks(out, "reloading the following units:")
794 assert_lacks(out, "\nrestarting the following units:")
795 assert_lacks(out, "\nstarting the following units:")
796 assert_lacks(out, "the following new units were started:")
797
798 # Only changing the description does nothing
799 out = switch_to_specialisation("${machine}", "simpleServiceDifferentDescription")
800 assert_lacks(out, "stopping the following units:")
801 assert_lacks(out, "NOT restarting the following changed units:")
802 assert_lacks(out, "reloading the following units:")
803 assert_lacks(out, "\nrestarting the following units:")
804 assert_lacks(out, "\nstarting the following units:")
805 assert_lacks(out, "the following new units were started:")
806
807 # Restart the simple service
808 out = switch_to_specialisation("${machine}", "simpleServiceModified")
809 assert_contains(out, "stopping the following units: test.service\n")
810 assert_lacks(out, "NOT restarting the following changed units:")
811 assert_lacks(out, "reloading the following units:")
812 assert_lacks(out, "\nrestarting the following units:")
813 assert_contains(out, "\nstarting the following units: test.service\n")
814 assert_lacks(out, "the following new units were started:")
815
816 # Restart the service with stopIfChanged=false
817 out = switch_to_specialisation("${machine}", "simpleServiceNostop")
818 assert_lacks(out, "stopping the following units:")
819 assert_lacks(out, "NOT restarting the following changed units:")
820 assert_lacks(out, "reloading the following units:")
821 assert_contains(out, "\nrestarting the following units: test.service\n")
822 assert_lacks(out, "\nstarting the following units:")
823 assert_lacks(out, "the following new units were started:")
824
825 # Reload the service with reloadIfChanged=true
826 out = switch_to_specialisation("${machine}", "simpleServiceReload")
827 assert_lacks(out, "stopping the following units:")
828 assert_lacks(out, "NOT restarting the following changed units:")
829 assert_contains(out, "reloading the following units: test.service\n")
830 assert_lacks(out, "\nrestarting the following units:")
831 assert_lacks(out, "\nstarting the following units:")
832 assert_lacks(out, "the following new units were started:")
833
834 # Nothing happens when restartIfChanged=false
835 out = switch_to_specialisation("${machine}", "simpleServiceNorestart")
836 assert_lacks(out, "stopping the following units:")
837 assert_contains(out, "NOT restarting the following changed units: test.service\n")
838 assert_lacks(out, "reloading the following units:")
839 assert_lacks(out, "\nrestarting the following units:")
840 assert_lacks(out, "\nstarting the following units:")
841 assert_lacks(out, "the following new units were started:")
842
843 # Dry mode shows different messages
844 out = switch_to_specialisation("${machine}", "simpleService", action="dry-activate")
845 assert_lacks(out, "stopping the following units:")
846 assert_lacks(out, "NOT restarting the following changed units:")
847 assert_lacks(out, "reloading the following units:")
848 assert_lacks(out, "\nrestarting the following units:")
849 assert_lacks(out, "\nstarting the following units:")
850 assert_lacks(out, "the following new units were started:")
851 assert_contains(out, "would start the following units: test.service\n")
852
853 out = switch_to_specialisation("${machine}", "", action="test")
854
855 # Ensure the service can be started when the activation script isn't in toplevel
856 # This is a lot like "Start a simple service", except activation-only deps could be gc-ed
857 out = run_switch("${nodes.machine.specialisation.simpleServiceSeparateActivationScript.configuration.system.build.separateActivationScript}/bin/switch-to-configuration");
858 assert_lacks(out, "installing dummy bootloader") # test does not install a bootloader
859 assert_lacks(out, "stopping the following units:")
860 assert_lacks(out, "NOT restarting the following changed units:")
861 assert_contains(out, "reloading the following units: dbus.service\n") # huh
862 assert_lacks(out, "\nrestarting the following units:")
863 assert_lacks(out, "\nstarting the following units:")
864 assert_contains(out, "the following new units were started: test.service\n")
865 machine.succeed("! test -e /run/current-system/activate")
866 machine.succeed("! test -e /run/current-system/dry-activate")
867 machine.succeed("! test -e /run/current-system/bin/switch-to-configuration")
868
869 # Ensure \ works in unit names
870 out = switch_to_specialisation("${machine}", "unitWithBackslash")
871 assert_contains(out, "stopping the following units: test.service\n")
872 assert_lacks(out, "NOT restarting the following changed units:")
873 assert_lacks(out, "reloading the following units:")
874 assert_lacks(out, "\nrestarting the following units:")
875 assert_lacks(out, "\nstarting the following units:")
876 assert_contains(out, "the following new units were started: escaped\\x2ddash.service\n")
877
878 out = switch_to_specialisation("${machine}", "unitWithBackslashModified")
879 assert_contains(out, "stopping the following units: escaped\\x2ddash.service\n")
880 assert_lacks(out, "NOT restarting the following changed units:")
881 assert_lacks(out, "reloading the following units:")
882 assert_lacks(out, "\nrestarting the following units:")
883 assert_contains(out, "\nstarting the following units: escaped\\x2ddash.service\n")
884 assert_lacks(out, "the following new units were started:")
885
886 # Ensure units can start with a dash
887 out = switch_to_specialisation("${machine}", "unitStartingWithDash")
888 assert_contains(out, "stopping the following units: escaped\\x2ddash.service\n")
889 assert_lacks(out, "NOT restarting the following changed units:")
890 assert_lacks(out, "reloading the following units:")
891 assert_lacks(out, "\nrestarting the following units:")
892 assert_lacks(out, "\nstarting the following units:")
893 assert_contains(out, "the following new units were started: -.service\n")
894
895 # The regression only occurs when reloading units
896 out = switch_to_specialisation("${machine}", "unitStartingWithDashModified")
897 assert_lacks(out, "stopping the following units:")
898 assert_lacks(out, "NOT restarting the following changed units:")
899 assert_contains(out, "reloading the following units: -.service")
900 assert_lacks(out, "\nrestarting the following units:")
901 assert_lacks(out, "\nstarting the following units:")
902 assert_lacks(out, "the following new units were started:")
903
904 # Ensure units that require changed units are properly reloaded
905 out = switch_to_specialisation("${machine}", "unitWithRequirement")
906 assert_contains(out, "stopping the following units: -.service\n")
907 assert_lacks(out, "NOT restarting the following changed units:")
908 assert_lacks(out, "reloading the following units:")
909 assert_lacks(out, "\nrestarting the following units:")
910 assert_lacks(out, "\nstarting the following units:")
911 assert_contains(out, "the following new units were started: required-service.service, test-service.service\n")
912
913 out = switch_to_specialisation("${machine}", "unitWithRequirementModified")
914 assert_contains(out, "stopping the following units: required-service.service\n")
915 assert_lacks(out, "NOT restarting the following changed units:")
916 assert_lacks(out, "reloading the following units:")
917 assert_lacks(out, "\nrestarting the following units:")
918 assert_contains(out, "\nstarting the following units: required-service.service, test-service.service\n")
919 assert_lacks(out, "the following new units were started:")
920
921 # Unless the unit asks to be not restarted
922 out = switch_to_specialisation("${machine}", "unitWithRequirementModifiedNostart")
923 assert_contains(out, "stopping the following units: required-service.service\n")
924 assert_lacks(out, "NOT restarting the following changed units:")
925 assert_lacks(out, "reloading the following units:")
926 assert_lacks(out, "\nrestarting the following units:")
927 assert_contains(out, "\nstarting the following units: required-service.service\n")
928 assert_lacks(out, "the following new units were started:")
929
930 # Ensure templated units are restarted when the base unit changes
931 switch_to_specialisation("${machine}", "unitWithTemplate")
932 out = switch_to_specialisation("${machine}", "unitWithTemplateModified")
933 assert_contains(out, "stopping the following units: instantiated@one.service, instantiated@two.service\n")
934 assert_lacks(out, "NOT restarting the following changed units:")
935 assert_lacks(out, "reloading the following units:")
936 assert_lacks(out, "\nrestarting the following units:")
937 assert_contains(out, "\nstarting the following units: instantiated@one.service, instantiated@two.service\n")
938 assert_lacks(out, "the following new units were started:")
939
940 with subtest("failing units"):
941 # Let the simple service fail
942 switch_to_specialisation("${machine}", "simpleServiceModified")
943 out = switch_to_specialisation("${machine}", "simpleServiceFailing", fail=True)
944 assert_contains(out, "stopping the following units: test.service\n")
945 assert_lacks(out, "NOT restarting the following changed units:")
946 assert_lacks(out, "reloading the following units:")
947 assert_lacks(out, "\nrestarting the following units:")
948 assert_contains(out, "\nstarting the following units: test.service\n")
949 assert_lacks(out, "the following new units were started:")
950 assert_contains(out, "warning: the following units failed: test.service\n")
951 assert_contains(out, "Main PID:") # output of systemctl
952
953 # A unit that gets into autorestart without failing is not treated as failed
954 out = switch_to_specialisation("${machine}", "autorestartService")
955 assert_lacks(out, "stopping the following units:")
956 assert_lacks(out, "NOT restarting the following changed units:")
957 assert_lacks(out, "reloading the following units:")
958 assert_lacks(out, "\nrestarting the following units:")
959 assert_lacks(out, "\nstarting the following units:")
960 assert_contains(out, "the following new units were started: autorestart.service\n")
961 machine.systemctl('stop autorestart.service') # cancel the 20y timer
962
963 # Switching to the same system should do nothing (especially not treat the unit as failed)
964 out = switch_to_specialisation("${machine}", "autorestartService")
965 assert_lacks(out, "stopping the following units:")
966 assert_lacks(out, "NOT restarting the following changed units:")
967 assert_lacks(out, "reloading the following units:")
968 assert_lacks(out, "\nrestarting the following units:")
969 assert_lacks(out, "\nstarting the following units:")
970 assert_contains(out, "the following new units were started: autorestart.service\n")
971 machine.systemctl('stop autorestart.service') # cancel the 20y timer
972
973 # If systemd thinks the unit has failed and is in autorestart, we should show it as failed
974 out = switch_to_specialisation("${machine}", "autorestartServiceFailing", fail=True)
975 assert_lacks(out, "stopping the following units:")
976 assert_lacks(out, "NOT restarting the following changed units:")
977 assert_lacks(out, "reloading the following units:")
978 assert_lacks(out, "\nrestarting the following units:")
979 assert_lacks(out, "\nstarting the following units:")
980 assert_lacks(out, "the following new units were started:")
981 assert_contains(out, "warning: the following units failed: autorestart.service\n")
982 assert_contains(out, "Main PID:") # output of systemctl
983
984 with subtest("unit file parser"):
985 # Switch to a well-known state
986 switch_to_specialisation("${machine}", "simpleServiceNostop")
987
988 # Add a section
989 out = switch_to_specialisation("${machine}", "simpleServiceWithExtraSection")
990 assert_lacks(out, "stopping the following units:")
991 assert_lacks(out, "NOT restarting the following changed units:")
992 assert_lacks(out, "reloading the following units:")
993 assert_contains(out, "\nrestarting the following units: test.service\n")
994 assert_lacks(out, "\nstarting the following units:")
995 assert_lacks(out, "the following new units were started:")
996
997 # Rename it
998 out = switch_to_specialisation("${machine}", "simpleServiceWithExtraSectionOtherName")
999 assert_lacks(out, "stopping the following units:")
1000 assert_lacks(out, "NOT restarting the following changed units:")
1001 assert_lacks(out, "reloading the following units:")
1002 assert_contains(out, "\nrestarting the following units: test.service\n")
1003 assert_lacks(out, "\nstarting the following units:")
1004 assert_lacks(out, "the following new units were started:")
1005
1006 # Remove it
1007 out = switch_to_specialisation("${machine}", "simpleServiceNostop")
1008 assert_lacks(out, "stopping the following units:")
1009 assert_lacks(out, "NOT restarting the following changed units:")
1010 assert_lacks(out, "reloading the following units:")
1011 assert_contains(out, "\nrestarting the following units: test.service\n")
1012 assert_lacks(out, "\nstarting the following units:")
1013 assert_lacks(out, "the following new units were started:")
1014
1015 # [Install] section is ignored
1016 out = switch_to_specialisation("${machine}", "simpleServiceWithInstallSection")
1017 assert_lacks(out, "stopping the following units:")
1018 assert_lacks(out, "NOT restarting the following changed units:")
1019 assert_lacks(out, "reloading the following units:")
1020 assert_lacks(out, "\nrestarting the following units:")
1021 assert_lacks(out, "\nstarting the following units:")
1022 assert_lacks(out, "the following new units were started:")
1023
1024 # Add a key
1025 out = switch_to_specialisation("${machine}", "simpleServiceWithExtraKey")
1026 assert_lacks(out, "stopping the following units:")
1027 assert_lacks(out, "NOT restarting the following changed units:")
1028 assert_lacks(out, "reloading the following units:")
1029 assert_contains(out, "\nrestarting the following units: test.service\n")
1030 assert_lacks(out, "\nstarting the following units:")
1031 assert_lacks(out, "the following new units were started:")
1032
1033 # Change its value
1034 out = switch_to_specialisation("${machine}", "simpleServiceWithExtraKeyOtherValue")
1035 assert_lacks(out, "stopping the following units:")
1036 assert_lacks(out, "NOT restarting the following changed units:")
1037 assert_lacks(out, "reloading the following units:")
1038 assert_contains(out, "\nrestarting the following units: test.service\n")
1039 assert_lacks(out, "\nstarting the following units:")
1040 assert_lacks(out, "the following new units were started:")
1041
1042 # Rename it
1043 out = switch_to_specialisation("${machine}", "simpleServiceWithExtraKeyOtherName")
1044 assert_lacks(out, "stopping the following units:")
1045 assert_lacks(out, "NOT restarting the following changed units:")
1046 assert_lacks(out, "reloading the following units:")
1047 assert_contains(out, "\nrestarting the following units: test.service\n")
1048 assert_lacks(out, "\nstarting the following units:")
1049 assert_lacks(out, "the following new units were started:")
1050
1051 # Remove it
1052 out = switch_to_specialisation("${machine}", "simpleServiceNostop")
1053 assert_lacks(out, "stopping the following units:")
1054 assert_lacks(out, "NOT restarting the following changed units:")
1055 assert_lacks(out, "reloading the following units:")
1056 assert_contains(out, "\nrestarting the following units: test.service\n")
1057 assert_lacks(out, "\nstarting the following units:")
1058 assert_lacks(out, "the following new units were started:")
1059
1060 # Add a reload trigger
1061 out = switch_to_specialisation("${machine}", "simpleServiceReloadTrigger")
1062 assert_lacks(out, "stopping the following units:")
1063 assert_lacks(out, "NOT restarting the following changed units:")
1064 assert_contains(out, "reloading the following units: test.service\n")
1065 assert_lacks(out, "\nrestarting the following units:")
1066 assert_lacks(out, "\nstarting the following units:")
1067 assert_lacks(out, "the following new units were started:")
1068
1069 # Modify the reload trigger
1070 out = switch_to_specialisation("${machine}", "simpleServiceReloadTriggerModified")
1071 assert_lacks(out, "stopping the following units:")
1072 assert_lacks(out, "NOT restarting the following changed units:")
1073 assert_contains(out, "reloading the following units: test.service\n")
1074 assert_lacks(out, "\nrestarting the following units:")
1075 assert_lacks(out, "\nstarting the following units:")
1076 assert_lacks(out, "the following new units were started:")
1077
1078 # Modify the reload trigger and something else
1079 out = switch_to_specialisation("${machine}", "simpleServiceReloadTriggerModifiedAndSomethingElse")
1080 assert_lacks(out, "stopping the following units:")
1081 assert_lacks(out, "NOT restarting the following changed units:")
1082 assert_lacks(out, "reloading the following units:")
1083 assert_contains(out, "\nrestarting the following units: test.service\n")
1084 assert_lacks(out, "\nstarting the following units:")
1085 assert_lacks(out, "the following new units were started:")
1086
1087 # Remove the reload trigger
1088 out = switch_to_specialisation("${machine}", "simpleServiceReloadTriggerModifiedSomethingElse")
1089 assert_lacks(out, "stopping the following units:")
1090 assert_lacks(out, "NOT restarting the following changed units:")
1091 assert_lacks(out, "reloading the following units:")
1092 assert_lacks(out, "\nrestarting the following units:")
1093 assert_lacks(out, "\nstarting the following units:")
1094 assert_lacks(out, "the following new units were started:")
1095
1096 with subtest("restart and reload by activation script"):
1097 switch_to_specialisation("${machine}", "simpleServiceNorestart")
1098 out = switch_to_specialisation("${machine}", "restart-and-reload-by-activation-script")
1099 assert_contains(out, "stopping the following units: test.service\n")
1100 assert_lacks(out, "NOT restarting the following changed units:")
1101 assert_lacks(out, "reloading the following units:")
1102 assert_lacks(out, "restarting the following units:")
1103 assert_contains(out, "\nstarting the following units: ${sortedUnits [
1104 "no-restart-service.service"
1105 "reload-triggers-and-restart-by-as.service"
1106 "simple-reload-service.service"
1107 "simple-restart-service.service"
1108 "simple-service.service"
1109 "templated-no-restart-service@instance.service"
1110 "templated-reload-triggers-and-restart-by-as@instance.service"
1111 "templated-simple-reload-service@instance.service"
1112 "templated-simple-restart-service@instance.service"
1113 "templated-simple-service@instance.service"
1114 ]}\n")
1115 assert_contains(out, "the following new units were started: ${sortedUnits [
1116 "no-restart-service.service"
1117 "reload-triggers-and-restart-by-as.service"
1118 "reload-triggers-and-restart.service"
1119 "reload-triggers.service"
1120 "simple-reload-service.service"
1121 "simple-restart-service.service"
1122 "simple-service.service"
1123 "system-templated\\\\x2dno\\\\x2drestart\\\\x2dservice.slice"
1124 "system-templated\\\\x2dreload\\\\x2dtriggers.slice"
1125 "system-templated\\\\x2dreload\\\\x2dtriggers\\\\x2dand\\\\x2drestart.slice"
1126 "system-templated\\\\x2dreload\\\\x2dtriggers\\\\x2dand\\\\x2drestart\\\\x2dby\\\\x2das.slice"
1127 "system-templated\\\\x2dsimple\\\\x2dreload\\\\x2dservice.slice"
1128 "system-templated\\\\x2dsimple\\\\x2drestart\\\\x2dservice.slice"
1129 "system-templated\\\\x2dsimple\\\\x2dservice.slice"
1130 "templated-no-restart-service@instance.service"
1131 "templated-reload-triggers-and-restart-by-as@instance.service"
1132 "templated-reload-triggers-and-restart@instance.service"
1133 "templated-reload-triggers@instance.service"
1134 "templated-simple-reload-service@instance.service"
1135 "templated-simple-restart-service@instance.service"
1136 "templated-simple-service@instance.service"
1137 ]}\n")
1138 # Switch to the same system where the example services get restarted
1139 # and reloaded by the activation script
1140 out = switch_to_specialisation("${machine}", "restart-and-reload-by-activation-script")
1141 assert_lacks(out, "stopping the following units:")
1142 assert_lacks(out, "NOT restarting the following changed units:")
1143 assert_contains(out, "reloading the following units: ${sortedUnits [
1144 "reload-triggers-and-restart.service"
1145 "reload-triggers.service"
1146 "simple-reload-service.service"
1147 "templated-reload-triggers-and-restart@instance.service"
1148 "templated-reload-triggers@instance.service"
1149 "templated-simple-reload-service@instance.service"
1150 ]}\n")
1151 assert_contains(out, "restarting the following units: ${sortedUnits [
1152 "reload-triggers-and-restart-by-as.service"
1153 "simple-restart-service.service"
1154 "simple-service.service"
1155 "templated-reload-triggers-and-restart-by-as@instance.service"
1156 "templated-simple-restart-service@instance.service"
1157 "templated-simple-service@instance.service"
1158 ]}\n")
1159 assert_lacks(out, "\nstarting the following units:")
1160 assert_lacks(out, "the following new units were started:")
1161 # Switch to the same system and see if the service gets restarted when it's modified
1162 # while the fact that it's supposed to be reloaded by the activation script is ignored.
1163 out = switch_to_specialisation("${machine}", "restart-and-reload-by-activation-script-modified")
1164 assert_lacks(out, "stopping the following units:")
1165 assert_lacks(out, "NOT restarting the following changed units:")
1166 assert_contains(out, "reloading the following units: ${sortedUnits [
1167 "reload-triggers.service"
1168 "simple-reload-service.service"
1169 "templated-reload-triggers@instance.service"
1170 "templated-simple-reload-service@instance.service"
1171 ]}\n")
1172 assert_contains(out, "restarting the following units: ${sortedUnits [
1173 "reload-triggers-and-restart-by-as.service"
1174 "reload-triggers-and-restart.service"
1175 "simple-restart-service.service"
1176 "simple-service.service"
1177 "templated-reload-triggers-and-restart-by-as@instance.service"
1178 "templated-reload-triggers-and-restart@instance.service"
1179 "templated-simple-restart-service@instance.service"
1180 "templated-simple-service@instance.service"
1181 ]}\n")
1182 assert_lacks(out, "\nstarting the following units:")
1183 assert_lacks(out, "the following new units were started:")
1184 # The same, but in dry mode
1185 out = switch_to_specialisation("${machine}", "restart-and-reload-by-activation-script", action="dry-activate")
1186 assert_lacks(out, "would stop the following units:")
1187 assert_lacks(out, "would NOT stop the following changed units:")
1188 assert_contains(out, "would reload the following units: ${sortedUnits [
1189 "reload-triggers.service"
1190 "simple-reload-service.service"
1191 "templated-reload-triggers@instance.service"
1192 "templated-simple-reload-service@instance.service"
1193 ]}\n")
1194 assert_contains(out, "would restart the following units: ${sortedUnits [
1195 "reload-triggers-and-restart-by-as.service"
1196 "reload-triggers-and-restart.service"
1197 "simple-restart-service.service"
1198 "simple-service.service"
1199 "templated-reload-triggers-and-restart-by-as@instance.service"
1200 "templated-reload-triggers-and-restart@instance.service"
1201 "templated-simple-restart-service@instance.service"
1202 "templated-simple-service@instance.service"
1203 ]}\n")
1204 assert_lacks(out, "\nwould start the following units:")
1205
1206 with subtest("socket-activated services"):
1207 # Socket-activated services don't get started, just the socket
1208 machine.fail("[ -S /run/test.sock ]")
1209 out = switch_to_specialisation("${machine}", "simple-socket")
1210 # assert_lacks(out, "stopping the following units:") not relevant
1211 assert_lacks(out, "NOT restarting the following changed units:")
1212 assert_lacks(out, "reloading the following units:")
1213 assert_lacks(out, "\nrestarting the following units:")
1214 assert_lacks(out, "\nstarting the following units:")
1215 assert_contains(out, "the following new units were started: socket-activated.socket\n")
1216 machine.succeed("[ -S /run/test.sock ]")
1217
1218 # Changing a non-activated service does nothing
1219 out = switch_to_specialisation("${machine}", "simple-socket-service-modified")
1220 assert_lacks(out, "stopping the following units:")
1221 assert_lacks(out, "NOT restarting the following changed units:")
1222 assert_lacks(out, "reloading the following units:")
1223 assert_lacks(out, "\nrestarting the following units:")
1224 assert_lacks(out, "\nstarting the following units:")
1225 assert_lacks(out, "the following new units were started:")
1226 machine.succeed("[ -S /run/test.sock ]")
1227 # The unit is properly activated when the socket is accessed
1228 if machine.succeed("socat - UNIX-CONNECT:/run/test.sock") != "hello":
1229 raise Exception("Socket was not properly activated") # idk how that would happen tbh
1230
1231 # Changing an activated service with stopIfChanged=false restarts the service
1232 out = switch_to_specialisation("${machine}", "simple-socket")
1233 assert_lacks(out, "stopping the following units:")
1234 assert_lacks(out, "NOT restarting the following changed units:")
1235 assert_lacks(out, "reloading the following units:")
1236 assert_contains(out, "\nrestarting the following units: socket-activated.service\n")
1237 assert_lacks(out, "\nstarting the following units:")
1238 assert_lacks(out, "the following new units were started:")
1239 machine.succeed("[ -S /run/test.sock ]")
1240 # Socket-activation of the unit still works
1241 if machine.succeed("socat - UNIX-CONNECT:/run/test.sock") != "hello":
1242 raise Exception("Socket was not properly activated after the service was restarted")
1243
1244 # Changing an activated service with stopIfChanged=true stops the service and
1245 # socket and starts the socket
1246 out = switch_to_specialisation("${machine}", "simple-socket-stop-if-changed")
1247 assert_contains(out, "stopping the following units: socket-activated.service, socket-activated.socket\n")
1248 assert_lacks(out, "NOT restarting the following changed units:")
1249 assert_lacks(out, "reloading the following units:")
1250 assert_lacks(out, "\nrestarting the following units:")
1251 assert_contains(out, "\nstarting the following units: socket-activated.socket\n")
1252 assert_lacks(out, "the following new units were started:")
1253 machine.succeed("[ -S /run/test.sock ]")
1254 # Socket-activation of the unit still works
1255 if machine.succeed("socat - UNIX-CONNECT:/run/test.sock") != "hello":
1256 raise Exception("Socket was not properly activated after the service was restarted")
1257
1258 # Changing a reload trigger of a socket-activated unit only reloads it
1259 out = switch_to_specialisation("${machine}", "simple-socket-stop-if-changed-and-reloadtrigger")
1260 assert_lacks(out, "stopping the following units:")
1261 assert_lacks(out, "NOT restarting the following changed units:")
1262 assert_contains(out, "reloading the following units: socket-activated.service\n")
1263 assert_lacks(out, "\nrestarting the following units:")
1264 assert_lacks(out, "\nstarting the following units: socket-activated.socket")
1265 assert_lacks(out, "the following new units were started:")
1266 machine.succeed("[ -S /run/test.sock ]")
1267 # Socket-activation of the unit still works
1268 if machine.succeed("socat - UNIX-CONNECT:/run/test.sock") != "hello":
1269 raise Exception("Socket was not properly activated after the service was restarted")
1270
1271 with subtest("mounts"):
1272 switch_to_specialisation("${machine}", "mount")
1273 out = machine.succeed("mount | grep 'on /testmount'")
1274 assert_contains(out, "size=1024k")
1275 # Changing options reloads the unit
1276 out = switch_to_specialisation("${machine}", "mountOptionsModified")
1277 assert_lacks(out, "stopping the following units:")
1278 assert_lacks(out, "NOT restarting the following changed units:")
1279 assert_contains(out, "reloading the following units: testmount.mount\n")
1280 assert_lacks(out, "\nrestarting the following units:")
1281 assert_lacks(out, "\nstarting the following units:")
1282 assert_lacks(out, "the following new units were started:")
1283 # It changed
1284 out = machine.succeed("mount | grep 'on /testmount'")
1285 assert_contains(out, "size=10240k")
1286 # Changing anything but `Options=` restarts the unit
1287 out = switch_to_specialisation("${machine}", "mountModified")
1288 assert_lacks(out, "stopping the following units:")
1289 assert_lacks(out, "NOT restarting the following changed units:")
1290 assert_lacks(out, "reloading the following units:")
1291 assert_contains(out, "\nrestarting the following units: testmount.mount\n")
1292 assert_lacks(out, "\nstarting the following units:")
1293 assert_lacks(out, "the following new units were started:")
1294 # It changed
1295 out = machine.succeed("mount | grep 'on /testmount'")
1296 assert_contains(out, "ramfs")
1297
1298 with subtest("timers"):
1299 switch_to_specialisation("${machine}", "timer")
1300 out = machine.succeed("systemctl show test-timer.timer")
1301 assert_contains(out, "OnCalendar=2014-03-25 02:59:56 UTC")
1302 out = switch_to_specialisation("${machine}", "timerModified")
1303 assert_lacks(out, "stopping the following units:")
1304 assert_lacks(out, "NOT restarting the following units:")
1305 assert_lacks(out, "reloading the following units:")
1306 assert_contains(out, "\nrestarting the following units: test-timer.timer\n")
1307 assert_lacks(out, "\nstarting the following units:")
1308 assert_lacks(out, "the following new units were started:")
1309 # It changed
1310 out = machine.succeed("systemctl show test-timer.timer")
1311 assert_contains(out, "OnCalendar=Fri 2012-11-23 16:00:00")
1312
1313 with subtest("targets"):
1314 # Modifying some special targets like hybrid-sleep.target does nothing
1315 out = switch_to_specialisation("${machine}", "hybridSleepModified")
1316 assert_contains(out, "stopping the following units: test-timer.timer\n")
1317 assert_lacks(out, "NOT restarting the following changed units:")
1318 assert_lacks(out, "reloading the following units:")
1319 assert_lacks(out, "\nrestarting the following units:")
1320 assert_lacks(out, "\nstarting the following units:")
1321 assert_lacks(out, "the following new units were started:")
1322
1323 # Adding a new target starts it
1324 out = switch_to_specialisation("${machine}", "target")
1325 assert_lacks(out, "stopping the following units:")
1326 assert_lacks(out, "NOT restarting the following changed units:")
1327 assert_lacks(out, "reloading the following units:")
1328 assert_lacks(out, "\nrestarting the following units:")
1329 assert_lacks(out, "\nstarting the following units:")
1330 assert_contains(out, "the following new units were started: test-target.target\n")
1331
1332 # Changing a target doesn't print anything because the unit is filtered
1333 machine.systemctl("start test-service.service")
1334 out = switch_to_specialisation("${machine}", "targetModified")
1335 assert_lacks(out, "stopping the following units:")
1336 assert_lacks(out, "NOT restarting the following changed units:")
1337 assert_lacks(out, "reloading the following units:")
1338 assert_lacks(out, "\nrestarting the following units:")
1339 assert_lacks(out, "\nstarting the following units:")
1340 assert_lacks(out, "the following new units were started:")
1341 machine.succeed("systemctl is-active test-service.service") # target was not restarted
1342
1343 # With X-StopOnReconfiguration, the target gets stopped and started
1344 out = switch_to_specialisation("${machine}", "targetModifiedStopOnReconfig")
1345 assert_lacks(out, "stopping the following units:")
1346 assert_lacks(out, "NOT restarting the following changed units:")
1347 assert_lacks(out, "reloading the following units:")
1348 assert_lacks(out, "\nrestarting the following units:")
1349 assert_lacks(out, "\nstarting the following units:")
1350 assert_lacks(out, "the following new units were started:")
1351 machine.fail("systemctl is-active test-service.servce") # target was restarted
1352
1353 # Remove the target by switching to the old specialisation
1354 out = switch_to_specialisation("${machine}", "timerModified")
1355 assert_contains(out, "stopping the following units: test-target.target\n")
1356 assert_lacks(out, "NOT restarting the following changed units:")
1357 assert_lacks(out, "reloading the following units:")
1358 assert_lacks(out, "\nrestarting the following units:")
1359 assert_lacks(out, "\nstarting the following units:")
1360 assert_contains(out, "the following new units were started: test-timer.timer\n")
1361
1362 with subtest("paths"):
1363 out = switch_to_specialisation("${machine}", "path")
1364 assert_contains(out, "stopping the following units: test-timer.timer\n")
1365 assert_lacks(out, "NOT restarting the following changed units:")
1366 assert_lacks(out, "reloading the following units:")
1367 assert_lacks(out, "\nrestarting the following units:")
1368 assert_lacks(out, "\nstarting the following units:")
1369 assert_contains(out, "the following new units were started: test-watch.path\n")
1370 machine.fail("test -f /testpath-modified")
1371
1372 # touch the file, unit should be triggered
1373 machine.succeed("touch /testpath")
1374 machine.wait_until_succeeds("test -f /testpath-modified")
1375 machine.succeed("rm /testpath /testpath-modified")
1376 machine.systemctl("stop test-watch.service")
1377 switch_to_specialisation("${machine}", "pathModified")
1378 machine.succeed("touch /testpath")
1379 machine.fail("test -f /testpath-modified")
1380 machine.succeed("touch /testpath2")
1381 machine.wait_until_succeeds("test -f /testpath-modified")
1382
1383 # This test ensures that changes to slice configuration get applied.
1384 # We test this by having a slice that allows no memory allocation at
1385 # all and starting a service within it. If the service crashes, the slice
1386 # is applied and if we modify the slice to allow memory allocation, the
1387 # service should successfully start.
1388 with subtest("slices"):
1389 machine.succeed("echo 0 > /proc/sys/vm/panic_on_oom") # allow OOMing
1390 out = switch_to_specialisation("${machine}", "slice")
1391 # assert_lacks(out, "stopping the following units:") not relevant
1392 assert_lacks(out, "NOT restarting the following changed units:")
1393 assert_lacks(out, "reloading the following units:")
1394 assert_lacks(out, "\nrestarting the following units:")
1395 assert_lacks(out, "\nstarting the following units:")
1396 assert_lacks(out, "the following new units were started:")
1397 machine.fail("systemctl start testservice.service")
1398
1399 out = switch_to_specialisation("${machine}", "sliceModified")
1400 assert_lacks(out, "stopping the following units:")
1401 assert_lacks(out, "NOT restarting the following changed units:")
1402 assert_lacks(out, "reloading the following units:")
1403 assert_lacks(out, "\nrestarting the following units:")
1404 assert_lacks(out, "\nstarting the following units:")
1405 assert_lacks(out, "the following new units were started:")
1406 machine.succeed("systemctl start testservice.service")
1407 machine.succeed("echo 1 > /proc/sys/vm/panic_on_oom") # disallow OOMing
1408 '';
1409})