commit 0d3738cdcc48bd32a7eae9b914440b67c8db252e · pyrox.dev/nixpkgs

+4 -2

nixos/lib/make-disk-image.nix

···

       23
       23
        
         postVM ? ""

     

       24
       24
        
       

     

       25
       25
        
       , name ? "nixos-disk-image"

     

       26
       26
       +
       

     

       27
       27
       +
       , format ? "raw"

     

       26
       28
        
       }:

     

       27
       29
        
       

     

       28
       30
        
       with lib;

     
···

       32
       34
        
           { preVM =

     

       33
       35
        
               ''

     

       34
       36
        
                 mkdir $out

     

       35
       35
       -
                 diskImage=$out/nixos.img

     

       36
       36
       -
                 ${pkgs.vmTools.qemu}/bin/qemu-img create -f raw $diskImage "${toString diskSize}M"

     

       37
       37
       +
                 diskImage=$out/nixos.${if format == "qcow2" then "qcow2" else "img"}

     

       38
       38
       +
                 ${pkgs.vmTools.qemu}/bin/qemu-img create -f ${format} $diskImage "${toString diskSize}M"

     

       37
       39
        
                 mv closure xchg/

     

       38
       40
        
               '';

     

       39
       41
        
             buildInputs = [ pkgs.utillinux pkgs.perl pkgs.e2fsprogs pkgs.parted ];

+3 -1

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

···

       10
       10
        
           ];

     

       11
       11
        
       

     

       12
       12
        
         system.build.amazonImage = import ../../../lib/make-disk-image.nix {

     

       13
       13
       -
           inherit pkgs lib config;

     

       13
       13
       +
           inherit lib config;

     

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

     

       14
       15
        
           partitioned = config.ec2.hvm;

     

       15
       16
        
           diskSize = if config.ec2.hvm then 2048 else 8192;

     

       17
       17
       +
           format = "qcow2";

     

       16
       18
        
           configFile = pkgs.writeText "configuration.nix"

     

       17
       19
        
             ''

     

       18
       20
        
               {

+1 -2

nixos/modules/virtualisation/amazon-image.nix

···

       65
       65
        
               fi

     

       66
       66
        
       

     

       67
       67
        
               if ! [ -e "$metaDir/user-data" ]; then

     

       68
       68
       -
                 wget -q -O "$metaDir/user-data" http://169.254.169.254/1.0/user-data

     

       69
       69
       -
                 chmod 600 "$metaDir/user-data"

     

       68
       68
       +
                 wget -q -O "$metaDir/user-data" http://169.254.169.254/1.0/user-data && chmod 600 "$metaDir/user-data"

     

       70
       69
        
               fi

     

       71
       70
        
       

     

       72
       71
        
               if ! [ -e "$metaDir/hostname" ]; then

+5 -6

nixos/tests/ec2.nix

···

       11
       11
        
             modules = [

     

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

     

       13
       13
        
               ../modules/testing/test-instrumentation.nix

     

       14
       14
       -
               ../modules/profiles/minimal.nix

     

       15
       14
        
               ../modules/profiles/qemu-guest.nix

     

       16
       15
        
               { ec2.hvm = true;

     

       17
       16
        
       

     
···

       30
       29
        
             metaData = pkgs.stdenv.mkDerivation {

     

       31
       30
        
               name = "metadata";

     

       32
       31
        
               buildCommand = ''

     

       33
       33
       -
                 mkdir -p $out/2011-01-01

     

       34
       34
       -
                 ln -s ${pkgs.writeText "userData" userData} $out/2011-01-01/user-data

     

       35
       32
        
                 mkdir -p $out/1.0/meta-data

     

       33
       33
       +
                 ln -s ${pkgs.writeText "userData" userData} $out/1.0/user-data

     

       36
       34
        
                 echo "${hostname}" > $out/1.0/meta-data/hostname

     

       37
       35
        
                 echo "(unknown)" > $out/1.0/meta-data/ami-manifest-path

     

       38
       36
        
               '' + optionalString (sshPublicKey != null) ''

     
···

       48
       46
        
                 my $imageDir = ($ENV{'TMPDIR'} // "/tmp") . "/vm-state-machine";

     

       49
       47
        
                 mkdir $imageDir, 0700;

     

       50
       48
        
                 my $diskImage = "$imageDir/machine.qcow2";

     

       51
       51
       -
                 system("qemu-img create -f qcow2 -o backing_file=${image}/nixos.img $diskImage") == 0 or die;

     

       49
       49
       +
                 system("qemu-img create -f qcow2 -o backing_file=${image}/nixos.qcow2 $diskImage") == 0 or die;

     

       52
       50
        
                 system("qemu-img resize $diskImage 10G") == 0 or die;

     

       53
       51
        
       

     

       54
       52
        
                 # Note: we use net=169.0.0.0/8 rather than

     
···

       91
       89
        
           '';

     

       92
       90
        
           script = ''

     

       93
       91
        
             $machine->start;

     

       94
       94
       -
             $machine->waitForFile("/root/user-data");

     

       92
       92
       +
             $machine->waitForFile("/etc/ec2-metadata/user-data");

     

       95
       93
        
             $machine->waitForUnit("sshd.service");

     

       96
       94
        
       

     

       97
       95
        
             $machine->succeed("grep unknown /etc/ec2-metadata/ami-manifest-path");

     
···

       121
       119
        
             # Just to make sure resizing is idempotent.

     

       122
       120
        
             $machine->shutdown;

     

       123
       121
        
             $machine->start;

     

       124
       124
       -
             $machine->waitForFile("/root/user-data");

     

       122
       122
       +
             $machine->waitForFile("/etc/ec2-metadata/user-data");

     

       125
       123
        
           '';

     

       126
       124
        
         };

     

       127
       125
        
       

     
···

       135
       133
        
               imports = [

     

       136
       134
        
                 <nixpkgs/nixos/modules/virtualisation/amazon-image.nix>

     

       137
       135
        
                 <nixpkgs/nixos/modules/testing/test-instrumentation.nix>

     

       136
       136
       +
                 <nixpkgs/nixos/modules/profiles/qemu-guest.nix>

     

       138
       137
        
               ];

     

       139
       138
        
               environment.etc.testFile = {

     

       140
       139
        
                 text = "whoa";