333 lines
9.9 KiB
Nix
333 lines
9.9 KiB
Nix
{
|
|
lib,
|
|
system-manager,
|
|
system,
|
|
nix-vm-test,
|
|
}:
|
|
|
|
let
|
|
forEachUbuntuImage =
|
|
name:
|
|
{
|
|
modules,
|
|
testScriptFunction,
|
|
extraPathsToRegister ? [ ],
|
|
projectTest ? test: test.sandboxed,
|
|
}:
|
|
let
|
|
ubuntu = nix-vm-test.ubuntu;
|
|
in
|
|
lib.listToAttrs (
|
|
lib.flip map (lib.attrNames ubuntu.images) (
|
|
imageVersion:
|
|
let
|
|
toplevel = (
|
|
system-manager.lib.makeSystemConfig {
|
|
modules = modules ++ [
|
|
(
|
|
{ lib, pkgs, ... }:
|
|
{
|
|
options.hostPkgs = lib.mkOption {
|
|
type = lib.types.raw;
|
|
readOnly = true;
|
|
};
|
|
config.hostPkgs = pkgs;
|
|
}
|
|
)
|
|
];
|
|
}
|
|
);
|
|
inherit (toplevel.config) hostPkgs;
|
|
in
|
|
lib.nameValuePair "ubuntu-${imageVersion}-${name}" (
|
|
projectTest (
|
|
ubuntu.${imageVersion} {
|
|
testScript = testScriptFunction { inherit toplevel hostPkgs; };
|
|
extraPathsToRegister = extraPathsToRegister ++ [
|
|
toplevel
|
|
];
|
|
sharedDirs = { };
|
|
}
|
|
)
|
|
)
|
|
)
|
|
);
|
|
|
|
# To test reload and restart, we include two services, one that can be reloaded
|
|
# and one that cannot.
|
|
# The id parameter is a string that can be used to force reloading the services
|
|
# between two configs by changing their contents.
|
|
testModule =
|
|
id:
|
|
{ lib, pkgs, ... }:
|
|
{
|
|
systemd.services = {
|
|
has-reload = {
|
|
enable = true;
|
|
description = "service-reload";
|
|
serviceConfig = {
|
|
Type = "oneshot";
|
|
RemainAfterExit = true;
|
|
ExecReload = ''
|
|
${lib.getBin pkgs.coreutils}/bin/true
|
|
'';
|
|
};
|
|
wantedBy = [ "system-manager.target" ];
|
|
script = ''
|
|
echo "I can be reloaded (id: ${id})"
|
|
'';
|
|
};
|
|
has-no-reload = {
|
|
enable = true;
|
|
description = "service-no-reload";
|
|
serviceConfig.Type = "simple";
|
|
wantedBy = [ "system-manager.target" ];
|
|
script = ''
|
|
while true; do
|
|
echo "I cannot be reloaded (id: ${id})"
|
|
done
|
|
'';
|
|
};
|
|
};
|
|
};
|
|
|
|
newConfig = system-manager.lib.makeSystemConfig {
|
|
modules = [
|
|
(testModule "new")
|
|
(
|
|
{ lib, pkgs, ... }:
|
|
{
|
|
config = {
|
|
nixpkgs.hostPlatform = system;
|
|
|
|
services.nginx.enable = false;
|
|
|
|
environment = {
|
|
etc = {
|
|
foo_new = {
|
|
text = ''
|
|
This is just a test!
|
|
'';
|
|
};
|
|
};
|
|
|
|
systemPackages = [
|
|
pkgs.fish
|
|
];
|
|
};
|
|
|
|
systemd.services = {
|
|
new-service = {
|
|
enable = true;
|
|
description = "new-service";
|
|
serviceConfig = {
|
|
Type = "oneshot";
|
|
RemainAfterExit = true;
|
|
ExecReload = "${lib.getBin pkgs.coreutils}/bin/true";
|
|
};
|
|
wantedBy = [
|
|
"system-manager.target"
|
|
"default.target"
|
|
];
|
|
script = ''
|
|
sleep 2
|
|
'';
|
|
};
|
|
};
|
|
};
|
|
}
|
|
)
|
|
];
|
|
};
|
|
|
|
in
|
|
|
|
forEachUbuntuImage "example" {
|
|
modules = [
|
|
(testModule "old")
|
|
../../../examples/example.nix
|
|
];
|
|
extraPathsToRegister = [ newConfig ];
|
|
testScriptFunction =
|
|
{ toplevel, ... }:
|
|
#python
|
|
''
|
|
# Start all machines in parallel
|
|
start_all()
|
|
|
|
vm.wait_for_unit("default.target")
|
|
|
|
vm.succeed("touch /etc/foo_test")
|
|
vm.succeed("${toplevel}/bin/activate 2>&1 | tee /tmp/output.log")
|
|
vm.succeed("grep -F 'Error while creating file in /etc: Unmanaged path already exists in filesystem, please remove it and run system-manager again: /etc/foo_test' /tmp/output.log")
|
|
vm.succeed("rm /etc/foo_test")
|
|
|
|
${system-manager.lib.activateProfileSnippet {
|
|
node = "vm";
|
|
profile = toplevel;
|
|
}}
|
|
vm.wait_for_unit("system-manager.target")
|
|
|
|
vm.succeed("systemctl status service-9.service")
|
|
vm.succeed("test -f /etc/baz/bar/foo2")
|
|
vm.succeed("test -f /etc/a/nested/example/foo3")
|
|
vm.succeed("test -f /etc/foo.conf")
|
|
vm.succeed("grep -F 'launch_the_rockets = true' /etc/foo.conf")
|
|
vm.fail("grep -F 'launch_the_rockets = false' /etc/foo.conf")
|
|
|
|
uid = vm.succeed("stat -c %u /etc/with_ownership").strip()
|
|
gid = vm.succeed("stat -c %g /etc/with_ownership").strip()
|
|
assert uid == "5", f"uid was {uid}, expected 5"
|
|
assert gid == "6", f"gid was {gid}, expected 6"
|
|
|
|
print(vm.succeed("cat /etc/passwd"))
|
|
|
|
user = vm.succeed("stat -c %U /etc/with_ownership2").strip()
|
|
group = vm.succeed("stat -c %G /etc/with_ownership2").strip()
|
|
assert user == "nobody", f"user was {user}, expected nobody"
|
|
assert group == "users", f"group was {group}, expected users"
|
|
|
|
vm.succeed("test -d /var/tmp/system-manager")
|
|
vm.succeed("test -d /var/tmp/sample")
|
|
|
|
vm.succeed("test -f /etc/tmpfiles.d/sample.conf")
|
|
vm.succeed("test -f /etc/tmpfiles.d/00-system-manager.conf")
|
|
|
|
${system-manager.lib.activateProfileSnippet {
|
|
node = "vm";
|
|
profile = newConfig;
|
|
}}
|
|
vm.succeed("systemctl status new-service.service")
|
|
vm.fail("systemctl status service-9.service")
|
|
vm.fail("test -f /etc/a/nested/example/foo3")
|
|
vm.fail("test -f /etc/baz/bar/foo2")
|
|
vm.fail("test -f /etc/systemd/system/nginx.service")
|
|
vm.succeed("test -f /etc/foo_new")
|
|
|
|
vm.succeed("test -d /var/tmp/system-manager")
|
|
vm.succeed("touch /var/tmp/system-manager/foo1")
|
|
|
|
# Simulate a reboot, to check that the services defined with
|
|
# system-manager start correctly after a reboot.
|
|
# TODO: can we find an easy way to really reboot the VM and not
|
|
# loose the root FS state?
|
|
vm.systemctl("isolate rescue.target")
|
|
# We need to send a return character to dismiss the rescue-mode prompt
|
|
vm.send_key("ret")
|
|
vm.systemctl("isolate default.target")
|
|
vm.wait_for_unit("default.target")
|
|
|
|
vm.succeed("systemctl status new-service.service")
|
|
vm.fail("systemctl status service-9.service")
|
|
vm.fail("test -f /etc/a/nested/example/foo3")
|
|
vm.fail("test -f /etc/baz/bar/foo2")
|
|
vm.succeed("test -f /etc/foo_new")
|
|
|
|
${system-manager.lib.deactivateProfileSnippet {
|
|
node = "vm";
|
|
profile = newConfig;
|
|
}}
|
|
vm.fail("systemctl status new-service.service")
|
|
vm.fail("test -f /etc/foo_new")
|
|
#vm.fail("test -f /var/tmp/system-manager/foo1")
|
|
'';
|
|
}
|
|
|
|
//
|
|
|
|
forEachUbuntuImage "prepopulate" {
|
|
modules = [
|
|
(testModule "old")
|
|
../../../examples/example.nix
|
|
];
|
|
extraPathsToRegister = [ newConfig ];
|
|
testScriptFunction =
|
|
{ toplevel, ... }:
|
|
''
|
|
# Start all machines in parallel
|
|
start_all()
|
|
|
|
vm.wait_for_unit("default.target")
|
|
|
|
${system-manager.lib.prepopulateProfileSnippet {
|
|
node = "vm";
|
|
profile = toplevel;
|
|
}}
|
|
vm.systemctl("daemon-reload")
|
|
|
|
# Simulate a reboot, to check that the services defined with
|
|
# system-manager start correctly after a reboot.
|
|
# TODO: can we find an easy way to really reboot the VM and not
|
|
# loose the root FS state?
|
|
vm.systemctl("isolate rescue.target")
|
|
# We need to send a return character to dismiss the rescue-mode prompt
|
|
vm.send_key("ret")
|
|
vm.systemctl("isolate default.target")
|
|
vm.wait_for_unit("system-manager.target")
|
|
|
|
vm.succeed("systemctl status service-9.service")
|
|
vm.succeed("test -f /etc/baz/bar/foo2")
|
|
vm.succeed("test -f /etc/a/nested/example/foo3")
|
|
vm.succeed("test -f /etc/foo.conf")
|
|
vm.succeed("grep -F 'launch_the_rockets = true' /etc/foo.conf")
|
|
vm.fail("grep -F 'launch_the_rockets = false' /etc/foo.conf")
|
|
|
|
${system-manager.lib.activateProfileSnippet {
|
|
node = "vm";
|
|
profile = newConfig;
|
|
}}
|
|
vm.succeed("systemctl status new-service.service")
|
|
vm.fail("systemctl status service-9.service")
|
|
vm.fail("test -f /etc/a/nested/example/foo3")
|
|
vm.fail("test -f /etc/baz/bar/foo2")
|
|
vm.succeed("test -f /etc/foo_new")
|
|
|
|
${system-manager.lib.deactivateProfileSnippet {
|
|
node = "vm";
|
|
profile = newConfig;
|
|
}}
|
|
vm.fail("systemctl status new-service.service")
|
|
vm.fail("test -f /etc/foo_new")
|
|
'';
|
|
}
|
|
|
|
//
|
|
|
|
forEachUbuntuImage "system-path" {
|
|
modules = [
|
|
(testModule "old")
|
|
../../../examples/example.nix
|
|
];
|
|
extraPathsToRegister = [ newConfig ];
|
|
testScriptFunction =
|
|
{ toplevel, hostPkgs, ... }:
|
|
''
|
|
# Start all machines in parallel
|
|
start_all()
|
|
vm.wait_for_unit("default.target")
|
|
|
|
vm.fail("bash --login -c '$(which rg)'")
|
|
vm.fail("bash --login -c '$(which fd)'")
|
|
|
|
${system-manager.lib.activateProfileSnippet {
|
|
node = "vm";
|
|
profile = toplevel;
|
|
}}
|
|
|
|
vm.wait_for_unit("system-manager.target")
|
|
vm.wait_for_unit("system-manager-path.service")
|
|
|
|
#vm.fail("bash --login -c '$(which fish)'")
|
|
vm.succeed("bash --login -c 'realpath $(which rg) | grep -F ${hostPkgs.ripgrep}/bin/rg'")
|
|
vm.succeed("bash --login -c 'realpath $(which fd) | grep -F ${hostPkgs.fd}/bin/fd'")
|
|
|
|
${system-manager.lib.activateProfileSnippet {
|
|
node = "vm";
|
|
profile = newConfig;
|
|
}}
|
|
|
|
vm.fail("bash --login -c '$(which rg)'")
|
|
vm.fail("bash --login -c '$(which fd)'")
|
|
vm.succeed("bash --login -c 'realpath $(which fish) | grep -F ${hostPkgs.fish}/bin/fish'")
|
|
'';
|
|
}
|