public/nixpkgs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

nixosTests.installer: Port to python

Browse Source
This commit is contained in:
Jacek Galowicz 2020-01-28 08:54:05 +01:00
parent 798fcaafa4
commit 059845b11d
1 changed files with 510 additions and 489 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

521
nixos/tests/installer.nix
View File

@ -3,7 +3,7 @@
pkgs ? import ../.. { inherit system config; } pkgs ? import ../.. { inherit system config; }
}: }:
with import ../lib/testing.nix { inherit system pkgs; }; with import ../lib/testing-python.nix { inherit system pkgs; };
with pkgs.lib; with pkgs.lib;
let let
@ -67,161 +67,193 @@ let
, grubIdentifier, preBootCommands, extraConfig , grubIdentifier, preBootCommands, extraConfig
, testCloneConfig , testCloneConfig
}: }:
let let iface = if grubVersion == 1 then "ide" else "virtio";
iface = if grubVersion == 1 then "ide" else "virtio";
isEfi = bootLoader == "systemd-boot" || (bootLoader == "grub" && grubUseEfi); isEfi = bootLoader == "systemd-boot" || (bootLoader == "grub" && grubUseEfi);
bios = if pkgs.stdenv.isAarch64 then "QEMU_EFI.fd" else "OVMF.fd";
# FIXME don't duplicate the -enable-kvm etc. flags here yet again!
qemuFlags =
(if system == "x86_64-linux" then "-m 768 " else "-m 512 ") +
(optionalString (system == "x86_64-linux") "-cpu host ") +
(optionalString (system == "aarch64-linux") "-enable-kvm -machine virt,gic-version=host -cpu host ");
hdFlags = ''hda => "vm-state-machine/machine.qcow2", hdaInterface => "${iface}", ''
+ optionalString isEfi (if pkgs.stdenv.isAarch64
then ''bios => "${pkgs.OVMF.fd}/FV/QEMU_EFI.fd", ''
else ''bios => "${pkgs.OVMF.fd}/FV/OVMF.fd", '');
in if !isEfi && !(pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64) then in if !isEfi && !(pkgs.stdenv.isi686 || pkgs.stdenv.isx86_64) then
throw "Non-EFI boot methods are only supported on i686 / x86_64" throw "Non-EFI boot methods are only supported on i686 / x86_64"
else '' else ''
def assemble_qemu_flags():
flags = "-cpu host"
${if system == "x86_64-linux"
then ''flags += " -m 768"''
else ''flags += " -m 512 -enable-kvm -machine virt,gic-version=host"''
}
return flags
$machine->start;
# Make sure that we get a login prompt etc. qemu_flags = {"qemuFlags": assemble_qemu_flags()}
$machine->succeed("echo hello");
#$machine->waitForUnit('getty@tty2');
#$machine->waitForUnit("rogue");
$machine->waitForUnit("nixos-manual");
# Wait for hard disks to appear in /dev hd_flags = {
$machine->succeed("udevadm settle"); "hdaInterface": "${iface}",
"hda": "vm-state-machine/machine.qcow2",
}
${optionalString isEfi ''
hd_flags.update(
bios="${pkgs.OVMF.fd}/FV/${bios}"
)''
}
default_flags = {**hd_flags, **qemu_flags}
def create_machine_named(name):
return create_machine({**default_flags, "name": "boot-after-install"})
machine.start()
with subtest("Assert readiness of login prompt"):
machine.succeed("echo hello")
machine.wait_for_unit("nixos-manual")
with subtest("Wait for hard disks to appear in /dev"):
machine.succeed("udevadm settle")
# Partition the disk.
${createPartitions} ${createPartitions}
# Create the NixOS configuration. with subtest("Create the NixOS configuration"):
$machine->succeed("nixos-generate-config --root /mnt"); machine.succeed("nixos-generate-config --root /mnt")
machine.succeed("cat /mnt/etc/nixos/hardware-configuration.nix >&2")
machine.copy_from_host(
"${ makeConfig {
inherit bootLoader grubVersion grubDevice grubIdentifier
grubUseEfi extraConfig;
}
}",
"/mnt/etc/nixos/configuration.nix",
)
$machine->succeed("cat /mnt/etc/nixos/hardware-configuration.nix >&2"); with subtest("Perform the installation"):
machine.succeed("nixos-install < /dev/null >&2")
$machine->copyFileFromHost( with subtest("Do it again to make sure it's idempotent"):
"${ makeConfig { inherit bootLoader grubVersion grubDevice grubIdentifier grubUseEfi extraConfig; } }", machine.succeed("nixos-install < /dev/null >&2")
"/mnt/etc/nixos/configuration.nix");
# Perform the installation. with subtest("Shutdown system after installation"):
$machine->succeed("nixos-install < /dev/null >&2"); machine.succeed("umount /mnt/boot || true")
machine.succeed("umount /mnt")
# Do it again to make sure it's idempotent. machine.succeed("sync")
$machine->succeed("nixos-install < /dev/null >&2"); machine.shutdown()
$machine->succeed("umount /mnt/boot || true");
$machine->succeed("umount /mnt");
$machine->succeed("sync");
$machine->shutdown;
# Now see if we can boot the installation. # Now see if we can boot the installation.
$machine = createMachine({ ${hdFlags} qemuFlags => "${qemuFlags}", name => "boot-after-install" }); machine = create_machine_named("boot-after-install")
# For example to enter LUKS passphrase. # For example to enter LUKS passphrase.
${preBootCommands} ${preBootCommands}
# Did /boot get mounted? with subtest("Assert that /boot get mounted"):
$machine->waitForUnit("local-fs.target"); machine.wait_for_unit("local-fs.target")
${if bootLoader == "grub"
${if bootLoader == "grub" then then ''machine.succeed("test -e /boot/grub")''
''$machine->succeed("test -e /boot/grub");'' else ''machine.succeed("test -e /boot/loader/loader.conf")''
else
''$machine->succeed("test -e /boot/loader/loader.conf");''
} }
# Check whether /root has correct permissions. with subtest("Check whether /root has correct permissions"):
$machine->succeed("stat -c '%a' /root") =~ /700/ or die; assert "700" in machine.succeed("stat -c '%a' /root")
# Did the swap device get activated? with subtest("Assert swap device got activated"):
# uncomment once https://bugs.freedesktop.org/show_bug.cgi?id=86930 is resolved # uncomment once https://bugs.freedesktop.org/show_bug.cgi?id=86930 is resolved
$machine->waitForUnit("swap.target"); machine.wait_for_unit("swap.target")
$machine->succeed("cat /proc/swaps | grep -q /dev"); machine.succeed("cat /proc/swaps | grep -q /dev")
# Check that the store is in good shape with subtest("Check that the store is in good shape"):
$machine->succeed("nix-store --verify --check-contents >&2"); machine.succeed("nix-store --verify --check-contents >&2")
# Check whether the channel works. with subtest("Check whether the channel works"):
$machine->succeed("nix-env -iA nixos.procps >&2"); machine.succeed("nix-env -iA nixos.procps >&2")
$machine->succeed("type -tP ps | tee /dev/stderr") =~ /.nix-profile/ assert ".nix-profile" in machine.succeed("type -tP ps | tee /dev/stderr")
or die "nix-env failed";
# Check that the daemon works, and that non-root users can run builds (this will build a new profile generation through the daemon) with subtest(
$machine->succeed("su alice -l -c 'nix-env -iA nixos.procps' >&2"); "Check that the daemon works, and that non-root users can run builds "
"(this will build a new profile generation through the daemon)"
):
machine.succeed("su alice -l -c 'nix-env -iA nixos.procps' >&2")
# We need a writable Nix store on next boot. with subtest("Configure system with writable Nix store on next boot"):
$machine->copyFileFromHost( # we're not using copy_from_host here because the installer image
"${ makeConfig { inherit bootLoader grubVersion grubDevice grubIdentifier grubUseEfi extraConfig; forceGrubReinstallCount = 1; } }", # doesn't know about the host-guest sharing mechanism.
"/etc/nixos/configuration.nix"); machine.copy_from_host_via_shell(
"${ makeConfig {
inherit bootLoader grubVersion grubDevice grubIdentifier
grubUseEfi extraConfig;
forceGrubReinstallCount = 1;
}
}",
"/etc/nixos/configuration.nix",
)
# Check whether nixos-rebuild works. with subtest("Check whether nixos-rebuild works"):
$machine->succeed("nixos-rebuild switch >&2"); machine.succeed("nixos-rebuild switch >&2")
# Test nixos-option. with subtest("Test nixos-option"):
$machine->succeed("nixos-option boot.initrd.kernelModules | grep virtio_console"); kernel_modules = machine.succeed("nixos-option boot.initrd.kernelModules")
$machine->succeed("nixos-option boot.initrd.kernelModules | grep 'List of modules'"); assert "virtio_console" in kernel_modules
$machine->succeed("nixos-option boot.initrd.kernelModules | grep qemu-guest.nix"); assert "List of modules" in kernel_modules
assert "qemu-guest.nix" in kernel_modules
$machine->shutdown; machine.shutdown()
# Check whether a writable store build works # Check whether a writable store build works
$machine = createMachine({ ${hdFlags} qemuFlags => "${qemuFlags}", name => "rebuild-switch" }); machine = create_machine_named("rebuild-switch")
${preBootCommands} ${preBootCommands}
$machine->waitForUnit("multi-user.target"); machine.wait_for_unit("multi-user.target")
$machine->copyFileFromHost(
"${ makeConfig { inherit bootLoader grubVersion grubDevice grubIdentifier grubUseEfi extraConfig; forceGrubReinstallCount = 2; } }", # we're not using copy_from_host here because the installer image
"/etc/nixos/configuration.nix"); # doesn't know about the host-guest sharing mechanism.
$machine->succeed("nixos-rebuild boot >&2"); machine.copy_from_host_via_shell(
$machine->shutdown; "${ makeConfig {
inherit bootLoader grubVersion grubDevice grubIdentifier
grubUseEfi extraConfig;
forceGrubReinstallCount = 2;
}
}",
"/etc/nixos/configuration.nix",
)
machine.succeed("nixos-rebuild boot >&2")
machine.shutdown()
# And just to be sure, check that the machine still boots after # And just to be sure, check that the machine still boots after
# "nixos-rebuild switch". # "nixos-rebuild switch".
$machine = createMachine({ ${hdFlags} qemuFlags => "${qemuFlags}", "boot-after-rebuild-switch" }); machine = create_machine_named("boot-after-rebuild-switch")
${preBootCommands} ${preBootCommands}
$machine->waitForUnit("network.target"); machine.wait_for_unit("network.target")
$machine->shutdown; machine.shutdown()
# Tests for validating clone configuration entries in grub menu # Tests for validating clone configuration entries in grub menu
${optionalString testCloneConfig '' ''
+ optionalString testCloneConfig ''
# Reboot Machine # Reboot Machine
$machine = createMachine({ ${hdFlags} qemuFlags => "${qemuFlags}", name => "clone-default-config" }); machine = create_machine_named("clone-default-config")
${preBootCommands} ${preBootCommands}
$machine->waitForUnit("multi-user.target"); machine.wait_for_unit("multi-user.target")
# Booted configuration name should be Home with subtest("Booted configuration name should be 'Home'"):
# This is not the name that shows in the grub menu. # This is not the name that shows in the grub menu.
# The default configuration is always shown as "Default" # The default configuration is always shown as "Default"
$machine->succeed("cat /run/booted-system/configuration-name >&2"); machine.succeed("cat /run/booted-system/configuration-name >&2")
$machine->succeed("cat /run/booted-system/configuration-name | grep Home"); assert "Home" in machine.succeed("cat /run/booted-system/configuration-name")
# We should find **not** a file named /etc/gitconfig with subtest("We should **not** find a file named /etc/gitconfig"):
$machine->fail("test -e /etc/gitconfig"); machine.fail("test -e /etc/gitconfig")
# Set grub to boot the second configuration with subtest("Set grub to boot the second configuration"):
$machine->succeed("grub-reboot 1"); machine.succeed("grub-reboot 1")
$machine->shutdown; machine.shutdown()
# Reboot Machine # Reboot Machine
$machine = createMachine({ ${hdFlags} qemuFlags => "${qemuFlags}", name => "clone-alternate-config" }); machine = create_machine_named("clone-alternate-config")
${preBootCommands} ${preBootCommands}
$machine->waitForUnit("multi-user.target"); machine.wait_for_unit("multi-user.target")
# Booted configuration name should be Work with subtest("Booted configuration name should be Work"):
$machine->succeed("cat /run/booted-system/configuration-name >&2"); machine.succeed("cat /run/booted-system/configuration-name >&2")
$machine->succeed("cat /run/booted-system/configuration-name | grep Work"); assert "Work" in machine.succeed("cat /run/booted-system/configuration-name")
# We should find a file named /etc/gitconfig with subtest("We should find a file named /etc/gitconfig"):
$machine->succeed("test -e /etc/gitconfig"); machine.succeed("test -e /etc/gitconfig")
$machine->shutdown;
''}
machine.shutdown()
''; '';
@ -243,11 +275,9 @@ let
nodes = { nodes = {
# The configuration of the machine used to run "nixos-install". # The configuration of the machine used to run "nixos-install".
machine = machine = { pkgs, ... }: {
{ pkgs, ... }: imports = [
../modules/profiles/installation-device.nix
{ imports =
[ ../modules/profiles/installation-device.nix
../modules/profiles/base.nix ../modules/profiles/base.nix
extraInstallerConfig extraInstallerConfig
]; ];
@ -270,20 +300,20 @@ let
# The test cannot access the network, so any packages we # The test cannot access the network, so any packages we
# need must be included in the VM. # need must be included in the VM.
system.extraDependencies = with pkgs; system.extraDependencies = with pkgs; [
[ sudo
libxml2.bin
libxslt.bin
desktop-file-utils desktop-file-utils
docbook5 docbook5
docbook_xsl_ns docbook_xsl_ns
unionfs-fuse libxml2.bin
ntp libxslt.bin
nixos-artwork.wallpapers.simple-dark-gray-bottom nixos-artwork.wallpapers.simple-dark-gray-bottom
perlPackages.XMLLibXML ntp
perlPackages.ListCompare perlPackages.ListCompare
perlPackages.XMLLibXML
shared-mime-info shared-mime-info
sudo
texinfo texinfo
unionfs-fuse
xorg.lndir xorg.lndir
# add curl so that rather than seeing the test attempt to download # add curl so that rather than seeing the test attempt to download
@ -291,11 +321,13 @@ let
curl curl
] ]
++ optional (bootLoader == "grub" && grubVersion == 1) pkgs.grub ++ optional (bootLoader == "grub" && grubVersion == 1) pkgs.grub
++ optionals (bootLoader == "grub" && grubVersion == 2) [ pkgs.grub2 pkgs.grub2_efi ]; ++ optionals (bootLoader == "grub" && grubVersion == 2) [
pkgs.grub2
pkgs.grub2_efi
];
nix.binaryCaches = mkForce [ ]; nix.binaryCaches = mkForce [ ];
nix.extraOptions = nix.extraOptions = ''
''
hashed-mirrors = hashed-mirrors =
connect-timeout = 1 connect-timeout = 1
''; '';
@ -310,13 +342,13 @@ let
}; };
}; };
makeLuksRootTest = name: luksFormatOpts: makeInstallerTest name makeLuksRootTest = name: luksFormatOpts: makeInstallerTest name {
{ createPartitions = '' createPartitions = ''
$machine->succeed( machine.succeed(
"flock /dev/vda parted --script /dev/vda -- mklabel msdos" "flock /dev/vda parted --script /dev/vda -- mklabel msdos"
. " mkpart primary ext2 1M 50MB" # /boot + " mkpart primary ext2 1M 50MB" # /boot
. " mkpart primary linux-swap 50M 1024M" + " mkpart primary linux-swap 50M 1024M"
. " mkpart primary 1024M -1s", # LUKS + " mkpart primary 1024M -1s", # LUKS
"udevadm settle", "udevadm settle",
"mkswap /dev/vda2 -L swap", "mkswap /dev/vda2 -L swap",
"swapon -L swap", "swapon -L swap",
@ -328,45 +360,44 @@ let
"mkfs.ext3 -L boot /dev/vda1", "mkfs.ext3 -L boot /dev/vda1",
"mkdir -p /mnt/boot", "mkdir -p /mnt/boot",
"mount LABEL=boot /mnt/boot", "mount LABEL=boot /mnt/boot",
); )
''; '';
extraConfig = '' extraConfig = ''
boot.kernelParams = lib.mkAfter [ "console=tty0" ]; boot.kernelParams = lib.mkAfter [ "console=tty0" ];
''; '';
enableOCR = true; enableOCR = true;
preBootCommands = '' preBootCommands = ''
$machine->start; machine.start()
$machine->waitForText(qr/Passphrase for/); machine.wait_for_text("Passphrase for")
$machine->sendChars("supersecret\n"); machine.send_chars("supersecret\n")
''; '';
}; };
# The (almost) simplest partitioning scheme: a swap partition and # The (almost) simplest partitioning scheme: a swap partition and
# one big filesystem partition. # one big filesystem partition.
simple-test-config = { createPartitions = simple-test-config = {
'' createPartitions = ''
$machine->succeed( machine.succeed(
"flock /dev/vda parted --script /dev/vda -- mklabel msdos" "flock /dev/vda parted --script /dev/vda -- mklabel msdos"
. " mkpart primary linux-swap 1M 1024M" + " mkpart primary linux-swap 1M 1024M"
. " mkpart primary ext2 1024M -1s", + " mkpart primary ext2 1024M -1s",
"udevadm settle", "udevadm settle",
"mkswap /dev/vda1 -L swap", "mkswap /dev/vda1 -L swap",
"swapon -L swap", "swapon -L swap",
"mkfs.ext3 -L nixos /dev/vda2", "mkfs.ext3 -L nixos /dev/vda2",
"mount LABEL=nixos /mnt", "mount LABEL=nixos /mnt",
); )
''; '';
}; };
simple-uefi-grub-config = simple-uefi-grub-config = {
{ createPartitions = createPartitions = ''
'' machine.succeed(
$machine->succeed(
"flock /dev/vda parted --script /dev/vda -- mklabel gpt" "flock /dev/vda parted --script /dev/vda -- mklabel gpt"
. " mkpart ESP fat32 1M 50MiB" # /boot + " mkpart ESP fat32 1M 50MiB" # /boot
. " set 1 boot on" + " set 1 boot on"
. " mkpart primary linux-swap 50MiB 1024MiB" + " mkpart primary linux-swap 50MiB 1024MiB"
. " mkpart primary ext2 1024MiB -1MiB", # / + " mkpart primary ext2 1024MiB -1MiB", # /
"udevadm settle", "udevadm settle",
"mkswap /dev/vda2 -L swap", "mkswap /dev/vda2 -L swap",
"swapon -L swap", "swapon -L swap",
@ -375,18 +406,17 @@ let
"mkfs.vfat -n BOOT /dev/vda1", "mkfs.vfat -n BOOT /dev/vda1",
"mkdir -p /mnt/boot", "mkdir -p /mnt/boot",
"mount LABEL=BOOT /mnt/boot", "mount LABEL=BOOT /mnt/boot",
); )
''; '';
bootLoader = "grub"; bootLoader = "grub";
grubUseEfi = true; grubUseEfi = true;
}; };
clone-test-extraconfig = { extraConfig = clone-test-extraconfig = {
'' extraConfig = ''
environment.systemPackages = [ pkgs.grub2 ]; environment.systemPackages = [ pkgs.grub2 ];
boot.loader.grub.configurationName = "Home"; boot.loader.grub.configurationName = "Home";
nesting.clone = [ nesting.clone = [ {
{
boot.loader.grub.configurationName = lib.mkForce "Work"; boot.loader.grub.configurationName = lib.mkForce "Work";
environment.etc = { environment.etc = {
@ -395,8 +425,7 @@ let
gitproxy = none for work.com gitproxy = none for work.com
"; ";
}; };
} } ];
];
''; '';
testCloneConfig = true; testCloneConfig = true;
}; };
@ -415,15 +444,14 @@ in {
simpleClone = makeInstallerTest "simpleClone" (simple-test-config // clone-test-extraconfig); simpleClone = makeInstallerTest "simpleClone" (simple-test-config // clone-test-extraconfig);
# Simple GPT/UEFI configuration using systemd-boot with 3 partitions: ESP, swap & root filesystem # Simple GPT/UEFI configuration using systemd-boot with 3 partitions: ESP, swap & root filesystem
simpleUefiSystemdBoot = makeInstallerTest "simpleUefiSystemdBoot" simpleUefiSystemdBoot = makeInstallerTest "simpleUefiSystemdBoot" {
{ createPartitions = createPartitions = ''
'' machine.succeed(
$machine->succeed(
"flock /dev/vda parted --script /dev/vda -- mklabel gpt" "flock /dev/vda parted --script /dev/vda -- mklabel gpt"
. " mkpart ESP fat32 1M 50MiB" # /boot + " mkpart ESP fat32 1M 50MiB" # /boot
. " set 1 boot on" + " set 1 boot on"
. " mkpart primary linux-swap 50MiB 1024MiB" + " mkpart primary linux-swap 50MiB 1024MiB"
. " mkpart primary ext2 1024MiB -1MiB", # / + " mkpart primary ext2 1024MiB -1MiB", # /
"udevadm settle", "udevadm settle",
"mkswap /dev/vda2 -L swap", "mkswap /dev/vda2 -L swap",
"swapon -L swap", "swapon -L swap",
@ -432,7 +460,7 @@ in {
"mkfs.vfat -n BOOT /dev/vda1", "mkfs.vfat -n BOOT /dev/vda1",
"mkdir -p /mnt/boot", "mkdir -p /mnt/boot",
"mount LABEL=BOOT /mnt/boot", "mount LABEL=BOOT /mnt/boot",
); )
''; '';
bootLoader = "systemd-boot"; bootLoader = "systemd-boot";
}; };
@ -443,14 +471,13 @@ in {
simpleUefiGrubClone = makeInstallerTest "simpleUefiGrubClone" (simple-uefi-grub-config // clone-test-extraconfig); simpleUefiGrubClone = makeInstallerTest "simpleUefiGrubClone" (simple-uefi-grub-config // clone-test-extraconfig);
# Same as the previous, but now with a separate /boot partition. # Same as the previous, but now with a separate /boot partition.
separateBoot = makeInstallerTest "separateBoot" separateBoot = makeInstallerTest "separateBoot" {
{ createPartitions = createPartitions = ''
'' machine.succeed(
$machine->succeed(
"flock /dev/vda parted --script /dev/vda -- mklabel msdos" "flock /dev/vda parted --script /dev/vda -- mklabel msdos"
. " mkpart primary ext2 1M 50MB" # /boot + " mkpart primary ext2 1M 50MB" # /boot
. " mkpart primary linux-swap 50MB 1024M" + " mkpart primary linux-swap 50MB 1024M"
. " mkpart primary ext2 1024M -1s", # / + " mkpart primary ext2 1024M -1s", # /
"udevadm settle", "udevadm settle",
"mkswap /dev/vda2 -L swap", "mkswap /dev/vda2 -L swap",
"swapon -L swap", "swapon -L swap",
@ -459,19 +486,18 @@ in {
"mkfs.ext3 -L boot /dev/vda1", "mkfs.ext3 -L boot /dev/vda1",
"mkdir -p /mnt/boot", "mkdir -p /mnt/boot",
"mount LABEL=boot /mnt/boot", "mount LABEL=boot /mnt/boot",
); )
''; '';
}; };
# Same as the previous, but with fat32 /boot. # Same as the previous, but with fat32 /boot.
separateBootFat = makeInstallerTest "separateBootFat" separateBootFat = makeInstallerTest "separateBootFat" {
{ createPartitions = createPartitions = ''
'' machine.succeed(
$machine->succeed(
"flock /dev/vda parted --script /dev/vda -- mklabel msdos" "flock /dev/vda parted --script /dev/vda -- mklabel msdos"
. " mkpart primary ext2 1M 50MB" # /boot + " mkpart primary ext2 1M 50MB" # /boot
. " mkpart primary linux-swap 50MB 1024M" + " mkpart primary linux-swap 50MB 1024M"
. " mkpart primary ext2 1024M -1s", # / + " mkpart primary ext2 1024M -1s", # /
"udevadm settle", "udevadm settle",
"mkswap /dev/vda2 -L swap", "mkswap /dev/vda2 -L swap",
"swapon -L swap", "swapon -L swap",
@ -480,13 +506,12 @@ in {
"mkfs.vfat -n BOOT /dev/vda1", "mkfs.vfat -n BOOT /dev/vda1",
"mkdir -p /mnt/boot", "mkdir -p /mnt/boot",
"mount LABEL=BOOT /mnt/boot", "mount LABEL=BOOT /mnt/boot",
); )
''; '';
}; };
# zfs on / with swap # zfs on / with swap
zfsroot = makeInstallerTest "zfs-root" zfsroot = makeInstallerTest "zfs-root" {
{
extraInstallerConfig = { extraInstallerConfig = {
boot.supportedFilesystems = [ "zfs" ]; boot.supportedFilesystems = [ "zfs" ];
}; };
@ -501,37 +526,32 @@ in {
networking.hostId = "00000000"; networking.hostId = "00000000";
''; '';
createPartitions = createPartitions = ''
'' machine.succeed(
$machine->succeed(
"flock /dev/vda parted --script /dev/vda -- mklabel msdos" "flock /dev/vda parted --script /dev/vda -- mklabel msdos"
. " mkpart primary linux-swap 1M 1024M" + " mkpart primary linux-swap 1M 1024M"
. " mkpart primary 1024M -1s", + " mkpart primary 1024M -1s",
"udevadm settle", "udevadm settle",
"mkswap /dev/vda1 -L swap", "mkswap /dev/vda1 -L swap",
"swapon -L swap", "swapon -L swap",
"zpool create rpool /dev/vda2", "zpool create rpool /dev/vda2",
"zfs create -o mountpoint=legacy rpool/root", "zfs create -o mountpoint=legacy rpool/root",
"mount -t zfs rpool/root /mnt", "mount -t zfs rpool/root /mnt",
"udevadm settle",
"udevadm settle" )
);
''; '';
}; };
# Create two physical LVM partitions combined into one volume group # Create two physical LVM partitions combined into one volume group
# that contains the logical swap and root partitions. # that contains the logical swap and root partitions.
lvm = makeInstallerTest "lvm" lvm = makeInstallerTest "lvm" {
{ createPartitions = createPartitions = ''
'' machine.succeed(
$machine->succeed(
"flock /dev/vda parted --script /dev/vda -- mklabel msdos" "flock /dev/vda parted --script /dev/vda -- mklabel msdos"
. " mkpart primary 1M 2048M" # PV1 + " mkpart primary 1M 2048M" # PV1
. " set 1 lvm on" + " set 1 lvm on"
. " mkpart primary 2048M -1s" # PV2 + " mkpart primary 2048M -1s" # PV2
. " set 2 lvm on", + " set 2 lvm on",
"udevadm settle", "udevadm settle",
"pvcreate /dev/vda1 /dev/vda2", "pvcreate /dev/vda1 /dev/vda2",
"vgcreate MyVolGroup /dev/vda1 /dev/vda2", "vgcreate MyVolGroup /dev/vda1 /dev/vda2",
@ -541,7 +561,7 @@ in {
"swapon -L swap", "swapon -L swap",
"mkfs.xfs -L nixos /dev/MyVolGroup/nixos", "mkfs.xfs -L nixos /dev/MyVolGroup/nixos",
"mount LABEL=nixos /mnt", "mount LABEL=nixos /mnt",
); )
''; '';
}; };
@ -557,14 +577,14 @@ in {
# Test whether opening encrypted filesystem with keyfile # Test whether opening encrypted filesystem with keyfile
# Checks for regression of missing cryptsetup, when no luks device without # Checks for regression of missing cryptsetup, when no luks device without
# keyfile is configured # keyfile is configured
encryptedFSWithKeyfile = makeInstallerTest "encryptedFSWithKeyfile" encryptedFSWithKeyfile = makeInstallerTest "encryptedFSWithKeyfile" {
{ createPartitions = '' createPartitions = ''
$machine->succeed( machine.succeed(
"flock /dev/vda parted --script /dev/vda -- mklabel msdos" "flock /dev/vda parted --script /dev/vda -- mklabel msdos"
. " mkpart primary ext2 1M 50MB" # /boot + " mkpart primary ext2 1M 50MB" # /boot
. " mkpart primary linux-swap 50M 1024M" + " mkpart primary linux-swap 50M 1024M"
. " mkpart primary 1024M 1280M" # LUKS with keyfile + " mkpart primary 1024M 1280M" # LUKS with keyfile
. " mkpart primary 1280M -1s", + " mkpart primary 1280M -1s",
"udevadm settle", "udevadm settle",
"mkswap /dev/vda2 -L swap", "mkswap /dev/vda2 -L swap",
"swapon -L swap", "swapon -L swap",
@ -579,12 +599,12 @@ in {
"cryptsetup luksOpen --key-file /mnt/keyfile /dev/vda3 crypt", "cryptsetup luksOpen --key-file /mnt/keyfile /dev/vda3 crypt",
"mkfs.ext3 -L test /dev/mapper/crypt", "mkfs.ext3 -L test /dev/mapper/crypt",
"cryptsetup luksClose crypt", "cryptsetup luksClose crypt",
"mkdir -p /mnt/test" "mkdir -p /mnt/test",
); )
''; '';
extraConfig = '' extraConfig = ''
fileSystems."/test" = fileSystems."/test" = {
{ device = "/dev/disk/by-label/test"; device = "/dev/disk/by-label/test";
fsType = "ext3"; fsType = "ext3";
encrypted.enable = true; encrypted.enable = true;
encrypted.blkDev = "/dev/vda3"; encrypted.blkDev = "/dev/vda3";
@ -594,25 +614,25 @@ in {
''; '';
}; };
swraid = makeInstallerTest "swraid" {
swraid = makeInstallerTest "swraid" createPartitions = ''
{ createPartitions = machine.succeed(
''
$machine->succeed(
"flock /dev/vda parted --script /dev/vda --" "flock /dev/vda parted --script /dev/vda --"
. " mklabel msdos" + " mklabel msdos"
. " mkpart primary ext2 1M 100MB" # /boot + " mkpart primary ext2 1M 100MB" # /boot
. " mkpart extended 100M -1s" + " mkpart extended 100M -1s"
. " mkpart logical 102M 2102M" # md0 (root), first device + " mkpart logical 102M 2102M" # md0 (root), first device
. " mkpart logical 2103M 4103M" # md0 (root), second device + " mkpart logical 2103M 4103M" # md0 (root), second device
. " mkpart logical 4104M 4360M" # md1 (swap), first device + " mkpart logical 4104M 4360M" # md1 (swap), first device
. " mkpart logical 4361M 4617M", # md1 (swap), second device + " mkpart logical 4361M 4617M", # md1 (swap), second device
"udevadm settle", "udevadm settle",
"ls -l /dev/vda* >&2", "ls -l /dev/vda* >&2",
"cat /proc/partitions >&2", "cat /proc/partitions >&2",
"udevadm control --stop-exec-queue", "udevadm control --stop-exec-queue",
"mdadm --create --force /dev/md0 --metadata 1.2 --level=raid1 --raid-devices=2 /dev/vda5 /dev/vda6", "mdadm --create --force /dev/md0 --metadata 1.2 --level=raid1 "
"mdadm --create --force /dev/md1 --metadata 1.2 --level=raid1 --raid-devices=2 /dev/vda7 /dev/vda8", + "--raid-devices=2 /dev/vda5 /dev/vda6",
"mdadm --create --force /dev/md1 --metadata 1.2 --level=raid1 "
+ "--raid-devices=2 /dev/vda7 /dev/vda8",
"udevadm control --start-exec-queue", "udevadm control --start-exec-queue",
"udevadm settle", "udevadm settle",
"mkswap -f /dev/md1 -L swap", "mkswap -f /dev/md1 -L swap",
@ -623,29 +643,28 @@ in {
"mkdir /mnt/boot", "mkdir /mnt/boot",
"mount LABEL=boot /mnt/boot", "mount LABEL=boot /mnt/boot",
"udevadm settle", "udevadm settle",
); )
''; '';
preBootCommands = '' preBootCommands = ''
$machine->start; machine.start()
$machine->fail("dmesg | grep 'immediate safe mode'"); machine.fail("dmesg | grep 'immediate safe mode'")
''; '';
}; };
# Test a basic install using GRUB 1. # Test a basic install using GRUB 1.
grub1 = makeInstallerTest "grub1" grub1 = makeInstallerTest "grub1" {
{ createPartitions = createPartitions = ''
'' machine.succeed(
$machine->succeed(
"flock /dev/sda parted --script /dev/sda -- mklabel msdos" "flock /dev/sda parted --script /dev/sda -- mklabel msdos"
. " mkpart primary linux-swap 1M 1024M" + " mkpart primary linux-swap 1M 1024M"
. " mkpart primary ext2 1024M -1s", + " mkpart primary ext2 1024M -1s",
"udevadm settle", "udevadm settle",
"mkswap /dev/sda1 -L swap", "mkswap /dev/sda1 -L swap",
"swapon -L swap", "swapon -L swap",
"mkfs.ext3 -L nixos /dev/sda2", "mkfs.ext3 -L nixos /dev/sda2",
"mount LABEL=nixos /mnt", "mount LABEL=nixos /mnt",
"mkdir -p /mnt/tmp", "mkdir -p /mnt/tmp",
); )
''; '';
grubVersion = 1; grubVersion = 1;
grubDevice = "/dev/sda"; grubDevice = "/dev/sda";
@ -654,14 +673,14 @@ in {
# Test using labels to identify volumes in grub # Test using labels to identify volumes in grub
simpleLabels = makeInstallerTest "simpleLabels" { simpleLabels = makeInstallerTest "simpleLabels" {
createPartitions = '' createPartitions = ''
$machine->succeed( machine.succeed(
"sgdisk -Z /dev/vda", "sgdisk -Z /dev/vda",
"sgdisk -n 1:0:+1M -n 2:0:+1G -N 3 -t 1:ef02 -t 2:8200 -t 3:8300 -c 3:root /dev/vda", "sgdisk -n 1:0:+1M -n 2:0:+1G -N 3 -t 1:ef02 -t 2:8200 -t 3:8300 -c 3:root /dev/vda",
"mkswap /dev/vda2 -L swap", "mkswap /dev/vda2 -L swap",
"swapon -L swap", "swapon -L swap",
"mkfs.ext4 -L root /dev/vda3", "mkfs.ext4 -L root /dev/vda3",
"mount LABEL=root /mnt", "mount LABEL=root /mnt",
); )
''; '';
grubIdentifier = "label"; grubIdentifier = "label";
}; };
@ -670,22 +689,23 @@ in {
# TODO: Fix udev so the symlinks are unneeded in /dev/disks # TODO: Fix udev so the symlinks are unneeded in /dev/disks
simpleProvided = makeInstallerTest "simpleProvided" { simpleProvided = makeInstallerTest "simpleProvided" {
createPartitions = '' createPartitions = ''
my $UUID = "\$(blkid -s UUID -o value /dev/vda2)"; uuid = "$(blkid -s UUID -o value /dev/vda2)"
$machine->succeed( machine.succeed(
"sgdisk -Z /dev/vda", "sgdisk -Z /dev/vda",
"sgdisk -n 1:0:+1M -n 2:0:+100M -n 3:0:+1G -N 4 -t 1:ef02 -t 2:8300 -t 3:8200 -t 4:8300 -c 2:boot -c 4:root /dev/vda", "sgdisk -n 1:0:+1M -n 2:0:+100M -n 3:0:+1G -N 4 -t 1:ef02 -t 2:8300 "
+ "-t 3:8200 -t 4:8300 -c 2:boot -c 4:root /dev/vda",
"mkswap /dev/vda3 -L swap", "mkswap /dev/vda3 -L swap",
"swapon -L swap", "swapon -L swap",
"mkfs.ext4 -L boot /dev/vda2", "mkfs.ext4 -L boot /dev/vda2",
"mkfs.ext4 -L root /dev/vda4", "mkfs.ext4 -L root /dev/vda4",
); )
$machine->execute("ln -s ../../vda2 /dev/disk/by-uuid/$UUID"); machine.execute(f"ln -s ../../vda2 /dev/disk/by-uuid/{uuid}")
$machine->execute("ln -s ../../vda4 /dev/disk/by-label/root"); machine.execute("ln -s ../../vda4 /dev/disk/by-label/root")
$machine->succeed( machine.succeed(
"mount /dev/disk/by-label/root /mnt", "mount /dev/disk/by-label/root /mnt",
"mkdir /mnt/boot", "mkdir /mnt/boot",
"mount /dev/disk/by-uuid/$UUID /mnt/boot" f"mount /dev/disk/by-uuid/{uuid} /mnt/boot",
); )
''; '';
grubIdentifier = "provided"; grubIdentifier = "provided";
}; };
@ -693,21 +713,21 @@ in {
# Simple btrfs grub testing # Simple btrfs grub testing
btrfsSimple = makeInstallerTest "btrfsSimple" { btrfsSimple = makeInstallerTest "btrfsSimple" {
createPartitions = '' createPartitions = ''
$machine->succeed( machine.succeed(
"sgdisk -Z /dev/vda", "sgdisk -Z /dev/vda",
"sgdisk -n 1:0:+1M -n 2:0:+1G -N 3 -t 1:ef02 -t 2:8200 -t 3:8300 -c 3:root /dev/vda", "sgdisk -n 1:0:+1M -n 2:0:+1G -N 3 -t 1:ef02 -t 2:8200 -t 3:8300 -c 3:root /dev/vda",
"mkswap /dev/vda2 -L swap", "mkswap /dev/vda2 -L swap",
"swapon -L swap", "swapon -L swap",
"mkfs.btrfs -L root /dev/vda3", "mkfs.btrfs -L root /dev/vda3",
"mount LABEL=root /mnt", "mount LABEL=root /mnt",
); )
''; '';
}; };
# Test to see if we can detect /boot and /nix on subvolumes # Test to see if we can detect /boot and /nix on subvolumes
btrfsSubvols = makeInstallerTest "btrfsSubvols" { btrfsSubvols = makeInstallerTest "btrfsSubvols" {
createPartitions = '' createPartitions = ''
$machine->succeed( machine.succeed(
"sgdisk -Z /dev/vda", "sgdisk -Z /dev/vda",
"sgdisk -n 1:0:+1M -n 2:0:+1G -N 3 -t 1:ef02 -t 2:8200 -t 3:8300 -c 3:root /dev/vda", "sgdisk -n 1:0:+1M -n 2:0:+1G -N 3 -t 1:ef02 -t 2:8200 -t 3:8300 -c 3:root /dev/vda",
"mkswap /dev/vda2 -L swap", "mkswap /dev/vda2 -L swap",
@ -722,14 +742,14 @@ in {
"mount -o defaults,subvol=nixos/default LABEL=root /mnt", "mount -o defaults,subvol=nixos/default LABEL=root /mnt",
"mkdir /mnt/boot", "mkdir /mnt/boot",
"mount -o defaults,subvol=boot LABEL=root /mnt/boot", "mount -o defaults,subvol=boot LABEL=root /mnt/boot",
); )
''; '';
}; };
# Test to see if we can detect default and aux subvolumes correctly # Test to see if we can detect default and aux subvolumes correctly
btrfsSubvolDefault = makeInstallerTest "btrfsSubvolDefault" { btrfsSubvolDefault = makeInstallerTest "btrfsSubvolDefault" {
createPartitions = '' createPartitions = ''
$machine->succeed( machine.succeed(
"sgdisk -Z /dev/vda", "sgdisk -Z /dev/vda",
"sgdisk -n 1:0:+1M -n 2:0:+1G -N 3 -t 1:ef02 -t 2:8200 -t 3:8300 -c 3:root /dev/vda", "sgdisk -n 1:0:+1M -n 2:0:+1G -N 3 -t 1:ef02 -t 2:8200 -t 3:8300 -c 3:root /dev/vda",
"mkswap /dev/vda2 -L swap", "mkswap /dev/vda2 -L swap",
@ -740,14 +760,15 @@ in {
"btrfs subvol create /mnt/badpath", "btrfs subvol create /mnt/badpath",
"btrfs subvol create /mnt/badpath/boot", "btrfs subvol create /mnt/badpath/boot",
"btrfs subvol create /mnt/nixos", "btrfs subvol create /mnt/nixos",
"btrfs subvol set-default \$(btrfs subvol list /mnt | grep 'nixos' | awk '{print \$2}') /mnt", "btrfs subvol set-default "
+ "$(btrfs subvol list /mnt | grep 'nixos' | awk '{print \$2}') /mnt",
"umount /mnt", "umount /mnt",
"mount -o defaults LABEL=root /mnt", "mount -o defaults LABEL=root /mnt",
"mkdir -p /mnt/badpath/boot", # Help ensure the detection mechanism is actually looking up subvolumes "mkdir -p /mnt/badpath/boot", # Help ensure the detection mechanism
# is actually looking up subvolumes
"mkdir /mnt/boot", "mkdir /mnt/boot",
"mount -o defaults,subvol=badpath/boot LABEL=root /mnt/boot", "mount -o defaults,subvol=badpath/boot LABEL=root /mnt/boot",
); )
''; '';
}; };
} }