commit 6e6188af7b1a8d6344f299bb882b24ab7839ddbd · pyrox.dev/nixpkgs

+22 -14

nixos/maintainers/scripts/ec2/amazon-image.nix

···

       20
       20
        
         imports = [

     

       21
       21
        
           ../../../modules/virtualisation/amazon-image.nix

     

       22
       22
        
           ../../../modules/virtualisation/disk-size-option.nix

     

       23
       23
       +
           ../../../modules/image/file-options.nix

     

       23
       24
        
           (lib.mkRenamedOptionModuleWith {

     

       24
       25
        
             sinceRelease = 2411;

     

       25
       26
        
             from = [

     
···

       31
       32
        
               "diskSize"

     

       32
       33
        
             ];

     

       33
       34
        
           })

     

       35
       35
       +
           (lib.mkRenamedOptionModuleWith {

     

       36
       36
       +
             sinceRelease = 2505;

     

       37
       37
       +
             from = [

     

       38
       38
       +
               "amazonImage"

     

       39
       39
       +
               "name"

     

       40
       40
       +
             ];

     

       41
       41
       +
             to = [

     

       42
       42
       +
               "image"

     

       43
       43
       +
               "baseName"

     

       44
       44
       +
             ];

     

       45
       45
       +
           })

     

       34
       46
        
         ];

     

       35
       47
        
       

     

       36
       48
        
         # Amazon recommends setting this to the highest possible value for a good EBS

     
