commit 6e6188af7b1a8d6344f299bb882b24ab7839ddbd · pyrox.dev/nixpkgs

+22 -14

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

···

       20
        
         imports = [

     

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

     

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

     

       0
        
       
     

       23
        
           (lib.mkRenamedOptionModuleWith {

     

       24
        
             sinceRelease = 2411;

     

       25
        
             from = [

     
···

       31
        
               "diskSize"

     

       32
        
             ];

     

       33
        
           })

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       34
        
         ];

     

       35
        
       

     

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

     
···

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

     

       45
        
       

     

       46
        
         options.amazonImage = {

     

       47
       -
           name = mkOption {

     

       48
       -
             type = types.str;

     

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

     

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

     

       51
       -
           };

     

       52
       -
       

     

       53
        
           contents = mkOption {

     

       54
        
             example = literalExpression ''

     

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

     
···

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

     

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

     

       82
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       83
        
         config.system.build.amazonImage =

     

       84
        
           let

     

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

     
···

       102
        
                 configFile

     

       103
        
                 pkgs

     

       104
        
                 ;

     

       105
       -
               inherit (cfg) contents format name;

     

       0
        
       
     

       106
        
       

     

       107
        
               includeChannel = true;

     

       108
        
       

     
···

       118
        
       

     

       119
        
               postVM = ''

     

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

     

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

     

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

     

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

     

       124
        
                  mv "$rootDiskImage" "$rootDisk"

     
···

       156
        
                 pkgs

     

       157
        
                 ;

     

       158
        
       

     

       159
       -
               inherit (cfg) contents format name;

     

       0
        
       
     

       0
        
       
     

       160
        
       

     

       161
        
               fsType = "ext4";

     

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

     
···

       164
        
               inherit (config.virtualisation) diskSize;

     

       165
        
       

     

       166
        
               postVM = ''

     

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

     

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

     

       169
       -
                  mv "$diskImage" "$friendlyName"

     

       170
       -
                  diskImage=$friendlyName

     

       171
       -
       

     

       172
        
                  mkdir -p $out/nix-support

     

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

     

       174

···

       20
        
         imports = [

     

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

     

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

     

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

     

       24
        
           (lib.mkRenamedOptionModuleWith {

     

       25
        
             sinceRelease = 2411;

     

       26
        
             from = [

     
···

       32
        
               "diskSize"

     

       33
        
             ];

     

       34
        
           })

     

       35
       +
           (lib.mkRenamedOptionModuleWith {

     

       36
       +
             sinceRelease = 2505;

     

       37
       +
             from = [

     

       38
       +
               "amazonImage"

     

       39
       +
               "name"

     

       40
       +
             ];

     

       41
       +
             to = [

     

       42
       +
               "image"

     

       43
       +
               "baseName"

     

       44
       +
             ];

     

       45
       +
           })

     

       46
        
         ];

     

       47
        
       

     

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

     
···

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

     

       57
        
       

     

       58
        
         options.amazonImage = {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       59
        
           contents = mkOption {

     

       60
        
             example = literalExpression ''

     

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

     
···

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

     

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

     

       88
        
       

     

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

     

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

     

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

     

       92
       +
       

     

       93
        
         config.system.build.amazonImage =

     

       94
        
           let

     

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

     
···

       112
        
                 configFile

     

       113
        
                 pkgs

     

       114
        
                 ;

     

       115
       +
               inherit (cfg) contents format;

     

       116
       +
               name = config.image.baseName;

     

       117
        
       

     

       118
        
               includeChannel = true;

     

       119
        
       

     
···

       129
        
       

     

       130
        
               postVM = ''

     

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

     

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

     

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

     

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

     

       135
        
                  mv "$rootDiskImage" "$rootDisk"

     
···

       167
        
                 pkgs

     

       168
        
                 ;

     

       169
        
       

     

       170
       +
               inherit (cfg) contents format;

     

       171
       +
               inherit (config.image) baseName;

     

       172
       +
               name = config.image.baseName;

     

       173
        
       

     

       174
        
               fsType = "ext4";

     

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

     
···

       177
        
               inherit (config.virtualisation) diskSize;

     

       178
        
       

     

       179
        
               postVM = ''

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       180
        
                  mkdir -p $out/nix-support

     

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

     

       182

+22 -8

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

···

       16
        
         imports = [

     

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

     

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

     

       0
        
       
     

       19
        
           (lib.mkRenamedOptionModuleWith {

     

       20
        
             sinceRelease = 2411;

     

       21
        
             from = [

     
···

       27
        
               "diskSize"

     

       28
        
             ];

     

       29
        
           })

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

       31
        
       

     

       32
        
         options.openstackImage = {

     

       33
       -
           name = mkOption {

     

       34
       -
             type = types.str;

     

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

     

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

     

       37
       -
           };

     

       38
       -
       

     

       39
        
           ramMB = mkOption {

     

       40
        
             type = types.int;

     

       41
        
             default = (3 * 1024);

     
···

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

     

       73
        
           virtualisation.diskSizeAutoSupported = false;

     

       74
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

       76
        
             inherit lib config;

     

       77
       -
             inherit (cfg) contents format name;

     

       0
        
       
     

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

     

       79
        
       

     

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

     
···

       98
        
       

     

       99
        
             postVM = ''

     

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

     

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

     

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

     

       103
        
                mv "$rootDiskImage" "$rootDisk"

     

       104

···

       16
        
         imports = [

     

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

     

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

     

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

     

       20
        
           (lib.mkRenamedOptionModuleWith {

     

       21
        
             sinceRelease = 2411;

     

       22
        
             from = [

     
···

       28
        
               "diskSize"

     

       29
        
             ];

     

       30
        
           })

     

       31
       +
           (lib.mkRenamedOptionModuleWith {

     

       32
       +
             sinceRelease = 2505;

     

       33
       +
             from = [

     

       34
       +
               "openstackImage"

     

       35
       +
               "name"

     

       36
       +
             ];

     

       37
       +
             to = [

     

       38
       +
               "image"

     

       39
       +
               "baseName"

     

       40
       +
             ];

     

       41
       +
           })

     

       42
       +
       

     

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

     

       44
        
       

     

       45
        
         options.openstackImage = {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       46
        
           ramMB = mkOption {

     

       47
        
             type = types.int;

     

       48
        
             default = (3 * 1024);

     
···

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

     

       80
        
           virtualisation.diskSizeAutoSupported = false;

     

       81
        
       

     

       82
       +
           image.extension = cfg.format;

     

       83
       +
           system.nixos.tags = [

     

       84
       +
             "openstack"

     

       85
       +
             "zfs"

     

       86
       +
           ];

     

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

     

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

     

       89
        
             inherit lib config;

     

       90
       +
             inherit (cfg) contents format;

     

       91
       +
             name = config.image.baseName;

     

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

     

       93
        
       

     

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

     
···

       112
        
       

     

       113
        
             postVM = ''

     

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

     

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

     

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

     

       117
        
                mv "$rootDiskImage" "$rootDisk"

     

       118

+7 -2

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

···

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

     

       4
        
       let

     

       5
        
         copyChannel = true;

     

       0
        
       
     

       6
        
       in

     

       7
        
       {

     

       8
        
         imports = [

     

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

     

       0
        
       
     

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

     

       11
        
       

     

       12
        
         documentation.enable = copyChannel;

     

       13
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

       15
       -
           inherit lib config copyChannel;

     

       0
        
       
     

       16
        
           additionalSpace = "1024M";

     

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

     

       18
       -
           format = "qcow2";

     

       19
        
           configFile = pkgs.writeText "configuration.nix"

     

       20
        
             ''

     

       21
        
               {

···

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

     

       4
        
       let

     

       5
        
         copyChannel = true;

     

       6
       +
           format = "qcow2";

     

       7
        
       in

     

       8
        
       {

     

       9
        
         imports = [

     

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

     

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

     

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

     

       13
        
       

     

       14
        
         documentation.enable = copyChannel;

     

       15
        
       

     

       16
       +
         image.extension = format;

     

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

     

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

     

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

     

       20
       +
           inherit lib config copyChannel format;

     

       21
       +
           inherit (config.image) baseName;

     

       22
        
           additionalSpace = "1024M";

     

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

     

       0
        
       
     

       24
        
           configFile = pkgs.writeText "configuration.nix"

     

       25
        
             ''

     

       26
        
               {

+35

nixos/modules/image/images.nix

···

       9
        
         inherit (lib) types;

     

       10
        
       

     

       11
        
         imageModules = {

     

       0
        
       
     

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

     

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

     

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

     
···

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

     

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

     

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

     

       0
        
       
     

       0
        
       
     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

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

     

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

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       25
        
         };

     

       26
        
         imageConfigs = lib.mapAttrs (

     

       27
        
           name: modules:

···

       9
        
         inherit (lib) types;

     

       10
        
       

     

       11
        
         imageModules = {

     

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

     

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

     

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

     

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

     
···

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       26
       +
           qemu = [

     

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

     

       28
       +
             {

     

       29
       +
               image.efiSupport = false;

     

       30
       +
             }

     

       31
       +
           ];

     

       32
       +
           raw-efi = [

     

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

     

       34
       +
             {

     

       35
       +
               image.format = "raw";

     

       36
       +
             }

     

       37
       +
           ];

     

       38
       +
           raw = [

     

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

     

       40
       +
             {

     

       41
       +
               image.format = "raw";

     

       42
       +
               image.efiSupport = false;

     

       43
       +
             }

     

       44
       +
           ];

     

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

     

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

     

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

     

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

     

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

     

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

     

       51
       +
           sd-card = [

     

       52
       +
             (

     

       53
       +
               let

     

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

     

       55
       +
               in

     

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

     

       57
       +
             )

     

       58
       +
           ];

     

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

     

       60
        
         };

     

       61
        
         imageConfigs = lib.mapAttrs (

     

       62
        
           name: modules:

-3

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

···

       15
        
         # Adds terminus_font for people with HiDPI displays

     

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

     

       17
        
       

     

       18
       -
         # ISO naming.

     

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

     

       20
       -
       

     

       21
        
         # EFI booting

     

       22
        
         isoImage.makeEfiBootable = true;

     

       23

···

       15
        
         # Adds terminus_font for people with HiDPI displays

     

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

     

       17
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       18
        
         # EFI booting

     

       19
        
         isoImage.makeEfiBootable = true;

     

       20

+31 -17

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

···

       476
        
       in

     

       477
        
       

     

       478
        
       {

     

       479
       -
         options = {

     

       480
       -
       

     

       481
       -
           isoImage.isoName = lib.mkOption {

     

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

     

       483
       -
             type = lib.types.str;

     

       484
       -
             description = ''

     

       485
       -
               Name of the generated ISO image file.

     

       486
       -
             '';

     

       487
       -
           };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       488
        
       

     

       489
       -
           isoImage.isoBaseName = lib.mkOption {

     

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

     

       491
       -
             type = lib.types.str;

     

       492
       -
             description = ''

     

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

     

       494
       -
             '';

     

       495
       -
           };

     

       496
        
       

     

       497
        
           isoImage.compressImage = lib.mkOption {

     

       498
        
             default = false;

     
···

       858
        
           boot.loader.timeout = 10;

     

       859
        
       

     

       860
        
           # Create the ISO image.

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

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

     

       0
        
       
     

       863
        
             bootable = config.isoImage.makeBiosBootable;

     

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

     

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

···

       476
        
       in

     

       477
        
       

     

       478
        
       {

     

       479
       +
         imports = [

     

       480
       +
           (lib.mkRenamedOptionModuleWith {

     

       481
       +
             sinceRelease = 2505;

     

       482
       +
             from = [

     

       483
       +
               "isoImage"

     

       484
       +
               "isoBaseName"

     

       485
       +
             ];

     

       486
       +
             to = [

     

       487
       +
               "image"

     

       488
       +
               "baseName"

     

       489
       +
             ];

     

       490
       +
           })

     

       491
       +
           (lib.mkRenamedOptionModuleWith {

     

       492
       +
             sinceRelease = 2505;

     

       493
       +
             from = [

     

       494
       +
               "isoImage"

     

       495
       +
               "isoName"

     

       496
       +
             ];

     

       497
       +
             to = [

     

       498
       +
               "image"

     

       499
       +
               "fileName"

     

       500
       +
             ];

     

       501
       +
           })

     

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

     

       503
       +
         ];

     

       504
        
       

     

       505
       +
         options = {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       506
        
       

     

       507
        
           isoImage.compressImage = lib.mkOption {

     

       508
        
             default = false;

     
···

       868
        
           boot.loader.timeout = 10;

     

       869
        
       

     

       870
        
           # Create the ISO image.

     

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

     

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

     

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

     

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

     

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

     

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

     

       877
        
             bootable = config.isoImage.makeBiosBootable;

     

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

     

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

+20 -1

nixos/modules/installer/netboot/netboot.nix

···

       1
        
       # This module creates netboot media containing the given NixOS

     

       2
        
       # configuration.

     

       3
        
       

     

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

     

       5
        
       

     

       6
        
       with lib;

     

       7
        
       

     

       8
        
       {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       9
        
         options = {

     

       10
        
       

     

       11
        
           netboot.squashfsCompression = mkOption {

     
···

       128
        
               path = config.system.build.kexecScript;

     

       129
        
             }

     

       130
        
           ];

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       131
        
       

     

       132
        
           boot.loader.timeout = 10;

     

       133

···

       1
        
       # This module creates netboot media containing the given NixOS

     

       2
        
       # configuration.

     

       3
        
       

     

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

     

       5
        
       

     

       6
        
       with lib;

     

       7
        
       

     

       8
        
       {

     

       9
       +
         imports = [

     

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

     

       11
       +
         ];

     

       12
       +
       

     

       13
        
         options = {

     

       14
        
       

     

       15
        
           netboot.squashfsCompression = mkOption {

     
···

       132
        
               path = config.system.build.kexecScript;

     

       133
        
             }

     

       134
        
           ];

     

       135
       +
       

     

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

     

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

     

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

     

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

     

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

     

       141
       +
             fileName = config.image.baseName;

     

       142
       +
             storeContents = [

     

       143
       +
               {

     

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

     

       145
       +
                 symlink = "/kexec_nixos";

     

       146
       +
               }

     

       147
       +
             ];

     

       148
       +
             contents = [];

     

       149
       +
           };

     

       150
        
       

     

       151
        
           boot.loader.timeout = 10;

     

       152

+31 -17

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

···

       29
        
         imports = [

     

       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
        
           (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.")

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       32
        
         ];

     

       33
        
       

     

       34
        
         options.sdImage = {

     

       35
       -
           imageName = mkOption {

     

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

     

       37
       -
             description = ''

     

       38
       -
               Name of the generated image file.

     

       39
       -
             '';

     

       40
       -
           };

     

       41
       -
       

     

       42
       -
           imageBaseName = mkOption {

     

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

     

       44
       -
             description = ''

     

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

     

       46
       -
             '';

     

       47
       -
           };

     

       48
       -
       

     

       49
        
           storePaths = mkOption {

     

       50
        
             type = with types; listOf package;

     

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

     
···

       180
        
       

     

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

     

       182
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

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

     

       185
       -
             name = config.sdImage.imageName;

     

       186
        
       

     

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

     

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

     

       189
        
       

     

       190
       -
             inherit (config.sdImage) imageName compressImage;

     

       191
        
       

     

       192
        
             buildCommand = ''

     

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

     

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

     

       195
        
       

     

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

     

       197
        
               if test -n "$compressImage"; then

···

       29
        
         imports = [

     

       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
        
           (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
       +
           (lib.mkRenamedOptionModuleWith {

     

       33
       +
             sinceRelease = 2505;

     

       34
       +
             from = [

     

       35
       +
               "sdImage"

     

       36
       +
               "imageBaseName"

     

       37
       +
             ];

     

       38
       +
             to = [

     

       39
       +
               "image"

     

       40
       +
               "baseName"

     

       41
       +
             ];

     

       42
       +
           })

     

       43
       +
           (lib.mkRenamedOptionModuleWith {

     

       44
       +
             sinceRelease = 2505;

     

       45
       +
             from = [

     

       46
       +
               "sdImage"

     

       47
       +
               "imageName"

     

       48
       +
             ];

     

       49
       +
             to = [

     

       50
       +
               "image"

     

       51
       +
               "fileName"

     

       52
       +
             ];

     

       53
       +
           })

     

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

     

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

     

       56
        
         ];

     

       57
        
       

     

       58
        
         options.sdImage = {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       59
        
           storePaths = mkOption {

     

       60
        
             type = with types; listOf package;

     

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

     
···

       190
        
       

     

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

     

       192
        
       

     

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

     

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

     

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

     

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

     

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

     

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

     

       199
       +
             name = config.image.fileName;

     

       200
        
       

     

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

     

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

     

       203
        
       

     

       204
       +
             inherit (config.sdImage) compressImage;

     

       205
        
       

     

       206
        
             buildCommand = ''

     

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

     

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

     

       209
        
       

     

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

     

       211
        
               if test -n "$compressImage"; then

+61

nixos/modules/virtualisation/disk-image.nix

···

       1
       +
       {

     

       2
       +
         config,

     

       3
       +
         lib,

     

       4
       +
         pkgs,

     

       5
       +
         ...

     

       6
       +
       }:

     

       7
       +
       let

     

       8
       +
         cfg = config.image;

     

       9
       +
       in

     

       10
       +
       {

     

       11
       +
         imports = [

     

       12
       +
           ./disk-size-option.nix

     

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

     

       14
       +
         ];

     

       15
       +
       

     

       16
       +
         options.image = {

     

       17
       +
           format = lib.mkOption {

     

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

     

       19
       +
             type = lib.types.enum [

     

       20
       +
               "raw"

     

       21
       +
               "qcow2"

     

       22
       +
             ];

     

       23
       +
             default = "qcow2";

     

       24
       +
           };

     

       25
       +
           efiSupport = lib.mkOption {

     

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

     

       27
       +
             type = lib.types.bool;

     

       28
       +
             default = true;

     

       29
       +
           };

     

       30
       +
         };

     

       31
       +
       

     

       32
       +
         config = {

     

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

     

       34
       +
             enable = lib.mkOptionDefault true;

     

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

     

       36
       +
           };

     

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

     

       38
       +
           boot.growPartition = lib.mkDefault true;

     

       39
       +
       

     

       40
       +
           fileSystems = {

     

       41
       +
             "/" = {

     

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

     

       43
       +
               autoResize = true;

     

       44
       +
               fsType = "ext4";

     

       45
       +
             };

     

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

     

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

     

       48
       +
               fsType = "vfat";

     

       49
       +
             };

     

       50
       +
           };

     

       51
       +
       

     

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

     

       53
       +
           image.extension = cfg.format;

     

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

     

       55
       +
             inherit lib config pkgs;

     

       56
       +
             inherit (config.virtualisation) diskSize;

     

       57
       +
             inherit (cfg) baseName format;

     

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

     

       59
       +
           };

     

       60
       +
         };

     

       61
       +
       }

+1 -1

nixos/release.nix

···

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

     

       63
        
             inherit system;

     

       64
        
             modules = makeModules module {

     

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

     

       66
        
             };

     

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

     

       68

···

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

     

       63
        
             inherit system;

     

       64
        
             modules = makeModules module {

     

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

     

       66
        
             };

     

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

     

       68

+1 -1

nixos/tests/ec2.nix

···

       55
        
             }

     

       56
        
           ];

     

       57
        
         }).config;

     

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

     

       59
        
       

     

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

     

       61
        
         snakeOilPrivateKey = sshKeys.snakeOilPrivateKey.text;

···

       55
        
             }

     

       56
        
           ];

     

       57
        
         }).config;

     

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

     

       59
        
       

     

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

     

       61
        
         snakeOilPrivateKey = sshKeys.snakeOilPrivateKey.text;

+1 -1

pkgs/desktops/gnome/installer.nix

···

       7
        
       

     

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

     

       9
        
           inherit system;

     

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

     

       11
        
         }).config;

     

       12
        
       

     

       13
        
       in

···

       7
        
       

     

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

     

       9
        
           inherit system;

     

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

     

       11
        
         }).config;

     

       12
        
       

     

       13
        
       in