2018-11-11 08:41:11 +00:00
|
|
|
{ system ? builtins.currentSystem,
|
|
|
|
config ? {},
|
2022-04-17 21:24:13 +00:00
|
|
|
pkgs ? import ../.. { inherit system config; },
|
|
|
|
systemdStage1 ? false
|
2018-11-11 08:41:11 +00:00
|
|
|
}:
|
2010-01-06 13:36:21 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
with import ../lib/testing-python.nix { inherit system pkgs; };
|
2014-04-14 12:02:44 +00:00
|
|
|
with pkgs.lib;
|
2010-01-10 01:26:01 +00:00
|
|
|
|
2010-01-07 13:19:38 +00:00
|
|
|
let
|
2010-01-06 13:36:21 +00:00
|
|
|
|
2010-01-06 20:52:05 +00:00
|
|
|
# The configuration to install.
|
2017-02-15 22:59:40 +00:00
|
|
|
makeConfig = { bootLoader, grubVersion, grubDevice, grubIdentifier, grubUseEfi
|
2015-06-10 13:18:54 +00:00
|
|
|
, extraConfig, forceGrubReinstallCount ? 0
|
2015-05-21 10:37:14 +00:00
|
|
|
}:
|
2014-08-31 16:18:13 +00:00
|
|
|
pkgs.writeText "configuration.nix" ''
|
2014-12-05 17:19:27 +00:00
|
|
|
{ config, lib, pkgs, modulesPath, ... }:
|
2010-01-06 20:52:05 +00:00
|
|
|
|
2013-09-04 11:05:09 +00:00
|
|
|
{ imports =
|
2013-10-13 15:24:11 +00:00
|
|
|
[ ./hardware-configuration.nix
|
2014-03-30 14:52:56 +00:00
|
|
|
<nixpkgs/nixos/modules/testing/test-instrumentation.nix>
|
2010-01-06 20:52:05 +00:00
|
|
|
];
|
|
|
|
|
2023-01-15 15:06:07 +00:00
|
|
|
documentation.enable = false;
|
|
|
|
|
2017-08-23 22:54:31 +00:00
|
|
|
# To ensure that we can rebuild the grub configuration on the nixos-rebuild
|
|
|
|
system.extraDependencies = with pkgs; [ stdenvNoCC ];
|
|
|
|
|
2022-04-17 21:24:13 +00:00
|
|
|
${optionalString systemdStage1 "boot.initrd.systemd.enable = true;"}
|
|
|
|
|
2016-04-23 11:20:34 +00:00
|
|
|
${optionalString (bootLoader == "grub") ''
|
|
|
|
boot.loader.grub.version = ${toString grubVersion};
|
|
|
|
${optionalString (grubVersion == 1) ''
|
|
|
|
boot.loader.grub.splashImage = null;
|
|
|
|
''}
|
2017-02-15 22:59:40 +00:00
|
|
|
|
2020-04-23 00:30:19 +00:00
|
|
|
boot.loader.grub.extraConfig = "serial; terminal_output serial";
|
2017-02-15 22:59:40 +00:00
|
|
|
${if grubUseEfi then ''
|
|
|
|
boot.loader.grub.device = "nodev";
|
|
|
|
boot.loader.grub.efiSupport = true;
|
|
|
|
boot.loader.grub.efiInstallAsRemovable = true; # XXX: needed for OVMF?
|
|
|
|
'' else ''
|
|
|
|
boot.loader.grub.device = "${grubDevice}";
|
|
|
|
boot.loader.grub.fsIdentifier = "${grubIdentifier}";
|
|
|
|
''}
|
2016-04-23 11:20:34 +00:00
|
|
|
|
|
|
|
boot.loader.grub.configurationLimit = 100 + ${toString forceGrubReinstallCount};
|
2012-04-11 09:42:53 +00:00
|
|
|
''}
|
2010-01-10 01:26:01 +00:00
|
|
|
|
2016-06-01 10:51:33 +00:00
|
|
|
${optionalString (bootLoader == "systemd-boot") ''
|
|
|
|
boot.loader.systemd-boot.enable = true;
|
2016-04-23 11:20:34 +00:00
|
|
|
''}
|
2014-09-04 17:30:25 +00:00
|
|
|
|
2023-01-01 16:20:37 +00:00
|
|
|
boot.initrd.secrets."/etc/secret" = /etc/nixos/secret;
|
|
|
|
|
2018-06-29 23:55:42 +00:00
|
|
|
users.users.alice = {
|
2017-02-20 19:57:16 +00:00
|
|
|
isNormalUser = true;
|
|
|
|
home = "/home/alice";
|
|
|
|
description = "Alice Foobar";
|
|
|
|
};
|
|
|
|
|
2015-06-10 11:14:40 +00:00
|
|
|
hardware.enableAllFirmware = lib.mkForce false;
|
2014-12-09 12:27:00 +00:00
|
|
|
|
2022-12-12 01:36:03 +00:00
|
|
|
${replaceStrings ["\n"] ["\n "] extraConfig}
|
2010-01-06 20:52:05 +00:00
|
|
|
}
|
|
|
|
'';
|
|
|
|
|
2011-09-14 18:20:50 +00:00
|
|
|
|
2015-06-10 11:14:40 +00:00
|
|
|
# The test script boots a NixOS VM, installs NixOS on an empty hard
|
2010-01-07 14:19:19 +00:00
|
|
|
# disk, and then reboot from the hard disk. It's parameterized with
|
|
|
|
# a test script fragment `createPartitions', which must create
|
2014-04-30 07:40:18 +00:00
|
|
|
# partitions and filesystems.
|
2017-02-15 22:59:40 +00:00
|
|
|
testScriptFun = { bootLoader, createPartitions, grubVersion, grubDevice, grubUseEfi
|
2020-05-25 02:05:55 +00:00
|
|
|
, grubIdentifier, preBootCommands, postBootCommands, extraConfig
|
2020-03-05 22:07:20 +00:00
|
|
|
, testSpecialisationConfig
|
2015-05-21 10:37:14 +00:00
|
|
|
}:
|
2020-01-28 07:54:05 +00:00
|
|
|
let iface = if grubVersion == 1 then "ide" else "virtio";
|
|
|
|
isEfi = bootLoader == "systemd-boot" || (bootLoader == "grub" && grubUseEfi);
|
|
|
|
bios = if pkgs.stdenv.isAarch64 then "QEMU_EFI.fd" else "OVMF.fd";
|
2021-11-21 01:50:41 +00:00
|
|
|
in if !isEfi && !pkgs.stdenv.hostPlatform.isx86 then
|
2018-03-23 17:27:31 +00:00
|
|
|
throw "Non-EFI boot methods are only supported on i686 / x86_64"
|
|
|
|
else ''
|
2020-01-28 07:54:05 +00:00
|
|
|
def assemble_qemu_flags():
|
2020-08-22 04:33:59 +00:00
|
|
|
flags = "-cpu max"
|
2021-05-03 01:44:52 +00:00
|
|
|
${if (system == "x86_64-linux" || system == "i686-linux")
|
2021-11-24 00:33:53 +00:00
|
|
|
then ''flags += " -m 1024"''
|
|
|
|
else ''flags += " -m 768 -enable-kvm -machine virt,gic-version=host"''
|
2020-01-28 07:54:05 +00:00
|
|
|
}
|
|
|
|
return flags
|
2019-03-07 09:38:28 +00:00
|
|
|
|
2010-01-06 13:36:21 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
qemu_flags = {"qemuFlags": assemble_qemu_flags()}
|
2010-01-06 20:52:05 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
hd_flags = {
|
|
|
|
"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}
|
2014-05-30 19:22:25 +00:00
|
|
|
|
2010-01-06 14:37:23 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
def create_machine_named(name):
|
2020-05-11 22:41:18 +00:00
|
|
|
return create_machine({**default_flags, "name": name})
|
2010-01-06 16:46:21 +00:00
|
|
|
|
2010-01-06 20:52:05 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
machine.start()
|
2010-01-06 16:46:21 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
with subtest("Assert readiness of login prompt"):
|
|
|
|
machine.succeed("echo hello")
|
2011-09-14 18:20:50 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
with subtest("Wait for hard disks to appear in /dev"):
|
|
|
|
machine.succeed("udevadm settle")
|
2012-05-24 23:39:03 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
${createPartitions}
|
2014-04-30 12:51:27 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
with subtest("Create the NixOS configuration"):
|
|
|
|
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",
|
|
|
|
)
|
2023-01-01 16:20:37 +00:00
|
|
|
machine.copy_from_host("${pkgs.writeText "secret" "secret"}", "/mnt/etc/nixos/secret")
|
2020-01-28 07:54:05 +00:00
|
|
|
|
|
|
|
with subtest("Perform the installation"):
|
|
|
|
machine.succeed("nixos-install < /dev/null >&2")
|
|
|
|
|
|
|
|
with subtest("Do it again to make sure it's idempotent"):
|
|
|
|
machine.succeed("nixos-install < /dev/null >&2")
|
|
|
|
|
2023-01-01 16:20:37 +00:00
|
|
|
with subtest("Check that we can build things in nixos-enter"):
|
|
|
|
machine.succeed(
|
|
|
|
"""
|
|
|
|
nixos-enter -- nix-build --option substitute false -E 'derivation {
|
|
|
|
name = "t";
|
|
|
|
builder = "/bin/sh";
|
|
|
|
args = ["-c" "echo nixos-enter build > $out"];
|
|
|
|
system = builtins.currentSystem;
|
|
|
|
preferLocalBuild = true;
|
|
|
|
}'
|
|
|
|
"""
|
|
|
|
)
|
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
with subtest("Shutdown system after installation"):
|
|
|
|
machine.succeed("umount /mnt/boot || true")
|
|
|
|
machine.succeed("umount /mnt")
|
|
|
|
machine.succeed("sync")
|
|
|
|
machine.shutdown()
|
2010-01-06 15:14:26 +00:00
|
|
|
|
|
|
|
# Now see if we can boot the installation.
|
2020-01-28 07:54:05 +00:00
|
|
|
machine = create_machine_named("boot-after-install")
|
2011-09-14 18:20:50 +00:00
|
|
|
|
2015-06-10 11:14:40 +00:00
|
|
|
# For example to enter LUKS passphrase.
|
2015-05-21 10:40:07 +00:00
|
|
|
${preBootCommands}
|
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
with subtest("Assert that /boot get mounted"):
|
|
|
|
machine.wait_for_unit("local-fs.target")
|
|
|
|
${if bootLoader == "grub"
|
|
|
|
then ''machine.succeed("test -e /boot/grub")''
|
|
|
|
else ''machine.succeed("test -e /boot/loader/loader.conf")''
|
|
|
|
}
|
|
|
|
|
|
|
|
with subtest("Check whether /root has correct permissions"):
|
|
|
|
assert "700" in machine.succeed("stat -c '%a' /root")
|
|
|
|
|
|
|
|
with subtest("Assert swap device got activated"):
|
|
|
|
# uncomment once https://bugs.freedesktop.org/show_bug.cgi?id=86930 is resolved
|
|
|
|
machine.wait_for_unit("swap.target")
|
|
|
|
machine.succeed("cat /proc/swaps | grep -q /dev")
|
|
|
|
|
|
|
|
with subtest("Check that the store is in good shape"):
|
|
|
|
machine.succeed("nix-store --verify --check-contents >&2")
|
|
|
|
|
|
|
|
with subtest("Check whether the channel works"):
|
|
|
|
machine.succeed("nix-env -iA nixos.procps >&2")
|
|
|
|
assert ".nix-profile" in machine.succeed("type -tP ps | tee /dev/stderr")
|
|
|
|
|
|
|
|
with subtest(
|
|
|
|
"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")
|
|
|
|
|
|
|
|
with subtest("Configure system with writable Nix store on next boot"):
|
|
|
|
# we're not using copy_from_host here because the installer image
|
|
|
|
# doesn't know about the host-guest sharing mechanism.
|
|
|
|
machine.copy_from_host_via_shell(
|
|
|
|
"${ makeConfig {
|
|
|
|
inherit bootLoader grubVersion grubDevice grubIdentifier
|
|
|
|
grubUseEfi extraConfig;
|
|
|
|
forceGrubReinstallCount = 1;
|
|
|
|
}
|
|
|
|
}",
|
|
|
|
"/etc/nixos/configuration.nix",
|
|
|
|
)
|
|
|
|
|
|
|
|
with subtest("Check whether nixos-rebuild works"):
|
|
|
|
machine.succeed("nixos-rebuild switch >&2")
|
|
|
|
|
2021-11-10 23:57:18 +00:00
|
|
|
# FIXME: Nix 2.4 broke nixos-option, someone has to fix it.
|
|
|
|
# with subtest("Test nixos-option"):
|
|
|
|
# kernel_modules = machine.succeed("nixos-option boot.initrd.kernelModules")
|
|
|
|
# assert "virtio_console" in kernel_modules
|
|
|
|
# assert "List of modules" in kernel_modules
|
|
|
|
# assert "qemu-guest.nix" in kernel_modules
|
2020-01-28 07:54:05 +00:00
|
|
|
|
|
|
|
machine.shutdown()
|
2010-01-06 22:53:27 +00:00
|
|
|
|
2014-09-04 17:30:25 +00:00
|
|
|
# Check whether a writable store build works
|
2020-01-28 07:54:05 +00:00
|
|
|
machine = create_machine_named("rebuild-switch")
|
2015-05-21 10:40:07 +00:00
|
|
|
${preBootCommands}
|
2020-01-28 07:54:05 +00:00
|
|
|
machine.wait_for_unit("multi-user.target")
|
|
|
|
|
|
|
|
# we're not using copy_from_host here because the installer image
|
|
|
|
# doesn't know about the host-guest sharing mechanism.
|
|
|
|
machine.copy_from_host_via_shell(
|
|
|
|
"${ makeConfig {
|
|
|
|
inherit bootLoader grubVersion grubDevice grubIdentifier
|
|
|
|
grubUseEfi extraConfig;
|
|
|
|
forceGrubReinstallCount = 2;
|
|
|
|
}
|
|
|
|
}",
|
|
|
|
"/etc/nixos/configuration.nix",
|
|
|
|
)
|
|
|
|
machine.succeed("nixos-rebuild boot >&2")
|
|
|
|
machine.shutdown()
|
2014-09-04 17:30:25 +00:00
|
|
|
|
2010-01-06 22:53:27 +00:00
|
|
|
# And just to be sure, check that the machine still boots after
|
|
|
|
# "nixos-rebuild switch".
|
2020-01-28 07:54:05 +00:00
|
|
|
machine = create_machine_named("boot-after-rebuild-switch")
|
2015-05-21 10:40:07 +00:00
|
|
|
${preBootCommands}
|
2020-01-28 07:54:05 +00:00
|
|
|
machine.wait_for_unit("network.target")
|
2020-05-25 02:05:55 +00:00
|
|
|
${postBootCommands}
|
2020-01-28 07:54:05 +00:00
|
|
|
machine.shutdown()
|
2019-03-07 09:38:28 +00:00
|
|
|
|
|
|
|
# Tests for validating clone configuration entries in grub menu
|
2020-01-28 07:54:05 +00:00
|
|
|
''
|
2020-03-05 22:07:20 +00:00
|
|
|
+ optionalString testSpecialisationConfig ''
|
2020-01-28 07:54:05 +00:00
|
|
|
# Reboot Machine
|
|
|
|
machine = create_machine_named("clone-default-config")
|
|
|
|
${preBootCommands}
|
|
|
|
machine.wait_for_unit("multi-user.target")
|
2019-03-07 09:38:28 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
with subtest("Booted configuration name should be 'Home'"):
|
|
|
|
# This is not the name that shows in the grub menu.
|
|
|
|
# The default configuration is always shown as "Default"
|
|
|
|
machine.succeed("cat /run/booted-system/configuration-name >&2")
|
|
|
|
assert "Home" in machine.succeed("cat /run/booted-system/configuration-name")
|
2019-03-07 09:38:28 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
with subtest("We should **not** find a file named /etc/gitconfig"):
|
|
|
|
machine.fail("test -e /etc/gitconfig")
|
2019-03-07 09:38:28 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
with subtest("Set grub to boot the second configuration"):
|
|
|
|
machine.succeed("grub-reboot 1")
|
2019-03-07 09:38:28 +00:00
|
|
|
|
2020-05-25 02:05:55 +00:00
|
|
|
${postBootCommands}
|
2020-01-28 07:54:05 +00:00
|
|
|
machine.shutdown()
|
2019-03-07 09:38:28 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
# Reboot Machine
|
|
|
|
machine = create_machine_named("clone-alternate-config")
|
|
|
|
${preBootCommands}
|
2019-03-07 09:38:28 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
machine.wait_for_unit("multi-user.target")
|
|
|
|
with subtest("Booted configuration name should be Work"):
|
|
|
|
machine.succeed("cat /run/booted-system/configuration-name >&2")
|
|
|
|
assert "Work" in machine.succeed("cat /run/booted-system/configuration-name")
|
2019-03-07 09:38:28 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
with subtest("We should find a file named /etc/gitconfig"):
|
|
|
|
machine.succeed("test -e /etc/gitconfig")
|
2019-03-07 09:38:28 +00:00
|
|
|
|
2020-05-25 02:05:55 +00:00
|
|
|
${postBootCommands}
|
2020-01-28 07:54:05 +00:00
|
|
|
machine.shutdown()
|
2010-01-06 15:14:26 +00:00
|
|
|
'';
|
2010-01-06 16:46:21 +00:00
|
|
|
|
2011-09-14 18:20:50 +00:00
|
|
|
|
2014-06-28 14:04:49 +00:00
|
|
|
makeInstallerTest = name:
|
2020-05-25 02:05:55 +00:00
|
|
|
{ createPartitions, preBootCommands ? "", postBootCommands ? "", extraConfig ? ""
|
2017-06-27 23:35:55 +00:00
|
|
|
, extraInstallerConfig ? {}
|
2016-06-01 10:51:33 +00:00
|
|
|
, bootLoader ? "grub" # either "grub" or "systemd-boot"
|
2017-02-15 22:59:40 +00:00
|
|
|
, grubVersion ? 2, grubDevice ? "/dev/vda", grubIdentifier ? "uuid", grubUseEfi ? false
|
2016-04-23 11:20:34 +00:00
|
|
|
, enableOCR ? false, meta ? {}
|
2020-03-05 22:07:20 +00:00
|
|
|
, testSpecialisationConfig ? false
|
2015-05-21 10:37:14 +00:00
|
|
|
}:
|
2014-04-14 14:24:08 +00:00
|
|
|
makeTest {
|
2015-05-22 05:14:00 +00:00
|
|
|
inherit enableOCR;
|
2015-06-10 11:14:40 +00:00
|
|
|
name = "installer-" + name;
|
2021-01-10 19:08:30 +00:00
|
|
|
meta = with pkgs.lib.maintainers; {
|
2015-07-12 10:09:40 +00:00
|
|
|
# put global maintainers here, individuals go into makeInstallerTest fkt call
|
2019-01-26 10:01:09 +00:00
|
|
|
maintainers = (meta.maintainers or []);
|
2015-07-12 10:09:40 +00:00
|
|
|
};
|
2015-06-10 11:14:40 +00:00
|
|
|
nodes = {
|
|
|
|
|
2018-02-07 18:32:41 +00:00
|
|
|
# The configuration of the machine used to run "nixos-install".
|
2020-01-28 07:54:05 +00:00
|
|
|
machine = { pkgs, ... }: {
|
|
|
|
imports = [
|
|
|
|
../modules/profiles/installation-device.nix
|
|
|
|
../modules/profiles/base.nix
|
|
|
|
extraInstallerConfig
|
|
|
|
];
|
|
|
|
|
2021-01-10 12:41:09 +00:00
|
|
|
# builds stuff in the VM, needs more juice
|
2020-01-28 07:54:05 +00:00
|
|
|
virtualisation.diskSize = 8 * 1024;
|
2021-01-10 12:41:09 +00:00
|
|
|
virtualisation.cores = 8;
|
2023-01-10 16:45:34 +00:00
|
|
|
virtualisation.memorySize = 2047;
|
2020-01-28 07:54:05 +00:00
|
|
|
|
2022-04-17 21:24:13 +00:00
|
|
|
boot.initrd.systemd.enable = systemdStage1;
|
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
# Use a small /dev/vdb as the root disk for the
|
|
|
|
# installer. This ensures the target disk (/dev/vda) is
|
|
|
|
# the same during and after installation.
|
|
|
|
virtualisation.emptyDiskImages = [ 512 ];
|
|
|
|
virtualisation.bootDevice =
|
nixosTests.installer: Fix grub1 test being unreliable
The kernel sometimes assigns `/dev/sdb` to the 8GiB disk. This, in turn,
means the test will fail because we're targeting the wrong disk.
```
machine # [ 0.000000] sd 2:0:0:0: [sda] 16777216 512-byte logical blocks: (8.59 GB/8.00 GiB)
machine # [ 0.000000] sd 3:0:0:0: [sdb] 1048576 512-byte logical blocks: (537 MB/512 MiB)
```
```
machine # [ 0.000000] sd 2:0:0:0: [sdb] 16777216 512-byte logical blocks: (8.59 GB/8.00 GiB)
machine # [ 0.000000] sd 3:0:0:0: [sda] 1048576 512-byte logical blocks: (537 MB/512 MiB)
```
Note how the "sd x:0:0:0:` ID is stable. That is because QEMU **is**
told to give specific identifiers to the disks. So using the
dev/disk/by-id/ identifiers is stable.
* * *
Tested by forcing the sda/sdb swap this way:
diff --git a/nixos/tests/installer.nix b/nixos/tests/installer.nix
index 24c55081f9a..2eee224351b 100644
--- a/nixos/tests/installer.nix
+++ b/nixos/tests/installer.nix
@@ -702,12 +702,19 @@ in {
+ " mkpart primary linux-swap 1M 1024M"
+ " mkpart primary ext2 1024M -1s",
"udevadm settle",
+ )
+ print(machine.succeed("find /dev/disk/ '!' -type d -printf '%p → %l\n' | sort"))
+ machine.succeed(
"mkswap ${grubDevice}-part1 -L swap",
"swapon -L swap",
"mkfs.ext3 -L nixos ${grubDevice}-part2",
"mount LABEL=nixos /mnt",
"mkdir -p /mnt/tmp",
)
+ machine.succeed("echo success")
+ machine.succeed(
+ 'if [[ "$(find ${grubDevice} -printf \'%l\')" != "../../sdb" ]]; then exit 22; else true; fi'
+ )
'';
grubVersion = 1;
# /dev/sda is not stable, even when the SCSI disk number is.
And ran this way:
$ until (clear; tmux clear ; time env -i nix-build nixos/release-combined.nix -A nixos.tests.installer.grub1.x86_64-linux); do echo derp; done
2021-04-25 23:37:19 +00:00
|
|
|
if grubVersion == 1 then "/dev/disk/by-id/scsi-0QEMU_QEMU_HARDDISK_drive2" else "/dev/vdb";
|
2020-01-28 07:54:05 +00:00
|
|
|
virtualisation.qemu.diskInterface =
|
|
|
|
if grubVersion == 1 then "scsi" else "virtio";
|
|
|
|
|
2022-04-22 19:27:03 +00:00
|
|
|
# We don't want to have any networking in the guest whatsoever.
|
|
|
|
# Also, if any vlans are enabled, the guest will reboot
|
|
|
|
# (with a different configuration for legacy reasons),
|
|
|
|
# and spend 5 minutes waiting for the vlan interface to show up
|
|
|
|
# (which will never happen).
|
|
|
|
virtualisation.vlans = [];
|
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
boot.loader.systemd-boot.enable = mkIf (bootLoader == "systemd-boot") true;
|
|
|
|
|
|
|
|
hardware.enableAllFirmware = mkForce false;
|
|
|
|
|
|
|
|
# The test cannot access the network, so any packages we
|
|
|
|
# need must be included in the VM.
|
|
|
|
system.extraDependencies = with pkgs; [
|
2022-01-22 20:44:44 +00:00
|
|
|
brotli
|
|
|
|
brotli.dev
|
|
|
|
brotli.lib
|
2020-01-28 07:54:05 +00:00
|
|
|
desktop-file-utils
|
|
|
|
docbook5
|
|
|
|
docbook_xsl_ns
|
2022-06-26 12:59:21 +00:00
|
|
|
(docbook-xsl-ns.override {
|
|
|
|
withManOptDedupPatch = true;
|
|
|
|
})
|
2022-04-05 16:54:45 +00:00
|
|
|
kmod.dev
|
2022-04-22 18:03:46 +00:00
|
|
|
libarchive.dev
|
2020-01-28 07:54:05 +00:00
|
|
|
libxml2.bin
|
|
|
|
libxslt.bin
|
|
|
|
nixos-artwork.wallpapers.simple-dark-gray-bottom
|
|
|
|
ntp
|
|
|
|
perlPackages.ListCompare
|
|
|
|
perlPackages.XMLLibXML
|
2022-01-22 20:44:44 +00:00
|
|
|
python3Minimal
|
2022-09-18 11:59:14 +00:00
|
|
|
# make-options-doc/default.nix
|
|
|
|
(let
|
|
|
|
self = (pkgs.python3Minimal.override {
|
|
|
|
inherit self;
|
|
|
|
includeSiteCustomize = true;
|
|
|
|
});
|
|
|
|
in self.withPackages (p: [ p.mistune ]))
|
2020-01-28 07:54:05 +00:00
|
|
|
shared-mime-info
|
|
|
|
sudo
|
|
|
|
texinfo
|
|
|
|
unionfs-fuse
|
|
|
|
xorg.lndir
|
|
|
|
|
|
|
|
# add curl so that rather than seeing the test attempt to download
|
|
|
|
# curl's tarball, we see what it's trying to download
|
|
|
|
curl
|
|
|
|
]
|
|
|
|
++ optional (bootLoader == "grub" && grubVersion == 1) pkgs.grub
|
2021-02-13 03:33:46 +00:00
|
|
|
++ optionals (bootLoader == "grub" && grubVersion == 2) (let
|
|
|
|
zfsSupport = lib.any (x: x == "zfs")
|
|
|
|
(extraInstallerConfig.boot.supportedFilesystems or []);
|
|
|
|
in [
|
|
|
|
(pkgs.grub2.override { inherit zfsSupport; })
|
|
|
|
(pkgs.grub2_efi.override { inherit zfsSupport; })
|
|
|
|
]);
|
2020-01-28 07:54:05 +00:00
|
|
|
|
2021-11-19 22:36:26 +00:00
|
|
|
nix.settings = {
|
|
|
|
substituters = mkForce [];
|
|
|
|
hashed-mirrors = null;
|
|
|
|
connect-timeout = 1;
|
|
|
|
};
|
2020-01-28 07:54:05 +00:00
|
|
|
};
|
2015-06-10 11:14:40 +00:00
|
|
|
|
|
|
|
};
|
|
|
|
|
2010-01-10 01:26:01 +00:00
|
|
|
testScript = testScriptFun {
|
2020-05-25 02:05:55 +00:00
|
|
|
inherit bootLoader createPartitions preBootCommands postBootCommands
|
2019-03-07 09:38:28 +00:00
|
|
|
grubVersion grubDevice grubIdentifier grubUseEfi extraConfig
|
2020-03-05 22:07:20 +00:00
|
|
|
testSpecialisationConfig;
|
2010-01-10 01:26:01 +00:00
|
|
|
};
|
2014-04-14 14:24:08 +00:00
|
|
|
};
|
2011-09-14 18:20:50 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
makeLuksRootTest = name: luksFormatOpts: makeInstallerTest name {
|
|
|
|
createPartitions = ''
|
|
|
|
machine.succeed(
|
2019-03-01 22:47:19 +00:00
|
|
|
"flock /dev/vda parted --script /dev/vda -- mklabel msdos"
|
2021-11-30 01:53:14 +00:00
|
|
|
+ " mkpart primary ext2 1M 100MB" # /boot
|
|
|
|
+ " mkpart primary linux-swap 100M 1024M"
|
2020-01-28 07:54:05 +00:00
|
|
|
+ " mkpart primary 1024M -1s", # LUKS
|
2019-03-01 22:47:19 +00:00
|
|
|
"udevadm settle",
|
|
|
|
"mkswap /dev/vda2 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"modprobe dm_mod dm_crypt",
|
|
|
|
"echo -n supersecret | cryptsetup luksFormat ${luksFormatOpts} -q /dev/vda3 -",
|
|
|
|
"echo -n supersecret | cryptsetup luksOpen --key-file - /dev/vda3 cryptroot",
|
|
|
|
"mkfs.ext3 -L nixos /dev/mapper/cryptroot",
|
|
|
|
"mount LABEL=nixos /mnt",
|
|
|
|
"mkfs.ext3 -L boot /dev/vda1",
|
|
|
|
"mkdir -p /mnt/boot",
|
|
|
|
"mount LABEL=boot /mnt/boot",
|
2020-01-28 07:54:05 +00:00
|
|
|
)
|
|
|
|
'';
|
|
|
|
extraConfig = ''
|
|
|
|
boot.kernelParams = lib.mkAfter [ "console=tty0" ];
|
|
|
|
'';
|
|
|
|
enableOCR = true;
|
|
|
|
preBootCommands = ''
|
|
|
|
machine.start()
|
|
|
|
machine.wait_for_text("Passphrase for")
|
|
|
|
machine.send_chars("supersecret\n")
|
|
|
|
'';
|
|
|
|
};
|
2019-03-01 22:47:19 +00:00
|
|
|
|
2019-03-07 09:30:11 +00:00
|
|
|
# The (almost) simplest partitioning scheme: a swap partition and
|
|
|
|
# one big filesystem partition.
|
2020-01-28 07:54:05 +00:00
|
|
|
simple-test-config = {
|
|
|
|
createPartitions = ''
|
|
|
|
machine.succeed(
|
|
|
|
"flock /dev/vda parted --script /dev/vda -- mklabel msdos"
|
|
|
|
+ " mkpart primary linux-swap 1M 1024M"
|
|
|
|
+ " mkpart primary ext2 1024M -1s",
|
|
|
|
"udevadm settle",
|
|
|
|
"mkswap /dev/vda1 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"mkfs.ext3 -L nixos /dev/vda2",
|
|
|
|
"mount LABEL=nixos /mnt",
|
|
|
|
)
|
|
|
|
'';
|
|
|
|
};
|
|
|
|
|
|
|
|
simple-uefi-grub-config = {
|
|
|
|
createPartitions = ''
|
|
|
|
machine.succeed(
|
|
|
|
"flock /dev/vda parted --script /dev/vda -- mklabel gpt"
|
2021-02-18 09:58:25 +00:00
|
|
|
+ " mkpart ESP fat32 1M 100MiB" # /boot
|
2020-01-28 07:54:05 +00:00
|
|
|
+ " set 1 boot on"
|
2021-02-18 09:58:25 +00:00
|
|
|
+ " mkpart primary linux-swap 100MiB 1024MiB"
|
2020-01-28 07:54:05 +00:00
|
|
|
+ " mkpart primary ext2 1024MiB -1MiB", # /
|
|
|
|
"udevadm settle",
|
|
|
|
"mkswap /dev/vda2 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"mkfs.ext3 -L nixos /dev/vda3",
|
|
|
|
"mount LABEL=nixos /mnt",
|
|
|
|
"mkfs.vfat -n BOOT /dev/vda1",
|
|
|
|
"mkdir -p /mnt/boot",
|
|
|
|
"mount LABEL=BOOT /mnt/boot",
|
|
|
|
)
|
|
|
|
'';
|
|
|
|
bootLoader = "grub";
|
|
|
|
grubUseEfi = true;
|
|
|
|
};
|
2019-03-07 09:38:28 +00:00
|
|
|
|
2020-03-05 22:07:20 +00:00
|
|
|
specialisation-test-extraconfig = {
|
2020-01-28 07:54:05 +00:00
|
|
|
extraConfig = ''
|
|
|
|
environment.systemPackages = [ pkgs.grub2 ];
|
|
|
|
boot.loader.grub.configurationName = "Home";
|
2020-03-05 22:07:20 +00:00
|
|
|
specialisation.work.configuration = {
|
2020-01-28 07:54:05 +00:00
|
|
|
boot.loader.grub.configurationName = lib.mkForce "Work";
|
|
|
|
|
|
|
|
environment.etc = {
|
|
|
|
"gitconfig".text = "
|
|
|
|
[core]
|
|
|
|
gitproxy = none for work.com
|
|
|
|
";
|
|
|
|
};
|
2020-03-05 22:07:20 +00:00
|
|
|
};
|
2020-01-28 07:54:05 +00:00
|
|
|
'';
|
2020-03-05 22:07:20 +00:00
|
|
|
testSpecialisationConfig = true;
|
2019-03-07 09:38:28 +00:00
|
|
|
};
|
2023-01-01 18:52:05 +00:00
|
|
|
# disable zfs so we can support latest kernel if needed
|
|
|
|
no-zfs-module = {
|
|
|
|
nixpkgs.overlays = [(final: super: {
|
|
|
|
zfs = super.zfs.overrideAttrs(_: {meta.platforms = [];});}
|
|
|
|
)];
|
|
|
|
};
|
2019-03-07 09:36:40 +00:00
|
|
|
in {
|
|
|
|
|
|
|
|
# !!! `parted mkpart' seems to silently create overlapping partitions.
|
|
|
|
|
|
|
|
|
|
|
|
# The (almost) simplest partitioning scheme: a swap partition and
|
|
|
|
# one big filesystem partition.
|
|
|
|
simple = makeInstallerTest "simple" simple-test-config;
|
2016-04-23 11:20:34 +00:00
|
|
|
|
2019-03-07 09:38:28 +00:00
|
|
|
# Test cloned configurations with the simple grub configuration
|
2020-03-05 22:07:20 +00:00
|
|
|
simpleSpecialised = makeInstallerTest "simpleSpecialised" (simple-test-config // specialisation-test-extraconfig);
|
2019-03-07 09:38:28 +00:00
|
|
|
|
2019-03-07 09:36:40 +00:00
|
|
|
# Simple GPT/UEFI configuration using systemd-boot with 3 partitions: ESP, swap & root filesystem
|
2020-01-28 07:54:05 +00:00
|
|
|
simpleUefiSystemdBoot = makeInstallerTest "simpleUefiSystemdBoot" {
|
|
|
|
createPartitions = ''
|
|
|
|
machine.succeed(
|
|
|
|
"flock /dev/vda parted --script /dev/vda -- mklabel gpt"
|
2021-11-30 01:53:14 +00:00
|
|
|
+ " mkpart ESP fat32 1M 100MiB" # /boot
|
2020-01-28 07:54:05 +00:00
|
|
|
+ " set 1 boot on"
|
2021-11-30 01:53:14 +00:00
|
|
|
+ " mkpart primary linux-swap 100MiB 1024MiB"
|
2020-01-28 07:54:05 +00:00
|
|
|
+ " mkpart primary ext2 1024MiB -1MiB", # /
|
|
|
|
"udevadm settle",
|
|
|
|
"mkswap /dev/vda2 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"mkfs.ext3 -L nixos /dev/vda3",
|
|
|
|
"mount LABEL=nixos /mnt",
|
|
|
|
"mkfs.vfat -n BOOT /dev/vda1",
|
|
|
|
"mkdir -p /mnt/boot",
|
|
|
|
"mount LABEL=BOOT /mnt/boot",
|
|
|
|
)
|
|
|
|
'';
|
|
|
|
bootLoader = "systemd-boot";
|
|
|
|
};
|
2017-02-15 22:59:40 +00:00
|
|
|
|
2019-03-07 09:36:40 +00:00
|
|
|
simpleUefiGrub = makeInstallerTest "simpleUefiGrub" simple-uefi-grub-config;
|
|
|
|
|
2019-03-07 09:38:28 +00:00
|
|
|
# Test cloned configurations with the uefi grub configuration
|
2020-03-05 22:07:20 +00:00
|
|
|
simpleUefiGrubSpecialisation = makeInstallerTest "simpleUefiGrubSpecialisation" (simple-uefi-grub-config // specialisation-test-extraconfig);
|
2019-03-07 09:38:28 +00:00
|
|
|
|
2010-01-07 13:19:38 +00:00
|
|
|
# Same as the previous, but now with a separate /boot partition.
|
2020-01-28 07:54:05 +00:00
|
|
|
separateBoot = makeInstallerTest "separateBoot" {
|
|
|
|
createPartitions = ''
|
|
|
|
machine.succeed(
|
|
|
|
"flock /dev/vda parted --script /dev/vda -- mklabel msdos"
|
2021-11-30 01:53:14 +00:00
|
|
|
+ " mkpart primary ext2 1M 100MB" # /boot
|
|
|
|
+ " mkpart primary linux-swap 100MB 1024M"
|
2020-01-28 07:54:05 +00:00
|
|
|
+ " mkpart primary ext2 1024M -1s", # /
|
|
|
|
"udevadm settle",
|
|
|
|
"mkswap /dev/vda2 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"mkfs.ext3 -L nixos /dev/vda3",
|
|
|
|
"mount LABEL=nixos /mnt",
|
|
|
|
"mkfs.ext3 -L boot /dev/vda1",
|
|
|
|
"mkdir -p /mnt/boot",
|
|
|
|
"mount LABEL=boot /mnt/boot",
|
|
|
|
)
|
|
|
|
'';
|
|
|
|
};
|
2011-09-14 18:20:50 +00:00
|
|
|
|
2015-07-08 19:05:31 +00:00
|
|
|
# Same as the previous, but with fat32 /boot.
|
2020-01-28 07:54:05 +00:00
|
|
|
separateBootFat = makeInstallerTest "separateBootFat" {
|
|
|
|
createPartitions = ''
|
|
|
|
machine.succeed(
|
|
|
|
"flock /dev/vda parted --script /dev/vda -- mklabel msdos"
|
2021-11-30 01:53:14 +00:00
|
|
|
+ " mkpart primary ext2 1M 100MB" # /boot
|
|
|
|
+ " mkpart primary linux-swap 100MB 1024M"
|
2020-01-28 07:54:05 +00:00
|
|
|
+ " mkpart primary ext2 1024M -1s", # /
|
|
|
|
"udevadm settle",
|
|
|
|
"mkswap /dev/vda2 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"mkfs.ext3 -L nixos /dev/vda3",
|
|
|
|
"mount LABEL=nixos /mnt",
|
|
|
|
"mkfs.vfat -n BOOT /dev/vda1",
|
|
|
|
"mkdir -p /mnt/boot",
|
|
|
|
"mount LABEL=BOOT /mnt/boot",
|
|
|
|
)
|
|
|
|
'';
|
|
|
|
};
|
2015-07-08 19:05:31 +00:00
|
|
|
|
2017-06-27 23:35:55 +00:00
|
|
|
# zfs on / with swap
|
2020-01-28 07:54:05 +00:00
|
|
|
zfsroot = makeInstallerTest "zfs-root" {
|
|
|
|
extraInstallerConfig = {
|
|
|
|
boot.supportedFilesystems = [ "zfs" ];
|
|
|
|
};
|
2017-06-27 23:35:55 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
extraConfig = ''
|
|
|
|
boot.supportedFilesystems = [ "zfs" ];
|
2017-06-27 23:35:55 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
# Using by-uuid overrides the default of by-id, and is unique
|
|
|
|
# to the qemu disks, as they don't produce by-id paths for
|
|
|
|
# some reason.
|
|
|
|
boot.zfs.devNodes = "/dev/disk/by-uuid/";
|
|
|
|
networking.hostId = "00000000";
|
|
|
|
'';
|
2017-06-27 23:35:55 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
createPartitions = ''
|
|
|
|
machine.succeed(
|
|
|
|
"flock /dev/vda parted --script /dev/vda -- mklabel msdos"
|
|
|
|
+ " mkpart primary linux-swap 1M 1024M"
|
|
|
|
+ " mkpart primary 1024M -1s",
|
|
|
|
"udevadm settle",
|
|
|
|
"mkswap /dev/vda1 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"zpool create rpool /dev/vda2",
|
|
|
|
"zfs create -o mountpoint=legacy rpool/root",
|
|
|
|
"mount -t zfs rpool/root /mnt",
|
|
|
|
"udevadm settle",
|
|
|
|
)
|
|
|
|
'';
|
|
|
|
};
|
2017-06-27 23:35:55 +00:00
|
|
|
|
2010-01-07 14:19:19 +00:00
|
|
|
# Create two physical LVM partitions combined into one volume group
|
2012-08-01 19:40:58 +00:00
|
|
|
# that contains the logical swap and root partitions.
|
2020-01-28 07:54:05 +00:00
|
|
|
lvm = makeInstallerTest "lvm" {
|
|
|
|
createPartitions = ''
|
|
|
|
machine.succeed(
|
|
|
|
"flock /dev/vda parted --script /dev/vda -- mklabel msdos"
|
|
|
|
+ " mkpart primary 1M 2048M" # PV1
|
|
|
|
+ " set 1 lvm on"
|
|
|
|
+ " mkpart primary 2048M -1s" # PV2
|
|
|
|
+ " set 2 lvm on",
|
|
|
|
"udevadm settle",
|
|
|
|
"pvcreate /dev/vda1 /dev/vda2",
|
|
|
|
"vgcreate MyVolGroup /dev/vda1 /dev/vda2",
|
|
|
|
"lvcreate --size 1G --name swap MyVolGroup",
|
2022-03-24 00:12:24 +00:00
|
|
|
"lvcreate --size 6G --name nixos MyVolGroup",
|
2020-01-28 07:54:05 +00:00
|
|
|
"mkswap -f /dev/MyVolGroup/swap -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"mkfs.xfs -L nixos /dev/MyVolGroup/nixos",
|
|
|
|
"mount LABEL=nixos /mnt",
|
|
|
|
)
|
|
|
|
'';
|
|
|
|
};
|
2010-05-16 20:44:45 +00:00
|
|
|
|
2019-03-01 22:47:19 +00:00
|
|
|
# Boot off an encrypted root partition with the default LUKS header format
|
|
|
|
luksroot = makeLuksRootTest "luksroot-format1" "";
|
|
|
|
|
|
|
|
# Boot off an encrypted root partition with LUKS1 format
|
|
|
|
luksroot-format1 = makeLuksRootTest "luksroot-format1" "--type=LUKS1";
|
|
|
|
|
|
|
|
# Boot off an encrypted root partition with LUKS2 format
|
|
|
|
luksroot-format2 = makeLuksRootTest "luksroot-format2" "--type=LUKS2";
|
nixos/tests/installer: Add test for LUKS rootfs.
This serves as a regression test for #7859.
It's pretty straightforward, except from the fact that nixos-generate-
config doesn't detect LUKS devices and the "sleep 60".
As for the former, I have tried to add support for LUKS devices for
nixos-generate-config, but it's not so easy as it sounds, because we
need to create a device tree across all possible mappers and/or LVM up
to the "real" device and then decide whether it is relevant to what is
currently mounted. So I guess this is something for the nixpart branch
(see #2079).
And the latter isn't very trivial as well, because the LUKS passphrase
prompt is issued on /dev/console, which is the last "console=..." kernel
parameter (thus the `mkAfter`). So we can't simply grep the log, because
the prompt ends up being on one terminal only (tty0) and using select()
on $machine->{socket} doesn't work very well, because the FD is always
"ready for read". If we would read the FD, we would conflict with
$machine->connect and end up having an inconsistent state. Another idea
would be to use multithreading to do $machine->connect while feeding the
passphrase prompt in a loop and stop the thread once $machine->connect
is done. Turns out that this is not so easy as well, because the threads
need to share the $machine object and of course need to do properly
locking.
In the end I decided to use the "blindly hope that 60 seconds is enough"
approach for now and come up with a better solution later. Other VM
tests surely use sleep as well, but it's $machine->sleep, which is bound
to the clock of the VM, so if the build machine is on high load, a
$machine->sleep gets properly delayed but the timer outside the VM won't
get that delay, so the test is not deterministic.
Tested against the following revisions:
5e3fe39: Before the libgcrypt cleanup (a71f78a) that broke cryptsetup.
69a6848: While cryptsetup was broken (obviously the test failed).
15faa43: After cryptsetup has been switched to OpenSSL (fd588f9).
Signed-off-by: aszlig <aszlig@redmoonstudios.org>
2015-05-21 10:42:00 +00:00
|
|
|
|
2017-09-12 11:57:37 +00:00
|
|
|
# Test whether opening encrypted filesystem with keyfile
|
|
|
|
# Checks for regression of missing cryptsetup, when no luks device without
|
|
|
|
# keyfile is configured
|
2020-01-28 07:54:05 +00:00
|
|
|
encryptedFSWithKeyfile = makeInstallerTest "encryptedFSWithKeyfile" {
|
|
|
|
createPartitions = ''
|
|
|
|
machine.succeed(
|
2018-09-22 10:22:17 +00:00
|
|
|
"flock /dev/vda parted --script /dev/vda -- mklabel msdos"
|
2021-11-30 01:53:14 +00:00
|
|
|
+ " mkpart primary ext2 1M 100MB" # /boot
|
|
|
|
+ " mkpart primary linux-swap 100M 1024M"
|
2020-01-28 07:54:05 +00:00
|
|
|
+ " mkpart primary 1024M 1280M" # LUKS with keyfile
|
|
|
|
+ " mkpart primary 1280M -1s",
|
2017-09-12 11:57:37 +00:00
|
|
|
"udevadm settle",
|
|
|
|
"mkswap /dev/vda2 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"mkfs.ext3 -L nixos /dev/vda4",
|
|
|
|
"mount LABEL=nixos /mnt",
|
|
|
|
"mkfs.ext3 -L boot /dev/vda1",
|
|
|
|
"mkdir -p /mnt/boot",
|
|
|
|
"mount LABEL=boot /mnt/boot",
|
|
|
|
"modprobe dm_mod dm_crypt",
|
|
|
|
"echo -n supersecret > /mnt/keyfile",
|
|
|
|
"cryptsetup luksFormat -q /dev/vda3 --key-file /mnt/keyfile",
|
|
|
|
"cryptsetup luksOpen --key-file /mnt/keyfile /dev/vda3 crypt",
|
|
|
|
"mkfs.ext3 -L test /dev/mapper/crypt",
|
|
|
|
"cryptsetup luksClose crypt",
|
2020-01-28 07:54:05 +00:00
|
|
|
"mkdir -p /mnt/test",
|
|
|
|
)
|
|
|
|
'';
|
|
|
|
extraConfig = ''
|
|
|
|
fileSystems."/test" = {
|
|
|
|
device = "/dev/disk/by-label/test";
|
|
|
|
fsType = "ext3";
|
|
|
|
encrypted.enable = true;
|
|
|
|
encrypted.blkDev = "/dev/vda3";
|
|
|
|
encrypted.label = "crypt";
|
|
|
|
encrypted.keyFile = "/mnt-root/keyfile";
|
|
|
|
};
|
|
|
|
'';
|
|
|
|
};
|
2017-09-12 11:57:37 +00:00
|
|
|
|
2020-01-28 07:54:05 +00:00
|
|
|
swraid = makeInstallerTest "swraid" {
|
|
|
|
createPartitions = ''
|
|
|
|
machine.succeed(
|
|
|
|
"flock /dev/vda parted --script /dev/vda --"
|
|
|
|
+ " mklabel msdos"
|
|
|
|
+ " mkpart primary ext2 1M 100MB" # /boot
|
|
|
|
+ " mkpart extended 100M -1s"
|
2020-09-05 08:32:42 +00:00
|
|
|
+ " mkpart logical 102M 3102M" # md0 (root), first device
|
|
|
|
+ " mkpart logical 3103M 6103M" # md0 (root), second device
|
|
|
|
+ " mkpart logical 6104M 6360M" # md1 (swap), first device
|
|
|
|
+ " mkpart logical 6361M 6617M", # md1 (swap), second device
|
2020-01-28 07:54:05 +00:00
|
|
|
"udevadm settle",
|
|
|
|
"ls -l /dev/vda* >&2",
|
|
|
|
"cat /proc/partitions >&2",
|
|
|
|
"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/md1 --metadata 1.2 --level=raid1 "
|
|
|
|
+ "--raid-devices=2 /dev/vda7 /dev/vda8",
|
|
|
|
"udevadm control --start-exec-queue",
|
|
|
|
"udevadm settle",
|
|
|
|
"mkswap -f /dev/md1 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"mkfs.ext3 -L nixos /dev/md0",
|
|
|
|
"mount LABEL=nixos /mnt",
|
|
|
|
"mkfs.ext3 -L boot /dev/vda1",
|
|
|
|
"mkdir /mnt/boot",
|
|
|
|
"mount LABEL=boot /mnt/boot",
|
|
|
|
"udevadm settle",
|
|
|
|
)
|
|
|
|
'';
|
|
|
|
preBootCommands = ''
|
|
|
|
machine.start()
|
|
|
|
machine.fail("dmesg | grep 'immediate safe mode'")
|
|
|
|
'';
|
|
|
|
};
|
2010-09-25 09:32:22 +00:00
|
|
|
|
2020-02-13 01:30:49 +00:00
|
|
|
bcache = makeInstallerTest "bcache" {
|
|
|
|
createPartitions = ''
|
|
|
|
machine.succeed(
|
|
|
|
"flock /dev/vda parted --script /dev/vda --"
|
|
|
|
+ " mklabel msdos"
|
2021-11-30 01:53:14 +00:00
|
|
|
+ " mkpart primary ext2 1M 100MB" # /boot
|
|
|
|
+ " mkpart primary 100MB 512MB " # swap
|
2020-02-13 01:30:49 +00:00
|
|
|
+ " mkpart primary 512MB 1024MB" # Cache (typically SSD)
|
|
|
|
+ " mkpart primary 1024MB -1s ", # Backing device (typically HDD)
|
|
|
|
"modprobe bcache",
|
|
|
|
"udevadm settle",
|
|
|
|
"make-bcache -B /dev/vda4 -C /dev/vda3",
|
|
|
|
"udevadm settle",
|
|
|
|
"mkfs.ext3 -L nixos /dev/bcache0",
|
|
|
|
"mount LABEL=nixos /mnt",
|
|
|
|
"mkfs.ext3 -L boot /dev/vda1",
|
|
|
|
"mkdir /mnt/boot",
|
|
|
|
"mount LABEL=boot /mnt/boot",
|
|
|
|
"mkswap -f /dev/vda2 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
)
|
|
|
|
'';
|
|
|
|
};
|
|
|
|
|
2022-05-05 00:26:43 +00:00
|
|
|
bcachefsSimple = makeInstallerTest "bcachefs-simple" {
|
|
|
|
extraInstallerConfig = {
|
|
|
|
boot.supportedFilesystems = [ "bcachefs" ];
|
2023-01-01 18:52:05 +00:00
|
|
|
imports = [ no-zfs-module ];
|
2022-05-05 00:26:43 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
createPartitions = ''
|
|
|
|
machine.succeed(
|
|
|
|
"flock /dev/vda parted --script /dev/vda -- mklabel msdos"
|
|
|
|
+ " mkpart primary ext2 1M 100MB" # /boot
|
|
|
|
+ " mkpart primary linux-swap 100M 1024M" # swap
|
|
|
|
+ " mkpart primary 1024M -1s", # /
|
|
|
|
"udevadm settle",
|
|
|
|
"mkswap /dev/vda2 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"mkfs.bcachefs -L root /dev/vda3",
|
|
|
|
"mount -t bcachefs /dev/vda3 /mnt",
|
|
|
|
"mkfs.ext3 -L boot /dev/vda1",
|
|
|
|
"mkdir -p /mnt/boot",
|
|
|
|
"mount /dev/vda1 /mnt/boot",
|
|
|
|
)
|
|
|
|
'';
|
|
|
|
};
|
|
|
|
|
|
|
|
bcachefsEncrypted = makeInstallerTest "bcachefs-encrypted" {
|
|
|
|
extraInstallerConfig = {
|
|
|
|
boot.supportedFilesystems = [ "bcachefs" ];
|
2023-01-01 18:52:05 +00:00
|
|
|
|
|
|
|
# disable zfs so we can support latest kernel if needed
|
|
|
|
imports = [ no-zfs-module ];
|
|
|
|
|
2022-05-05 00:26:43 +00:00
|
|
|
environment.systemPackages = with pkgs; [ keyutils ];
|
|
|
|
};
|
|
|
|
|
|
|
|
extraConfig = ''
|
2023-01-01 18:53:11 +00:00
|
|
|
boot.kernelParams = lib.mkAfter [ "console=tty0" ];
|
|
|
|
'';
|
|
|
|
|
|
|
|
enableOCR = true;
|
|
|
|
preBootCommands = ''
|
|
|
|
machine.start()
|
|
|
|
machine.wait_for_text("enter passphrase for ")
|
|
|
|
machine.send_chars("password\n")
|
2022-05-05 00:26:43 +00:00
|
|
|
'';
|
|
|
|
|
|
|
|
createPartitions = ''
|
|
|
|
machine.succeed(
|
|
|
|
"flock /dev/vda parted --script /dev/vda -- mklabel msdos"
|
|
|
|
+ " mkpart primary ext2 1M 100MB" # /boot
|
|
|
|
+ " mkpart primary linux-swap 100M 1024M" # swap
|
|
|
|
+ " mkpart primary 1024M -1s", # /
|
|
|
|
"udevadm settle",
|
|
|
|
"mkswap /dev/vda2 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"keyctl link @u @s",
|
|
|
|
"echo password | mkfs.bcachefs -L root --encrypted /dev/vda3",
|
|
|
|
"echo password | bcachefs unlock /dev/vda3",
|
|
|
|
"mount -t bcachefs /dev/vda3 /mnt",
|
|
|
|
"mkfs.ext3 -L boot /dev/vda1",
|
|
|
|
"mkdir -p /mnt/boot",
|
|
|
|
"mount /dev/vda1 /mnt/boot",
|
|
|
|
)
|
|
|
|
'';
|
|
|
|
};
|
|
|
|
|
|
|
|
bcachefsMulti = makeInstallerTest "bcachefs-multi" {
|
|
|
|
extraInstallerConfig = {
|
|
|
|
boot.supportedFilesystems = [ "bcachefs" ];
|
2023-01-01 18:52:05 +00:00
|
|
|
|
|
|
|
# disable zfs so we can support latest kernel if needed
|
|
|
|
imports = [ no-zfs-module ];
|
2022-05-05 00:26:43 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
createPartitions = ''
|
|
|
|
machine.succeed(
|
|
|
|
"flock /dev/vda parted --script /dev/vda -- mklabel msdos"
|
|
|
|
+ " mkpart primary ext2 1M 100MB" # /boot
|
|
|
|
+ " mkpart primary linux-swap 100M 1024M" # swap
|
|
|
|
+ " mkpart primary 1024M 4096M" # /
|
|
|
|
+ " mkpart primary 4096M -1s", # /
|
|
|
|
"udevadm settle",
|
|
|
|
"mkswap /dev/vda2 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"mkfs.bcachefs -L root --metadata_replicas 2 --foreground_target ssd --promote_target ssd --background_target hdd --label ssd /dev/vda3 --label hdd /dev/vda4",
|
|
|
|
"mount -t bcachefs /dev/vda3:/dev/vda4 /mnt",
|
|
|
|
"mkfs.ext3 -L boot /dev/vda1",
|
|
|
|
"mkdir -p /mnt/boot",
|
|
|
|
"mount /dev/vda1 /mnt/boot",
|
|
|
|
)
|
|
|
|
'';
|
|
|
|
};
|
|
|
|
|
2012-04-11 09:42:53 +00:00
|
|
|
# Test a basic install using GRUB 1.
|
nixosTests.installer: Fix grub1 test being unreliable
The kernel sometimes assigns `/dev/sdb` to the 8GiB disk. This, in turn,
means the test will fail because we're targeting the wrong disk.
```
machine # [ 0.000000] sd 2:0:0:0: [sda] 16777216 512-byte logical blocks: (8.59 GB/8.00 GiB)
machine # [ 0.000000] sd 3:0:0:0: [sdb] 1048576 512-byte logical blocks: (537 MB/512 MiB)
```
```
machine # [ 0.000000] sd 2:0:0:0: [sdb] 16777216 512-byte logical blocks: (8.59 GB/8.00 GiB)
machine # [ 0.000000] sd 3:0:0:0: [sda] 1048576 512-byte logical blocks: (537 MB/512 MiB)
```
Note how the "sd x:0:0:0:` ID is stable. That is because QEMU **is**
told to give specific identifiers to the disks. So using the
dev/disk/by-id/ identifiers is stable.
* * *
Tested by forcing the sda/sdb swap this way:
diff --git a/nixos/tests/installer.nix b/nixos/tests/installer.nix
index 24c55081f9a..2eee224351b 100644
--- a/nixos/tests/installer.nix
+++ b/nixos/tests/installer.nix
@@ -702,12 +702,19 @@ in {
+ " mkpart primary linux-swap 1M 1024M"
+ " mkpart primary ext2 1024M -1s",
"udevadm settle",
+ )
+ print(machine.succeed("find /dev/disk/ '!' -type d -printf '%p → %l\n' | sort"))
+ machine.succeed(
"mkswap ${grubDevice}-part1 -L swap",
"swapon -L swap",
"mkfs.ext3 -L nixos ${grubDevice}-part2",
"mount LABEL=nixos /mnt",
"mkdir -p /mnt/tmp",
)
+ machine.succeed("echo success")
+ machine.succeed(
+ 'if [[ "$(find ${grubDevice} -printf \'%l\')" != "../../sdb" ]]; then exit 22; else true; fi'
+ )
'';
grubVersion = 1;
# /dev/sda is not stable, even when the SCSI disk number is.
And ran this way:
$ until (clear; tmux clear ; time env -i nix-build nixos/release-combined.nix -A nixos.tests.installer.grub1.x86_64-linux); do echo derp; done
2021-04-25 23:37:19 +00:00
|
|
|
grub1 = makeInstallerTest "grub1" rec {
|
2020-01-28 07:54:05 +00:00
|
|
|
createPartitions = ''
|
|
|
|
machine.succeed(
|
nixosTests.installer: Fix grub1 test being unreliable
The kernel sometimes assigns `/dev/sdb` to the 8GiB disk. This, in turn,
means the test will fail because we're targeting the wrong disk.
```
machine # [ 0.000000] sd 2:0:0:0: [sda] 16777216 512-byte logical blocks: (8.59 GB/8.00 GiB)
machine # [ 0.000000] sd 3:0:0:0: [sdb] 1048576 512-byte logical blocks: (537 MB/512 MiB)
```
```
machine # [ 0.000000] sd 2:0:0:0: [sdb] 16777216 512-byte logical blocks: (8.59 GB/8.00 GiB)
machine # [ 0.000000] sd 3:0:0:0: [sda] 1048576 512-byte logical blocks: (537 MB/512 MiB)
```
Note how the "sd x:0:0:0:` ID is stable. That is because QEMU **is**
told to give specific identifiers to the disks. So using the
dev/disk/by-id/ identifiers is stable.
* * *
Tested by forcing the sda/sdb swap this way:
diff --git a/nixos/tests/installer.nix b/nixos/tests/installer.nix
index 24c55081f9a..2eee224351b 100644
--- a/nixos/tests/installer.nix
+++ b/nixos/tests/installer.nix
@@ -702,12 +702,19 @@ in {
+ " mkpart primary linux-swap 1M 1024M"
+ " mkpart primary ext2 1024M -1s",
"udevadm settle",
+ )
+ print(machine.succeed("find /dev/disk/ '!' -type d -printf '%p → %l\n' | sort"))
+ machine.succeed(
"mkswap ${grubDevice}-part1 -L swap",
"swapon -L swap",
"mkfs.ext3 -L nixos ${grubDevice}-part2",
"mount LABEL=nixos /mnt",
"mkdir -p /mnt/tmp",
)
+ machine.succeed("echo success")
+ machine.succeed(
+ 'if [[ "$(find ${grubDevice} -printf \'%l\')" != "../../sdb" ]]; then exit 22; else true; fi'
+ )
'';
grubVersion = 1;
# /dev/sda is not stable, even when the SCSI disk number is.
And ran this way:
$ until (clear; tmux clear ; time env -i nix-build nixos/release-combined.nix -A nixos.tests.installer.grub1.x86_64-linux); do echo derp; done
2021-04-25 23:37:19 +00:00
|
|
|
"flock ${grubDevice} parted --script ${grubDevice} -- mklabel msdos"
|
2020-01-28 07:54:05 +00:00
|
|
|
+ " mkpart primary linux-swap 1M 1024M"
|
|
|
|
+ " mkpart primary ext2 1024M -1s",
|
|
|
|
"udevadm settle",
|
nixosTests.installer: Fix grub1 test being unreliable
The kernel sometimes assigns `/dev/sdb` to the 8GiB disk. This, in turn,
means the test will fail because we're targeting the wrong disk.
```
machine # [ 0.000000] sd 2:0:0:0: [sda] 16777216 512-byte logical blocks: (8.59 GB/8.00 GiB)
machine # [ 0.000000] sd 3:0:0:0: [sdb] 1048576 512-byte logical blocks: (537 MB/512 MiB)
```
```
machine # [ 0.000000] sd 2:0:0:0: [sdb] 16777216 512-byte logical blocks: (8.59 GB/8.00 GiB)
machine # [ 0.000000] sd 3:0:0:0: [sda] 1048576 512-byte logical blocks: (537 MB/512 MiB)
```
Note how the "sd x:0:0:0:` ID is stable. That is because QEMU **is**
told to give specific identifiers to the disks. So using the
dev/disk/by-id/ identifiers is stable.
* * *
Tested by forcing the sda/sdb swap this way:
diff --git a/nixos/tests/installer.nix b/nixos/tests/installer.nix
index 24c55081f9a..2eee224351b 100644
--- a/nixos/tests/installer.nix
+++ b/nixos/tests/installer.nix
@@ -702,12 +702,19 @@ in {
+ " mkpart primary linux-swap 1M 1024M"
+ " mkpart primary ext2 1024M -1s",
"udevadm settle",
+ )
+ print(machine.succeed("find /dev/disk/ '!' -type d -printf '%p → %l\n' | sort"))
+ machine.succeed(
"mkswap ${grubDevice}-part1 -L swap",
"swapon -L swap",
"mkfs.ext3 -L nixos ${grubDevice}-part2",
"mount LABEL=nixos /mnt",
"mkdir -p /mnt/tmp",
)
+ machine.succeed("echo success")
+ machine.succeed(
+ 'if [[ "$(find ${grubDevice} -printf \'%l\')" != "../../sdb" ]]; then exit 22; else true; fi'
+ )
'';
grubVersion = 1;
# /dev/sda is not stable, even when the SCSI disk number is.
And ran this way:
$ until (clear; tmux clear ; time env -i nix-build nixos/release-combined.nix -A nixos.tests.installer.grub1.x86_64-linux); do echo derp; done
2021-04-25 23:37:19 +00:00
|
|
|
"mkswap ${grubDevice}-part1 -L swap",
|
2020-01-28 07:54:05 +00:00
|
|
|
"swapon -L swap",
|
nixosTests.installer: Fix grub1 test being unreliable
The kernel sometimes assigns `/dev/sdb` to the 8GiB disk. This, in turn,
means the test will fail because we're targeting the wrong disk.
```
machine # [ 0.000000] sd 2:0:0:0: [sda] 16777216 512-byte logical blocks: (8.59 GB/8.00 GiB)
machine # [ 0.000000] sd 3:0:0:0: [sdb] 1048576 512-byte logical blocks: (537 MB/512 MiB)
```
```
machine # [ 0.000000] sd 2:0:0:0: [sdb] 16777216 512-byte logical blocks: (8.59 GB/8.00 GiB)
machine # [ 0.000000] sd 3:0:0:0: [sda] 1048576 512-byte logical blocks: (537 MB/512 MiB)
```
Note how the "sd x:0:0:0:` ID is stable. That is because QEMU **is**
told to give specific identifiers to the disks. So using the
dev/disk/by-id/ identifiers is stable.
* * *
Tested by forcing the sda/sdb swap this way:
diff --git a/nixos/tests/installer.nix b/nixos/tests/installer.nix
index 24c55081f9a..2eee224351b 100644
--- a/nixos/tests/installer.nix
+++ b/nixos/tests/installer.nix
@@ -702,12 +702,19 @@ in {
+ " mkpart primary linux-swap 1M 1024M"
+ " mkpart primary ext2 1024M -1s",
"udevadm settle",
+ )
+ print(machine.succeed("find /dev/disk/ '!' -type d -printf '%p → %l\n' | sort"))
+ machine.succeed(
"mkswap ${grubDevice}-part1 -L swap",
"swapon -L swap",
"mkfs.ext3 -L nixos ${grubDevice}-part2",
"mount LABEL=nixos /mnt",
"mkdir -p /mnt/tmp",
)
+ machine.succeed("echo success")
+ machine.succeed(
+ 'if [[ "$(find ${grubDevice} -printf \'%l\')" != "../../sdb" ]]; then exit 22; else true; fi'
+ )
'';
grubVersion = 1;
# /dev/sda is not stable, even when the SCSI disk number is.
And ran this way:
$ until (clear; tmux clear ; time env -i nix-build nixos/release-combined.nix -A nixos.tests.installer.grub1.x86_64-linux); do echo derp; done
2021-04-25 23:37:19 +00:00
|
|
|
"mkfs.ext3 -L nixos ${grubDevice}-part2",
|
2020-01-28 07:54:05 +00:00
|
|
|
"mount LABEL=nixos /mnt",
|
|
|
|
"mkdir -p /mnt/tmp",
|
|
|
|
)
|
|
|
|
'';
|
|
|
|
grubVersion = 1;
|
nixosTests.installer: Fix grub1 test being unreliable
The kernel sometimes assigns `/dev/sdb` to the 8GiB disk. This, in turn,
means the test will fail because we're targeting the wrong disk.
```
machine # [ 0.000000] sd 2:0:0:0: [sda] 16777216 512-byte logical blocks: (8.59 GB/8.00 GiB)
machine # [ 0.000000] sd 3:0:0:0: [sdb] 1048576 512-byte logical blocks: (537 MB/512 MiB)
```
```
machine # [ 0.000000] sd 2:0:0:0: [sdb] 16777216 512-byte logical blocks: (8.59 GB/8.00 GiB)
machine # [ 0.000000] sd 3:0:0:0: [sda] 1048576 512-byte logical blocks: (537 MB/512 MiB)
```
Note how the "sd x:0:0:0:` ID is stable. That is because QEMU **is**
told to give specific identifiers to the disks. So using the
dev/disk/by-id/ identifiers is stable.
* * *
Tested by forcing the sda/sdb swap this way:
diff --git a/nixos/tests/installer.nix b/nixos/tests/installer.nix
index 24c55081f9a..2eee224351b 100644
--- a/nixos/tests/installer.nix
+++ b/nixos/tests/installer.nix
@@ -702,12 +702,19 @@ in {
+ " mkpart primary linux-swap 1M 1024M"
+ " mkpart primary ext2 1024M -1s",
"udevadm settle",
+ )
+ print(machine.succeed("find /dev/disk/ '!' -type d -printf '%p → %l\n' | sort"))
+ machine.succeed(
"mkswap ${grubDevice}-part1 -L swap",
"swapon -L swap",
"mkfs.ext3 -L nixos ${grubDevice}-part2",
"mount LABEL=nixos /mnt",
"mkdir -p /mnt/tmp",
)
+ machine.succeed("echo success")
+ machine.succeed(
+ 'if [[ "$(find ${grubDevice} -printf \'%l\')" != "../../sdb" ]]; then exit 22; else true; fi'
+ )
'';
grubVersion = 1;
# /dev/sda is not stable, even when the SCSI disk number is.
And ran this way:
$ until (clear; tmux clear ; time env -i nix-build nixos/release-combined.nix -A nixos.tests.installer.grub1.x86_64-linux); do echo derp; done
2021-04-25 23:37:19 +00:00
|
|
|
# /dev/sda is not stable, even when the SCSI disk number is.
|
|
|
|
grubDevice = "/dev/disk/by-id/scsi-0QEMU_QEMU_HARDDISK_drive1";
|
2020-01-28 07:54:05 +00:00
|
|
|
};
|
2012-04-11 09:42:53 +00:00
|
|
|
|
2014-05-02 04:11:49 +00:00
|
|
|
# Test using labels to identify volumes in grub
|
2014-08-29 09:48:00 +00:00
|
|
|
simpleLabels = makeInstallerTest "simpleLabels" {
|
2014-05-02 04:11:49 +00:00
|
|
|
createPartitions = ''
|
2020-01-28 07:54:05 +00:00
|
|
|
machine.succeed(
|
|
|
|
"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",
|
|
|
|
"mkswap /dev/vda2 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"mkfs.ext4 -L root /dev/vda3",
|
|
|
|
"mount LABEL=root /mnt",
|
|
|
|
)
|
2014-05-02 04:11:49 +00:00
|
|
|
'';
|
|
|
|
grubIdentifier = "label";
|
|
|
|
};
|
|
|
|
|
|
|
|
# Test using the provided disk name within grub
|
2014-05-02 07:03:25 +00:00
|
|
|
# TODO: Fix udev so the symlinks are unneeded in /dev/disks
|
2014-08-29 09:48:00 +00:00
|
|
|
simpleProvided = makeInstallerTest "simpleProvided" {
|
2014-05-02 04:11:49 +00:00
|
|
|
createPartitions = ''
|
2020-01-28 07:54:05 +00:00
|
|
|
uuid = "$(blkid -s UUID -o value /dev/vda2)"
|
|
|
|
machine.succeed(
|
|
|
|
"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",
|
|
|
|
"mkswap /dev/vda3 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"mkfs.ext4 -L boot /dev/vda2",
|
|
|
|
"mkfs.ext4 -L root /dev/vda4",
|
|
|
|
)
|
|
|
|
machine.execute(f"ln -s ../../vda2 /dev/disk/by-uuid/{uuid}")
|
|
|
|
machine.execute("ln -s ../../vda4 /dev/disk/by-label/root")
|
|
|
|
machine.succeed(
|
|
|
|
"mount /dev/disk/by-label/root /mnt",
|
|
|
|
"mkdir /mnt/boot",
|
|
|
|
f"mount /dev/disk/by-uuid/{uuid} /mnt/boot",
|
|
|
|
)
|
2014-05-02 04:11:49 +00:00
|
|
|
'';
|
|
|
|
grubIdentifier = "provided";
|
|
|
|
};
|
|
|
|
|
2014-05-01 11:21:30 +00:00
|
|
|
# Simple btrfs grub testing
|
2014-08-29 09:48:00 +00:00
|
|
|
btrfsSimple = makeInstallerTest "btrfsSimple" {
|
2014-05-01 11:21:30 +00:00
|
|
|
createPartitions = ''
|
2020-01-28 07:54:05 +00:00
|
|
|
machine.succeed(
|
|
|
|
"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",
|
|
|
|
"mkswap /dev/vda2 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"mkfs.btrfs -L root /dev/vda3",
|
|
|
|
"mount LABEL=root /mnt",
|
|
|
|
)
|
2014-05-01 11:21:30 +00:00
|
|
|
'';
|
|
|
|
};
|
|
|
|
|
|
|
|
# Test to see if we can detect /boot and /nix on subvolumes
|
2014-08-29 09:48:00 +00:00
|
|
|
btrfsSubvols = makeInstallerTest "btrfsSubvols" {
|
2014-05-01 11:21:30 +00:00
|
|
|
createPartitions = ''
|
2020-01-28 07:54:05 +00:00
|
|
|
machine.succeed(
|
|
|
|
"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",
|
|
|
|
"mkswap /dev/vda2 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"mkfs.btrfs -L root /dev/vda3",
|
|
|
|
"btrfs device scan",
|
|
|
|
"mount LABEL=root /mnt",
|
|
|
|
"btrfs subvol create /mnt/boot",
|
|
|
|
"btrfs subvol create /mnt/nixos",
|
|
|
|
"btrfs subvol create /mnt/nixos/default",
|
|
|
|
"umount /mnt",
|
|
|
|
"mount -o defaults,subvol=nixos/default LABEL=root /mnt",
|
|
|
|
"mkdir /mnt/boot",
|
|
|
|
"mount -o defaults,subvol=boot LABEL=root /mnt/boot",
|
|
|
|
)
|
2014-05-01 11:21:30 +00:00
|
|
|
'';
|
|
|
|
};
|
2014-08-29 23:37:28 +00:00
|
|
|
|
|
|
|
# Test to see if we can detect default and aux subvolumes correctly
|
|
|
|
btrfsSubvolDefault = makeInstallerTest "btrfsSubvolDefault" {
|
|
|
|
createPartitions = ''
|
2020-01-28 07:54:05 +00:00
|
|
|
machine.succeed(
|
|
|
|
"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",
|
|
|
|
"mkswap /dev/vda2 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"mkfs.btrfs -L root /dev/vda3",
|
|
|
|
"btrfs device scan",
|
|
|
|
"mount LABEL=root /mnt",
|
|
|
|
"btrfs subvol create /mnt/badpath",
|
|
|
|
"btrfs subvol create /mnt/badpath/boot",
|
|
|
|
"btrfs subvol create /mnt/nixos",
|
|
|
|
"btrfs subvol set-default "
|
2020-08-23 14:10:02 +00:00
|
|
|
+ "$(btrfs subvol list /mnt | grep 'nixos' | awk '{print $2}') /mnt",
|
2020-01-28 07:54:05 +00:00
|
|
|
"umount /mnt",
|
|
|
|
"mount -o defaults LABEL=root /mnt",
|
|
|
|
"mkdir -p /mnt/badpath/boot", # Help ensure the detection mechanism
|
|
|
|
# is actually looking up subvolumes
|
|
|
|
"mkdir /mnt/boot",
|
|
|
|
"mount -o defaults,subvol=badpath/boot LABEL=root /mnt/boot",
|
|
|
|
)
|
2014-08-29 23:37:28 +00:00
|
|
|
'';
|
|
|
|
};
|
2022-10-31 14:31:10 +00:00
|
|
|
|
|
|
|
# Test to see if we can deal with subvols that need to be escaped in fstab
|
|
|
|
btrfsSubvolEscape = makeInstallerTest "btrfsSubvolEscape" {
|
|
|
|
createPartitions = ''
|
|
|
|
machine.succeed(
|
|
|
|
"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",
|
|
|
|
"mkswap /dev/vda2 -L swap",
|
|
|
|
"swapon -L swap",
|
|
|
|
"mkfs.btrfs -L root /dev/vda3",
|
|
|
|
"btrfs device scan",
|
|
|
|
"mount LABEL=root /mnt",
|
|
|
|
"btrfs subvol create '/mnt/nixos in space'",
|
|
|
|
"btrfs subvol create /mnt/boot",
|
|
|
|
"umount /mnt",
|
|
|
|
"mount -o 'defaults,subvol=nixos in space' LABEL=root /mnt",
|
|
|
|
"mkdir /mnt/boot",
|
|
|
|
"mount -o defaults,subvol=boot LABEL=root /mnt/boot",
|
|
|
|
)
|
|
|
|
'';
|
|
|
|
};
|
2010-01-06 13:36:21 +00:00
|
|
|
}
|