···

       44
       56
        
           [ "nvme_core.io_timeout=${timeout}" ];

     

       45
       57
        
       

     

       46
       58
        
         options.amazonImage = {

     

       47
       47
       -
           name = mkOption {

     

       48
       48
       -
             type = types.str;

     

       49
       49
       -
             description = "The name of the generated derivation";

     

       50
       50
       -
             default = "nixos-amazon-image-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}";

     

       51
       51
       -
           };

     

       52
       52
       -
       

     

       53
       59
        
           contents = mkOption {

     

       54
       60
        
             example = literalExpression ''

     

       55
       61
        
               [ { source = pkgs.memtest86 + "/memtest.bin";

     
···

       80
       86
        
         config.virtualisation.diskSize = lib.mkOverride 1490 (3 * 1024);

     

       81
       87
        
         config.virtualisation.diskSizeAutoSupported = !config.ec2.zfs.enable;

     

       82
       88
        
       

     

       89
       89
       +
         config.system.nixos.tags = [ "amazon" ];

     

       90
       90
       +
         config.system.build.image = config.system.build.amazonImage;

     

       91
       91
       +
         config.image.extension = cfg.format;

     

       92
       92
       +
       

     

       83
       93
        
         config.system.build.amazonImage =

     

       84
       94
        
           let

     

       85
       95
        
             configFile = pkgs.writeText "configuration.nix" ''

     
···

       102
       112
        
                 configFile

     

       103
       113
        
                 pkgs

     

       104
       114
        
                 ;

     

       105
       105
       -
               inherit (cfg) contents format name;

     

       115
       115
       +
               inherit (cfg) contents format;

     

       116
       116
       +
               name = config.image.baseName;

     

       106
       117
        
       

     

       107
       118
        
               includeChannel = true;

     

       108
       119
        
       

     
···

       118
       129
        
       

     

       119
       130
        
               postVM = ''

     

       120
       131
        
                  extension=''${rootDiskImage##*.}

     

       121
       121
       -
                  friendlyName=$out/${cfg.name}

     

       132
       132
       +
                  friendlyName=$out/${config.image.baseName}

     

       122
       133
        
                  rootDisk="$friendlyName.root.$extension"

     

       123
       134
        
                  bootDisk="$friendlyName.boot.$extension"

     

       124
       135
        
                  mv "$rootDiskImage" "$rootDisk"

     
···

       156
       167
        
                 pkgs

     

       157
       168
        
                 ;

     

       158
       169
        
       

     

       159
       159
       -
               inherit (cfg) contents format name;

     

       170
       170
       +
               inherit (cfg) contents format;

     

       171
       171
       +
               inherit (config.image) baseName;

     

       172
       172
       +
               name = config.image.baseName;

     

       160
       173
        
       

     

       161
       174
        
               fsType = "ext4";

     

       162
       175
        
               partitionTableType = if config.ec2.efi then "efi" else "legacy+gpt";

     
···

       164
       177
        
               inherit (config.virtualisation) diskSize;

     

       165
       178
        
       

     

       166
       179
        
               postVM = ''

     

       167
       167
       -
                  extension=''${diskImage##*.}

     

       168
       168
       -
                  friendlyName=$out/${cfg.name}.$extension

     

       169
       169
       -
                  mv "$diskImage" "$friendlyName"

     

       170
       170
       -
                  diskImage=$friendlyName

     

       171
       171
       -
       

     

       172
       180
        
                  mkdir -p $out/nix-support

     

       173
       181
        
                  echo "file ${cfg.format} $diskImage" >> $out/nix-support/hydra-build-products

     

       174
       182

+22 -8

nixos/maintainers/scripts/openstack/openstack-image-zfs.nix

···

       16
       16
        
         imports = [

     

       17
       17
        
           ../../../modules/virtualisation/openstack-config.nix

     

       18
       18
        
           ../../../modules/virtualisation/disk-size-option.nix

     

       19
       19
       +
           ../../../modules/image/file-options.nix

     

       19
       20
        
           (lib.mkRenamedOptionModuleWith {

     

       20
       21
        
             sinceRelease = 2411;

     

       21
       22
        
             from = [

     
···

       27
       28
        
               "diskSize"

     

       28
       29
        
             ];

     

       29
       30
        
           })

     

       31
       31
       +
           (lib.mkRenamedOptionModuleWith {

     

       32
       32
       +
             sinceRelease = 2505;

     

       33
       33
       +
             from = [

     

       34
       34
       +
               "openstackImage"

     

       35
       35
       +
               "name"

     

       36
       36
       +
             ];

     

       37
       37
       +
             to = [

     

       38
       38
       +
               "image"

     

       39
       39
       +
               "baseName"

     

       40
       40
       +
             ];

     

       41
       41
       +
           })

     

       42
       42
       +
       

     

       30
       43
        
         ] ++ (lib.optional copyChannel ../../../modules/installer/cd-dvd/channel.nix);

     

       31
       44
        
       

     

       32
       45
        
         options.openstackImage = {

     

       33
       33
       -
           name = mkOption {

     

       34
       34
       -
             type = types.str;

     

       35
       35
       -
             description = "The name of the generated derivation";

     

       36
       36
       -
             default = "nixos-openstack-image-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}";

     

       37
       37
       -
           };

     

       38
       38
       -
       

     

       39
       46
        
           ramMB = mkOption {

     

       40
       47
        
             type = types.int;

     

       41
       48
        
             default = (3 * 1024);

     
···

       72
       79
        
           virtualisation.diskSize = lib.mkOverride 1490 (8 * 1024);

     

       73
       80
        
           virtualisation.diskSizeAutoSupported = false;

     

       74
       81
        
       

     

       82
       82
       +
           image.extension = cfg.format;

     

       83
       83
       +
           system.nixos.tags = [

     

       84
       84
       +
             "openstack"

     

       85
       85
       +
             "zfs"

     

       86
       86
       +
           ];

     

       87
       87
       +
           system.build.image = config.system.build.openstackImage;

     

       75
       88
        
           system.build.openstackImage = import ../../../lib/make-single-disk-zfs-image.nix {

     

       76
       89
        
             inherit lib config;

     

       77
       77
       -
             inherit (cfg) contents format name;

     

       90
       90
       +
             inherit (cfg) contents format;

     

       91
       91
       +
             name = config.image.baseName;

     

       78
       92
        
             pkgs = import ../../../.. { inherit (pkgs) system; }; # ensure we use the regular qemu-kvm package

     

       79
       93
        
       

     

       80
       94
        
             configFile = pkgs.writeText "configuration.nix" ''

     
···

       98
       112
        
       

     

       99
       113
        
             postVM = ''

     

       100
       114
        
                extension=''${rootDiskImage##*.}

     

       101
       101
       -
                friendlyName=$out/${cfg.name}

     

       115
       115
       +
                friendlyName=$out/${config.image.baseName}

     

       102
       116
        
                rootDisk="$friendlyName.root.$extension"

     

       103
       117
        
                mv "$rootDiskImage" "$rootDisk"

     

       104
       118

+7 -2

nixos/maintainers/scripts/openstack/openstack-image.nix

···

       3
       3
        
       { config, lib, pkgs, ... }:

     

       4
       4
        
       let

     

       5
       5
        
         copyChannel = true;

     

       6
       6
       +
           format = "qcow2";

     

       6
       7
        
       in

     

       7
       8
        
       {

     

       8
       9
        
         imports = [

     

       9
       10
        
           ../../../modules/virtualisation/openstack-config.nix

     

       11
       11
       +
           ../../../modules/image/file-options.nix

     

       10
       12
        
         ] ++ (lib.optional copyChannel ../../../modules/installer/cd-dvd/channel.nix);

     

       11
       13
        
       

     

       12
       14
        
         documentation.enable = copyChannel;

     

       13
       15
        
       

     

       16
       16
       +
         image.extension = format;

     

       17
       17
       +
         system.nixos.tags = [ "openstack" ];

     

       18
       18
       +
         system.build.image = config.system.build.openstackImage;

     

       14
       19
        
         system.build.openstackImage = import ../../../lib/make-disk-image.nix {

     

       15
       15
       -
           inherit lib config copyChannel;

     

       20
       20
       +
           inherit lib config copyChannel format;

     

       21
       21
       +
           inherit (config.image) baseName;

     

       16
       22
        
           additionalSpace = "1024M";

     

       17
       23
        
           pkgs = import ../../../.. { inherit (pkgs) system; }; # ensure we use the regular qemu-kvm package

     

       18
       18
       -
           format = "qcow2";

     

       19
       24
        
           configFile = pkgs.writeText "configuration.nix"

     

       20
       25
        
             ''

     

       21
       26
        
               {

+35

nixos/modules/image/images.nix

···

       9
       9
        
         inherit (lib) types;

     

       10
       10
        
       

     

       11
       11
        
         imageModules = {

     

       12
       12
       +
           amazon = [ ../../maintainers/scripts/ec2/amazon-image.nix ];

     

       12
       13
        
           azure = [ ../virtualisation/azure-image.nix ];

     

       13
       14
        
           digital-ocean = [ ../virtualisation/digital-ocean-image.nix ];

     

       14
       15
        
           google-compute = [ ../virtualisation/google-compute-image.nix ];

     
···

       17
       18
        
           lxc = [ ../virtualisation/lxc-container.nix ];

     

       18
       19
        
           lxc-metadata = [ ../virtualisation/lxc-image-metadata.nix ];

     

       19
       20
        
           oci = [ ../virtualisation/oci-image.nix ];

     

       21
       21
       +
           openstack = [ ../../maintainers/scripts/openstack/openstack-image.nix ];

     

       22
       22
       +
           openstack-zfs = [ ../../maintainers/scripts/openstack/openstack-image-zfs.nix ];

     

       20
       23
        
           proxmox = [ ../virtualisation/proxmox-image.nix ];

     

       24
       24
       +
           proxmox-lxc = [ ../virtualisation/proxmox-lxc.nix ];

     

       25
       25
       +
           qemu-efi = [ ../virtualisation/disk-image.nix ];

     

       26
       26
       +
           qemu = [

     

       27
       27
       +
             ../virtualisation/disk-image.nix

     

       28
       28
       +
             {

     

       29
       29
       +
               image.efiSupport = false;

     

       30
       30
       +
             }

     

       31
       31
       +
           ];

     

       32
       32
       +
           raw-efi = [

     

       33
       33
       +
             ../virtualisation/disk-image.nix

     

       34
       34
       +
             {

     

       35
       35
       +
               image.format = "raw";

     

       36
       36
       +
             }

     

       37
       37
       +
           ];

     

       38
       38
       +
           raw = [

     

       39
       39
       +
             ../virtualisation/disk-image.nix

     

       40
       40
       +
             {

     

       41
       41
       +
               image.format = "raw";

     

       42
       42
       +
               image.efiSupport = false;

     

       43
       43
       +
             }

     

       44
       44
       +
           ];

     

       21
       45
        
           kubevirt = [ ../virtualisation/kubevirt.nix ];

     

       22
       46
        
           vagrant-virtualbox = [ ../virtualisation/vagrant-virtualbox-image.nix ];

     

       23
       47
        
           virtualbox = [ ../virtualisation/virtualbox-image.nix ];

     

       24
       48
        
           vmware = [ ../virtualisation/vmware-image.nix ];

     

       49
       49
       +
           iso = [ ../installer/cd-dvd/iso-image.nix ];

     

       50
       50
       +
           iso-installer = [ ../installer/cd-dvd/installation-cd-base.nix ];

     

       51
       51
       +
           sd-card = [

     

       52
       52
       +
             (

     

       53
       53
       +
               let

     

       54
       54
       +
                 module = ../. + "/installer/sd-card/sd-image-${pkgs.targetPlatform.linuxArch}.nix";

     

       55
       55
       +
               in

     

       56
       56
       +
               if builtins.pathExists module then module else throw "The module ${module} does not exist."

     

       57
       57
       +
             )

     

       58
       58
       +
           ];

     

       59
       59
       +
           kexec = [ ../installer/netboot/netboot-minimal.nix ];

     

       25
       60
        
         };

     

       26
       61
        
         imageConfigs = lib.mapAttrs (

     

       27
       62
        
           name: modules:

-3

nixos/modules/installer/cd-dvd/installation-cd-base.nix

···

       15
       15
        
         # Adds terminus_font for people with HiDPI displays

     

       16
       16
        
         console.packages = options.console.packages.default ++ [ pkgs.terminus_font ];

     

       17
       17
        
       

     

       18
       18
       -
         # ISO naming.

     

       19
       19
       -
         isoImage.isoName = "${config.isoImage.isoBaseName}-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}.iso";

     

       20
       20
       -
       

     

       21
       18
        
         # EFI booting

     

       22
       19
        
         isoImage.makeEfiBootable = true;

     

       23
       20

+31 -17

nixos/modules/installer/cd-dvd/iso-image.nix

···

       476
       476
        
       in

     

       477
       477
        
       

     

       478
       478
        
       {

     

       479
       479
       -
         options = {

     

       480
       480
       -
       

     

       481
       481
       -
           isoImage.isoName = lib.mkOption {

     

       482
       482
       -
             default = "${config.isoImage.isoBaseName}.iso";

     

       483
       483
       -
             type = lib.types.str;

     

       484
       484
       -
             description = ''

     

       485
       485
       -
               Name of the generated ISO image file.

     

       486
       486
       -
             '';

     

       487
       487
       -
           };

     

       479
       479
       +
         imports = [

     

       480
       480
       +
           (lib.mkRenamedOptionModuleWith {

     

       481
       481
       +
             sinceRelease = 2505;

     

       482
       482
       +
             from = [

     

       483
       483
       +
               "isoImage"

     

       484
       484
       +
               "isoBaseName"

     

       485
       485
       +
             ];

     

       486
       486
       +
             to = [

     

       487
       487
       +
               "image"

     

       488
       488
       +
               "baseName"

     

       489
       489
       +
             ];

     

       490
       490
       +
           })

     

       491
       491
       +
           (lib.mkRenamedOptionModuleWith {

     

       492
       492
       +
             sinceRelease = 2505;

     

       493
       493
       +
             from = [

     

       494
       494
       +
               "isoImage"

     

       495
       495
       +
               "isoName"

     

       496
       496
       +
             ];

     

       497
       497
       +
             to = [

     

       498
       498
       +
               "image"

     

       499
       499
       +
               "fileName"

     

       500
       500
       +
             ];

     

       501
       501
       +
           })

     

       502
       502
       +
           ../../image/file-options.nix

     

       503
       503
       +
         ];

     

       488
       504
        
       

     

       489
       489
       -
           isoImage.isoBaseName = lib.mkOption {

     

       490
       490
       -
             default = config.system.nixos.distroId;

     

       491
       491
       -
             type = lib.types.str;

     

       492
       492
       -
             description = ''

     

       493
       493
       -
               Prefix of the name of the generated ISO image file.

     

       494
       494
       -
             '';

     

       495
       495
       -
           };

     

       505
       505
       +
         options = {

     

       496
       506
        
       

     

       497
       507
        
           isoImage.compressImage = lib.mkOption {

     

       498
       508
        
             default = false;

     
···

       858
       868
        
           boot.loader.timeout = 10;

     

       859
       869
        
       

     

       860
       870
        
           # Create the ISO image.

     

       871
       871
       +
           image.extension = if config.isoImage.compressImage then "iso.zst" else "iso";

     

       872
       872
       +
           image.filePath = "iso/${config.image.fileName}";

     

       873
       873
       +
           system.build.image = config.system.build.isoImage;

     

       861
       874
        
           system.build.isoImage = pkgs.callPackage ../../../lib/make-iso9660-image.nix ({

     

       862
       862
       -
             inherit (config.isoImage) isoName compressImage volumeID contents;

     

       875
       875
       +
             inherit (config.isoImage) compressImage volumeID contents;

     

       876
       876
       +
             isoName = "${config.image.baseName}.iso";

     

       863
       877
        
             bootable = config.isoImage.makeBiosBootable;

     

       864
       878
        
             bootImage = "/isolinux/isolinux.bin";

     

       865
       879
        
             syslinux = if config.isoImage.makeBiosBootable then pkgs.syslinux else null;

+20 -1

nixos/modules/installer/netboot/netboot.nix

···

       1
       1
        
       # This module creates netboot media containing the given NixOS

     

       2
       2
        
       # configuration.

     

       3
       3
        
       

     

       4
       4
       -
       { config, lib, pkgs, ... }:

     

       4
       4
       +
       { config, lib, pkgs, modulesPath, ... }:

     

       5
       5
        
       

     

       6
       6
        
       with lib;

     

       7
       7
        
       

     

       8
       8
        
       {

     

       9
       9
       +
         imports = [

     

       10
       10
       +
           ../../image/file-options.nix

     

       11
       11
       +
         ];

     

       12
       12
       +
       

     

       9
       13
        
         options = {

     

       10
       14
        
       

     

       11
       15
        
           netboot.squashfsCompression = mkOption {

     
···

       128
       132
        
               path = config.system.build.kexecScript;

     

       129
       133
        
             }

     

       130
       134
        
           ];

     

       135
       135
       +
       

     

       136
       136
       +
           image.extension = "tar.xz";

     

       137
       137
       +
           image.filePath = "tarball/${config.image.fileName}";

     

       138
       138
       +
           system.nixos.tags = [ "kexec" ];

     

       139
       139
       +
           system.build.image = config.system.build.kexecTarball;

     

       140
       140
       +
           system.build.kexecTarball = pkgs.callPackage "${toString modulesPath}/../lib/make-system-tarball.nix" {

     

       141
       141
       +
             fileName = config.image.baseName;

     

       142
       142
       +
             storeContents = [

     

       143
       143
       +
               {

     

       144
       144
       +
                 object = config.system.build.kexecScript;

     

       145
       145
       +
                 symlink = "/kexec_nixos";

     

       146
       146
       +
               }

     

       147
       147
       +
             ];

     

       148
       148
       +
             contents = [];

     

       149
       149
       +
           };

     

       131
       150
        
       

     

       132
       151
        
           boot.loader.timeout = 10;

     

       133
       152

+31 -17

nixos/modules/installer/sd-card/sd-image.nix

···

       29
       29
        
         imports = [

     

       30
       30
        
           (mkRemovedOptionModule [ "sdImage" "bootPartitionID" ] "The FAT partition for SD image now only holds the Raspberry Pi firmware files. Use firmwarePartitionID to configure that partition's ID.")

     

       31
       31
        
           (mkRemovedOptionModule [ "sdImage" "bootSize" ] "The boot files for SD image have been moved to the main ext4 partition. The FAT partition now only holds the Raspberry Pi firmware files. Changing its size may not be required.")

     

       32
       32
       +
           (lib.mkRenamedOptionModuleWith {

     

       33
       33
       +
             sinceRelease = 2505;

     

       34
       34
       +
             from = [

     

       35
       35
       +
               "sdImage"

     

       36
       36
       +
               "imageBaseName"

     

       37
       37
       +
             ];

     

       38
       38
       +
             to = [

     

       39
       39
       +
               "image"

     

       40
       40
       +
               "baseName"

     

       41
       41
       +
             ];

     

       42
       42
       +
           })

     

       43
       43
       +
           (lib.mkRenamedOptionModuleWith {

     

       44
       44
       +
             sinceRelease = 2505;

     

       45
       45
       +
             from = [

     

       46
       46
       +
               "sdImage"

     

       47
       47
       +
               "imageName"

     

       48
       48
       +
             ];

     

       49
       49
       +
             to = [

     

       50
       50
       +
               "image"

     

       51
       51
       +
               "fileName"

     

       52
       52
       +
             ];

     

       53
       53
       +
           })

     

       54
       54
       +
           ../../profiles/all-hardware.nix

     

       55
       55
       +
           ../../image/file-options.nix

     

       32
       56
        
         ];

     

       33
       57
        
       

     

       34
       58
        
         options.sdImage = {

     

       35
       35
       -
           imageName = mkOption {

     

       36
       36
       -
             default = "${config.sdImage.imageBaseName}-${config.system.nixos.label}-${pkgs.stdenv.hostPlatform.system}.img";

     

       37
       37
       -
             description = ''

     

       38
       38
       -
               Name of the generated image file.

     

       39
       39
       -
             '';

     

       40
       40
       -
           };

     

       41
       41
       -
       

     

       42
       42
       -
           imageBaseName = mkOption {

     

       43
       43
       -
             default = "nixos-sd-image";

     

       44
       44
       -
             description = ''

     

       45
       45
       -
               Prefix of the name of the generated image file.

     

       46
       46
       -
             '';

     

       47
       47
       -
           };

     

       48
       48
       -
       

     

       49
       59
        
           storePaths = mkOption {

     

       50
       60
        
             type = with types; listOf package;

     

       51
       61
        
             example = literalExpression "[ pkgs.stdenv ]";

     
···

       180
       190
        
       

     

       181
       191
        
           sdImage.storePaths = [ config.system.build.toplevel ];

     

       182
       192
        
       

     

       193
       193
       +
           image.extension = if config.sdImage.compressImage then "img.zst" else "img";

     

       194
       194
       +
           image.filePath = "sd-card/${config.image.fileName}";

     

       195
       195
       +
           system.nixos.tags = [ "sd-card" ];

     

       196
       196
       +
           system.build.image = config.system.build.sdImage;

     

       183
       197
        
           system.build.sdImage = pkgs.callPackage ({ stdenv, dosfstools, e2fsprogs,

     

       184
       198
        
           mtools, libfaketime, util-linux, zstd }: stdenv.mkDerivation {

     

       185
       185
       -
             name = config.sdImage.imageName;

     

       199
       199
       +
             name = config.image.fileName;

     

       186
       200
        
       

     

       187
       201
        
             nativeBuildInputs = [ dosfstools e2fsprogs libfaketime mtools util-linux ]

     

       188
       202
        
             ++ lib.optional config.sdImage.compressImage zstd;

     

       189
       203
        
       

     

       190
       190
       -
             inherit (config.sdImage) imageName compressImage;

     

       204
       204
       +
             inherit (config.sdImage) compressImage;

     

       191
       205
        
       

     

       192
       206
        
             buildCommand = ''

     

       193
       207
        
               mkdir -p $out/nix-support $out/sd-image

     

       194
       194
       -
               export img=$out/sd-image/${config.sdImage.imageName}

     

       208
       208
       +
               export img=$out/sd-image/${config.image.baseName}.img

     

       195
       209
        
       

     

       196
       210
        
               echo "${pkgs.stdenv.buildPlatform.system}" > $out/nix-support/system

     

       197
       211
        
               if test -n "$compressImage"; then

+61

nixos/modules/virtualisation/disk-image.nix

···

       1
       1
       +
       {

     

       2
       2
       +
         config,

     

       3
       3
       +
         lib,

     

       4
       4
       +
         pkgs,

     

       5
       5
       +
         ...

     

       6
       6
       +
       }:

     

       7
       7
       +
       let

     

       8
       8
       +
         cfg = config.image;

     

       9
       9
       +
       in

     

       10
       10
       +
       {

     

       11
       11
       +
         imports = [

     

       12
       12
       +
           ./disk-size-option.nix

     

       13
       13
       +
           ../image/file-options.nix

     

       14
       14
       +
         ];

     

       15
       15
       +
       

     

       16
       16
       +
         options.image = {

     

       17
       17
       +
           format = lib.mkOption {

     

       18
       18
       +
             description = "Format of the disk image to generate: raw or qcow2";

     

       19
       19
       +
             type = lib.types.enum [

     

       20
       20
       +
               "raw"

     

       21
       21
       +
               "qcow2"

     

       22
       22
       +
             ];

     

       23
       23
       +
             default = "qcow2";

     

       24
       24
       +
           };

     

       25
       25
       +
           efiSupport = lib.mkOption {

     

       26
       26
       +
             description = "Whether the disk image should support EFI boot or legacy boot";

     

       27
       27
       +
             type = lib.types.bool;

     

       28
       28
       +
             default = true;

     

       29
       29
       +
           };

     

       30
       30
       +
         };

     

       31
       31
       +
       

     

       32
       32
       +
         config = {

     

       33
       33
       +
           boot.loader.grub = lib.mkIf (!cfg.efiSupport) {

     

       34
       34
       +
             enable = lib.mkOptionDefault true;

     

       35
       35
       +
             devices = lib.mkDefault [ "/dev/vda" ];

     

       36
       36
       +
           };

     

       37
       37
       +
           boot.loader.systemd-boot.enable = lib.mkDefault cfg.efiSupport;

     

       38
       38
       +
           boot.growPartition = lib.mkDefault true;

     

       39
       39
       +
       

     

       40
       40
       +
           fileSystems = {

     

       41
       41
       +
             "/" = {

     

       42
       42
       +
               device = "/dev/disk/by-label/nixos";

     

       43
       43
       +
               autoResize = true;

     

       44
       44
       +
               fsType = "ext4";

     

       45
       45
       +
             };

     

       46
       46
       +
             "/boot" = lib.mkIf (cfg.efiSupport) {

     

       47
       47
       +
               device = "/dev/disk/by-label/ESP";

     

       48
       48
       +
               fsType = "vfat";

     

       49
       49
       +
             };

     

       50
       50
       +
           };

     

       51
       51
       +
       

     

       52
       52
       +
           system.nixos.tags = [ cfg.format ] ++ lib.optionals cfg.efiSupport [ "efi" ];

     

       53
       53
       +
           image.extension = cfg.format;

     

       54
       54
       +
           system.build.image = import ../../lib/make-disk-image.nix {

     

       55
       55
       +
             inherit lib config pkgs;

     

       56
       56
       +
             inherit (config.virtualisation) diskSize;

     

       57
       57
       +
             inherit (cfg) baseName format;

     

       58
       58
       +
             partitionTableType = if cfg.efiSupport then "efi" else "legacy";

     

       59
       59
       +
           };

     

       60
       60
       +
         };

     

       61
       61
       +
       }

+1 -1

nixos/release.nix

···

       62
       62
        
           hydraJob ((import lib/eval-config.nix {

     

       63
       63
        
             inherit system;

     

       64
       64
        
             modules = makeModules module {

     

       65
       65
       -
               isoImage.isoBaseName = "nixos-${type}";

     

       65
       65
       +
               image.baseName = "nixos-${type}";

     

       66
       66
        
             };

     

       67
       67
        
           }).config.system.build.isoImage);

     

       68
       68

+1 -1

nixos/tests/ec2.nix

···

       55
       55
        
             }

     

       56
       56
        
           ];

     

       57
       57
        
         }).config;

     

       58
       58
       -
         image = "${imageCfg.system.build.amazonImage}/${imageCfg.amazonImage.name}.qcow2";

     

       58
       58
       +
         image = "${imageCfg.system.build.amazonImage}/${imageCfg.image.imageFile}";

     

       59
       59
        
       

     

       60
       60
        
         sshKeys = import ./ssh-keys.nix pkgs;

     

       61
       61
        
         snakeOilPrivateKey = sshKeys.snakeOilPrivateKey.text;

+1 -1

pkgs/desktops/gnome/installer.nix

···

       7
       7
        
       

     

       8
       8
        
         config = (import ../../../../nixos/lib/eval-config.nix {

     

       9
       9
        
           inherit system;

     

       10
       10
       -
           modules = [ module { isoImage.isoBaseName = isoBaseName; } ] ++ extraModules;

     

       10
       10
       +
           modules = [ module { image.baseName = isoBaseName; } ] ++ extraModules;

     

       11
       11
        
         }).config;

     

       12
       12
        
       

     

       13
       13
        
       in