commit aeb31b97ad055e3bab6660ca9713e406915c6ea7 · pyrox.dev/nixpkgs

+105

nixos/lib/make-disk-image.nix

···

       1
       +
       { pkgs

     

       2
       +
       , lib

     

       3
       +
       

     

       4
       +
       , # The NixOS configuration to be installed onto the disk image.

     

       5
       +
         config

     

       6
       +
       

     

       7
       +
       , # The size of the disk, in megabytes.

     

       8
       +
         diskSize

     

       9
       +
       

     

       10
       +
       , # Whether the disk should be partitioned (with a single partition

     

       11
       +
         # containing the root filesystem) or contain the root filesystem

     

       12
       +
         # directly.

     

       13
       +
         partitioned ? true

     

       14
       +
       

     

       15
       +
       , # The root file system type.

     

       16
       +
         fsType ? "ext4"

     

       17
       +
       

     

       18
       +
       , # The initial NixOS configuration file to be copied to

     

       19
       +
         # /etc/nixos/configuration.nix.

     

       20
       +
         configFile ? null

     

       21
       +
       

     

       22
       +
       }:

     

       23
       +
       

     

       24
       +
       with lib;

     

       25
       +
       

     

       26
       +
       pkgs.vmTools.runInLinuxVM (

     

       27
       +
         pkgs.runCommand "nixos-disk-image"

     

       28
       +
           { preVM =

     

       29
       +
               ''

     

       30
       +
                 mkdir $out

     

       31
       +
                 diskImage=$out/nixos.img

     

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

     

       33
       +
                 mv closure xchg/

     

       34
       +
               '';

     

       35
       +
             buildInputs = [ pkgs.utillinux pkgs.perl pkgs.e2fsprogs pkgs.parted ];

     

       36
       +
             exportReferencesGraph =

     

       37
       +
               [ "closure" config.system.build.toplevel ];

     

       38
       +
           }

     

       39
       +
           ''

     

       40
       +
             ${if partitioned then ''

     

       41
       +
               # Create a single / partition.

     

       42
       +
               parted /dev/vda mklabel msdos

     

       43
       +
               parted /dev/vda -- mkpart primary ext2 1M -1s

     

       44
       +
               . /sys/class/block/vda1/uevent

     

       45
       +
               mknod /dev/vda1 b $MAJOR $MINOR

     

       46
       +
               rootDisk=/dev/vda1

     

       47
       +
             '' else ''

     

       48
       +
               rootDisk=/dev/vda

     

       49
       +
             ''}

     

       50
       +
       

     

       51
       +
             # Create an empty filesystem and mount it.

     

       52
       +
             mkfs.${fsType} -L nixos $rootDisk

     

       53
       +
             ${optionalString (fsType == "ext4") ''

     

       54
       +
               tune2fs -c 0 -i 0 $rootDisk

     

       55
       +
             ''}

     

       56
       +
             mkdir /mnt

     

       57
       +
             mount $rootDisk /mnt

     

       58
       +
       

     

       59
       +
             # The initrd expects these directories to exist.

     

       60
       +
             mkdir /mnt/dev /mnt/proc /mnt/sys

     

       61
       +
       

     

       62
       +
             mount -o bind /proc /mnt/proc

     

       63
       +
             mount -o bind /dev /mnt/dev

     

       64
       +
             mount -o bind /sys /mnt/sys

     

       65
       +
       

     

       66
       +
             # Copy all paths in the closure to the filesystem.

     

       67
       +
             storePaths=$(perl ${pkgs.pathsFromGraph} /tmp/xchg/closure)

     

       68
       +
       

     

       69
       +
             mkdir -p /mnt/nix/store

     

       70
       +
             echo "copying everything (will take a while)..."

     

       71
       +
             cp -prd $storePaths /mnt/nix/store/

     

       72
       +
       

     

       73
       +
             # Register the paths in the Nix database.

     

       74
       +
             printRegistration=1 perl ${pkgs.pathsFromGraph} /tmp/xchg/closure | \

     

       75
       +
                 chroot /mnt ${config.nix.package}/bin/nix-store --load-db --option build-users-group ""

     

       76
       +
       

     

       77
       +
             # Create the system profile to allow nixos-rebuild to work.

     

       78
       +
             chroot /mnt ${config.nix.package}/bin/nix-env --option build-users-group "" \

     

       79
       +
                 -p /nix/var/nix/profiles/system --set ${config.system.build.toplevel}

     

       80
       +
       

     

       81
       +
             # `nixos-rebuild' requires an /etc/NIXOS.

     

       82
       +
             mkdir -p /mnt/etc

     

       83
       +
             touch /mnt/etc/NIXOS

     

       84
       +
       

     

       85
       +
             # `switch-to-configuration' requires a /bin/sh

     

       86
       +
             mkdir -p /mnt/bin

     

       87
       +
             ln -s ${config.system.build.binsh}/bin/sh /mnt/bin/sh

     

       88
       +
       

     

       89
       +
             # Install a configuration.nix.

     

       90
       +
             mkdir -p /mnt/etc/nixos

     

       91
       +
             ${optionalString (configFile != null) ''

     

       92
       +
               cp ${configFile} /mnt/etc/nixos/configuration.nix

     

       93
       +
             ''}

     

       94
       +
       

     

       95
       +
             # Generate the GRUB menu.

     

       96
       +
             ln -s vda /dev/xvda

     

       97
       +
             chroot /mnt ${config.system.build.toplevel}/bin/switch-to-configuration boot

     

       98
       +
       

     

       99
       +
             umount /mnt/proc /mnt/dev /mnt/sys

     

       100
       +
             umount /mnt

     

       101
       +
       

     

       102
       +
             # Do an fsck to make sure resize2fs works.

     

       103
       +
             fsck.${fsType} -f -y $rootDisk

     

       104
       +
           ''

     

       105
       +
       )

-5

nixos/maintainers/scripts/ec2/amazon-base-config.nix

···

       1
       -
       { modulesPath, ...}:

     

       2
       -
       {

     

       3
       -
         imports = [ "${modulesPath}/virtualisation/amazon-init.nix" ];

     

       4
       -
         services.journald.rateLimitBurst = 0;

     

       5
       -
       }

-5

nixos/maintainers/scripts/ec2/amazon-hvm-config.nix

···

       1
       -
       { config, pkgs, ...}:

     

       2
       -
       {

     

       3
       -
         imports = [ ./amazon-base-config.nix ];

     

       4
       -
         ec2.hvm = true;

     

       5
       -
       }

-34

nixos/maintainers/scripts/ec2/amazon-hvm-install-config.nix

···

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

     

       2
       -
       let

     

       3
       -
         cloudUtils = pkgs.fetchurl {

     

       4
       -
           url = "https://launchpad.net/cloud-utils/trunk/0.27/+download/cloud-utils-0.27.tar.gz";

     

       5
       -
           sha256 = "16shlmg36lidp614km41y6qk3xccil02f5n3r4wf6d1zr5n4v8vd";

     

       6
       -
         };

     

       7
       -
         growpart = pkgs.stdenv.mkDerivation {

     

       8
       -
           name = "growpart";

     

       9
       -
           src = cloudUtils;

     

       10
       -
           buildPhase = ''

     

       11
       -
             cp bin/growpart $out

     

       12
       -
             sed -i 's|awk|gawk|' $out

     

       13
       -
             sed -i 's|sed|gnused|' $out

     

       14
       -
           '';

     

       15
       -
           dontInstall = true;

     

       16
       -
           dontPatchShebangs = true;

     

       17
       -
         };

     

       18
       -
       in

     

       19
       -
       {

     

       20
       -
         imports = [ ./amazon-base-config.nix ];

     

       21
       -
         ec2.hvm = true;

     

       22
       -
         boot.loader.grub.device = lib.mkOverride 0 "/dev/xvdg";

     

       23
       -
         boot.kernelParams = [ "console=ttyS0" ];

     

       24
       -
       

     

       25
       -
         boot.initrd.extraUtilsCommands = ''

     

       26
       -
           copy_bin_and_libs ${pkgs.gawk}/bin/gawk

     

       27
       -
           copy_bin_and_libs ${pkgs.gnused}/bin/sed

     

       28
       -
           copy_bin_and_libs ${pkgs.utillinux}/sbin/sfdisk

     

       29
       -
           cp -v ${growpart} $out/bin/growpart

     

       30
       -
         '';

     

       31
       -
         boot.initrd.postDeviceCommands = ''

     

       32
       -
           [ -e /dev/xvda ] && [ -e /dev/xvda1 ] && TMPDIR=/run sh $(type -P growpart) /dev/xvda 1

     

       33
       -
         '';

     

       34
       -
       }

+27

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

···

       1
       +
       { config, lib, pkgs, ... }:

     

       2
       +
       

     

       3
       +
       with lib;

     

       4
       +
       

     

       5
       +
       {

     

       6
       +
       

     

       7
       +
         imports =

     

       8
       +
           [ ../../../modules/installer/cd-dvd/channel.nix

     

       9
       +
             ../../../modules/virtualisation/amazon-image.nix

     

       10
       +
           ];

     

       11
       +
       

     

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

     

       13
       +
           inherit pkgs lib config;

     

       14
       +
           partitioned = config.ec2.hvm;

     

       15
       +
           diskSize = 8192;

     

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

     

       17
       +
             ''

     

       18
       +
               {

     

       19
       +
                 imports = [ <nixpkgs/nixos/modules/virtualisation/amazon-image.nix> ];

     

       20
       +
                 ${optionalString config.ec2.hvm ''

     

       21
       +
                   ec2.hvm = true;

     

       22
       +
                 ''}

     

       23
       +
               }

     

       24
       +
             '';

     

       25
       +
         };

     

       26
       +
       

     

       27
       +
       }

+217

nixos/maintainers/scripts/ec2/create-amis.sh

···

       1
       +
       #! /bin/sh -e

     

       2
       +
       

     

       3
       +
       set -o pipefail

     

       4
       +
       #set -x

     

       5
       +
       

     

       6
       +
       stateDir=${TMPDIR:-/tmp}/ec2-image

     

       7
       +
       echo "keeping state in $stateDir"

     

       8
       +
       mkdir -p $stateDir

     

       9
       +
       

     

       10
       +
       version=$(nix-instantiate --eval --strict '<nixpkgs>' -A lib.nixpkgsVersion | sed s/'"'//g)

     

       11
       +
       echo "NixOS version is $version"

     

       12
       +
       

     

       13
       +
       rm -f ec2-amis.nix

     

       14
       +
       

     

       15
       +
       

     

       16
       +
       for type in hvm pv; do

     

       17
       +
           link=$stateDir/$type

     

       18
       +
           imageFile=$link/nixos.img

     

       19
       +
           system=x86_64-linux

     

       20
       +
           arch=x86_64

     

       21
       +
       

     

       22
       +
           # Build the image.

     

       23
       +
           if ! [ -L $link ]; then

     

       24
       +
               if [ $type = pv ]; then hvmFlag=false; else hvmFlag=true; fi

     

       25
       +
       

     

       26
       +
               echo "building image type '$type'..."

     

       27
       +
               nix-build -o $link \

     

       28
       +
                   '<nixpkgs/nixos>' \

     

       29
       +
                   -A config.system.build.amazonImage \

     

       30
       +
                   --arg configuration "{ imports = [ <nixpkgs/nixos/maintainers/scripts/ec2/amazon-image.nix> ]; ec2.hvm = $hvmFlag; }"

     

       31
       +
           fi

     

       32
       +
       

     

       33
       +
           for store in ebs s3; do

     

       34
       +
       

     

       35
       +
               bucket=nixos-amis

     

       36
       +
               bucketDir="$version-$type-$store"

     

       37
       +
       

     

       38
       +
               prevAmi=

     

       39
       +
               prevRegion=

     

       40
       +
       

     

       41
       +
               #for region in eu-west-1 eu-central-1 us-east-1 us-west-1 us-west-2 ap-southeast-1 ap-southeast-2 ap-northeast-1 sa-east-1; do

     

       42
       +
               for region in eu-west-1 us-east-1; do

     

       43
       +
       

     

       44
       +
                   name=nixos-$version-$arch-$type-$store

     

       45
       +
                   description="NixOS $system $version ($type-$store)"

     

       46
       +
       

     

       47
       +
                   amiFile=$stateDir/$region.$type.$store.ami-id

     

       48
       +
       

     

       49
       +
                   if ! [ -e $amiFile ]; then

     

       50
       +
       

     

       51
       +
                       echo "doing $name in $region..."

     

       52
       +
       

     

       53
       +
                       if [ -n "$prevAmi" ]; then

     

       54
       +
                           ami=$(ec2-copy-image \

     

       55
       +
                               --region "$region" \

     

       56
       +
                               --source-region "$prevRegion" --source-ami-id "$prevAmi" \

     

       57
       +
                               --name "$name" --description "$description" | cut -f 2)

     

       58
       +
                       else

     

       59
       +
       

     

       60
       +
                           if [ $store = s3 ]; then

     

       61
       +
       

     

       62
       +
                               # Bundle the image.

     

       63
       +
                               imageDir=$stateDir/$type-bundled

     

       64
       +
       

     

       65
       +
                               if ! [ -d $imageDir ]; then

     

       66
       +
                                   rm -rf $imageDir.tmp

     

       67
       +
                                   mkdir -p $imageDir.tmp

     

       68
       +
                                   ec2-bundle-image \

     

       69
       +
                                       -d $imageDir.tmp \

     

       70
       +
                                       -i $imageFile --arch $arch \

     

       71
       +
                                       --user "$AWS_ACCOUNT" -c "$EC2_CERT" -k "$EC2_PRIVATE_KEY"

     

       72
       +
                                   mv $imageDir.tmp $imageDir

     

       73
       +
                               fi

     

       74
       +
       

     

       75
       +
                               # Upload the bundle to S3.

     

       76
       +
                               if ! [ -e $imageDir/uploaded ]; then

     

       77
       +
                                   echo "uploading bundle to S3..."

     

       78
       +
                                   ec2-upload-bundle \

     

       79
       +
                                       -m $imageDir/nixos.img.manifest.xml \

     

       80
       +
                                       -b "$bucket/$bucketDir" \

     

       81
       +
                                       -a "$EC2_ACCESS_KEY" -s "$EC2_SECRET_KEY" \

     

       82
       +
                                       --location EU

     

       83
       +
                                   touch $imageDir/uploaded

     

       84
       +
                               fi

     

       85
       +
       

     

       86
       +
                               extraFlags="$bucket/$bucketDir/nixos.img.manifest.xml"

     

       87
       +
       

     

       88
       +
                           else

     

       89
       +
       

     

       90
       +
                               # Convert the image to vhd format so we don't have

     

       91
       +
                               # to upload a huge raw image.

     

       92
       +
                               vhdFile=$stateDir/$type.vhd

     

       93
       +
                               if ! [ -e $vhdFile ]; then

     

       94
       +
                                   qemu-img convert -O vpc $imageFile $vhdFile.tmp

     

       95
       +
                                   mv $vhdFile.tmp $vhdFile

     

       96
       +
                               fi

     

       97
       +
       

     

       98
       +
                               taskId=$(cat $stateDir/$region.$type.task-id 2> /dev/null || true)

     

       99
       +
                               volId=$(cat $stateDir/$region.$type.vol-id 2> /dev/null || true)

     

       100
       +
                               snapId=$(cat $stateDir/$region.$type.snap-id 2> /dev/null || true)

     

       101
       +
       

     

       102
       +
                               # Import the VHD file.

     

       103
       +
                               if [ -z "$snapId" -a -z "$volId" -a -z "$taskId" ]; then

     

       104
       +
                                   echo "importing $vhdFile..."

     

       105
       +
                                   taskId=$(ec2-import-volume $vhdFile --no-upload -f vhd \

     

       106
       +
                                       -o "$EC2_ACCESS_KEY" -w "$EC2_SECRET_KEY" \

     

       107
       +
                                       --region "$region" -z "${region}a" \

     

       108
       +
                                       --bucket "$bucket" --prefix "$bucketDir/" \

     

       109
       +
                                       | tee /dev/stderr \

     

       110
       +
                                       | sed 's/.*\(import-vol-[0-9a-z]\+\).*/\1/ ; t ; d')

     

       111
       +
                                   echo -n "$taskId" > $stateDir/$region.$type.task-id

     

       112
       +
                               fi

     

       113
       +
       

     

       114
       +
                               if [ -z "$snapId" -a -z "$volId" ]; then

     

       115
       +
                                   ec2-resume-import  $vhdFile -t "$taskId" --region "$region" \

     

       116
       +
                                       -o "$EC2_ACCESS_KEY" -w "$EC2_SECRET_KEY"

     

       117
       +
                               fi

     

       118
       +
       

     

       119
       +
                               # Wait for the volume creation to finish.

     

       120
       +
                               if [ -z "$snapId" -a -z "$volId" ]; then

     

       121
       +
                                   echo "waiting for import to finish..."

     

       122
       +
                                   while true; do

     

       123
       +
                                       volId=$(ec2-describe-conversion-tasks "$taskId" --region "$region" | sed 's/.*VolumeId.*\(vol-[0-9a-f]\+\).*/\1/ ; t ; d')

     

       124
       +
                                       if [ -n "$volId" ]; then break; fi

     

       125
       +
                                       sleep 10

     

       126
       +
                                   done

     

       127
       +
       

     

       128
       +
                                   echo -n "$volId" > $stateDir/$region.$type.vol-id

     

       129
       +
                               fi

     

       130
       +
       

     

       131
       +
                               # Delete the import task.

     

       132
       +
                               if [ -n "$volId" -a -n "$taskId" ]; then

     

       133
       +
                                   echo "removing import task..."

     

       134
       +
                                   ec2-delete-disk-image -t "$taskId" --region "$region" -o "$EC2_ACCESS_KEY" -w "$EC2_SECRET_KEY" || true

     

       135
       +
                                   rm -f $stateDir/$region.$type.task-id

     

       136
       +
                               fi

     

       137
       +
       

     

       138
       +
                               # Create a snapshot.

     

       139
       +
                               if [ -z "$snapId" ]; then

     

       140
       +
                                   echo "creating snapshot..."

     

       141
       +
                                   snapId=$(ec2-create-snapshot "$volId" --region "$region" | cut -f 2)

     

       142
       +
                                   echo -n "$snapId" > $stateDir/$region.$type.snap-id

     

       143
       +
                                   ec2-create-tags "$snapId" -t "Name=$description" --region "$region"

     

       144
       +
                               fi

     

       145
       +
       

     

       146
       +
                               # Wait for the snapshot to finish.

     

       147
       +
                               echo "waiting for snapshot to finish..."

     

       148
       +
                               while true; do

     

       149
       +
                                   status=$(ec2-describe-snapshots "$snapId" --region "$region" | head -n1 | cut -f 4)

     

       150
       +
                                   if [ "$status" = completed ]; then break; fi

     

       151
       +
                                   sleep 10

     

       152
       +
                               done

     

       153
       +
       

     

       154
       +
                               # Delete the volume.

     

       155
       +
                               if [ -n "$volId" ]; then

     

       156
       +
                                   echo "deleting volume..."

     

       157
       +
                                   ec2-delete-volume "$volId" --region "$region" || true

     

       158
       +
                                   rm -f $stateDir/$region.$type.vol-id

     

       159
       +
                               fi

     

       160
       +
       

     

       161
       +
                               extraFlags="-b /dev/sda1=$snapId:20:true:gp2"

     

       162
       +
       

     

       163
       +
                               if [ $type = pv ]; then

     

       164
       +
                                   extraFlags+=" --root-device-name=/dev/sda1"

     

       165
       +
                               fi

     

       166
       +
       

     

       167
       +
                               extraFlags+=" -b /dev/sdb=ephemeral0 -b /dev/sdc=ephemeral1 -b /dev/sdd=ephemeral2 -b /dev/sde=ephemeral3"

     

       168
       +
                           fi

     

       169
       +
       

     

       170
       +
                           # Register the AMI.

     

       171
       +
                           if [ $type = pv ]; then

     

       172
       +
                               kernel=$(ec2-describe-images -o amazon --filter "manifest-location=*pv-grub-hd0_1.04-$arch*" --region "$region" | cut -f 2)

     

       173
       +
                               [ -n "$kernel" ]

     

       174
       +
                               echo "using PV-GRUB kernel $kernel"

     

       175
       +
                               extraFlags+=" --virtualization-type paravirtual --kernel $kernel"

     

       176
       +
                           else

     

       177
       +
                               extraFlags+=" --virtualization-type hvm"

     

       178
       +
                           fi

     

       179
       +
       

     

       180
       +
                           set -x

     

       181
       +
                           ami=$(ec2-register \

     

       182
       +
                               -n "$name" \

     

       183
       +
                               -d "$description" \

     

       184
       +
                               --region "$region" \

     

       185
       +
                               --architecture "$arch" \

     

       186
       +
                               $extraFlags | cut -f 2)

     

       187
       +
                       fi

     

       188
       +
       

     

       189
       +
                       echo -n "$ami" > $amiFile

     

       190
       +
                       echo "created AMI $ami of type '$type' in $region..."

     

       191
       +
       

     

       192
       +
                   else

     

       193
       +
                       ami=$(cat $amiFile)

     

       194
       +
                   fi

     

       195
       +
       

     

       196
       +
                   echo "waiting for AMI..."

     

       197
       +
                   while true; do

     

       198
       +
                       status=$(ec2-describe-images "$ami" --region "$region" | head -n1 | cut -f 5)

     

       199
       +
                       if [ "$status" = available ]; then break; fi

     

       200
       +
                       sleep 10

     

       201
       +
                   done

     

       202
       +
       

     

       203
       +
                   ec2-modify-image-attribute \

     

       204
       +
                       --region "$region" "$ami" -l -a all

     

       205
       +
       

     

       206
       +
                   echo "region = $region, type = $type, store = $store, ami = $ami"

     

       207
       +
                   if [ -z "$prevAmi" ]; then

     

       208
       +
                       prevAmi="$ami"

     

       209
       +
                       prevRegion="$region"

     

       210
       +
                   fi

     

       211
       +
       

     

       212
       +
                   echo "  \"15.09\".$region.$type-$store = \"$ami\";" >> ec2-amis.nix

     

       213
       +
               done

     

       214
       +
       

     

       215
       +
           done

     

       216
       +
       

     

       217
       +
       done

-216

nixos/maintainers/scripts/ec2/create-ebs-amis.py

···

       1
       -
       #! /usr/bin/env python

     

       2
       -
       

     

       3
       -
       import os

     

       4
       -
       import sys

     

       5
       -
       import time

     

       6
       -
       import argparse

     

       7
       -
       import nixops.util

     

       8
       -
       from nixops import deployment

     

       9
       -
       from boto.ec2.blockdevicemapping import BlockDeviceMapping, BlockDeviceType

     

       10
       -
       import boto.ec2

     

       11
       -
       from nixops.statefile import StateFile, get_default_state_file

     

       12
       -
       

     

       13
       -
       parser = argparse.ArgumentParser(description='Create an EBS-backed NixOS AMI')

     

       14
       -
       parser.add_argument('--region', dest='region', required=True, help='EC2 region to create the image in')

     

       15
       -
       parser.add_argument('--channel', dest='channel', default="14.12", help='Channel to use')

     

       16
       -
       parser.add_argument('--keep', dest='keep', action='store_true', help='Keep NixOps machine after use')

     

       17
       -
       parser.add_argument('--hvm', dest='hvm', action='store_true', help='Create HVM image')

     

       18
       -
       parser.add_argument('--key', dest='key_name', action='store_true', help='Keypair used for HVM instance creation', default="rob")

     

       19
       -
       args = parser.parse_args()

     

       20
       -
       

     

       21
       -
       instance_type = "m3.medium" if args.hvm else "m1.small"

     

       22
       -
       

     

       23
       -
       if args.hvm:

     

       24
       -
           virtualization_type = "hvm"

     

       25
       -
           root_block = "/dev/sda1"

     

       26
       -
           image_type = 'hvm'

     

       27
       -
       else:

     

       28
       -
           virtualization_type = "paravirtual"

     

       29
       -
           root_block = "/dev/sda"

     

       30
       -
           image_type = 'ebs'

     

       31
       -
       

     

       32
       -
       ebs_size = 20

     

       33
       -
       

     

       34
       -
       # Start a NixOS machine in the given region.

     

       35
       -
       f = open("ebs-creator-config.nix", "w")

     

       36
       -
       f.write('''{{

     

       37
       -
         resources.ec2KeyPairs.keypair.accessKeyId = "lb-nixos";

     

       38
       -
         resources.ec2KeyPairs.keypair.region = "{0}";

     

       39
       -
       

     

       40
       -
         machine =

     

       41
       -
           {{ pkgs, ... }}:

     

       42
       -
           {{

     

       43
       -
             deployment.ec2.accessKeyId = "lb-nixos";

     

       44
       -
             deployment.ec2.region = "{0}";

     

       45
       -
             deployment.ec2.blockDeviceMapping."/dev/xvdg".size = pkgs.lib.mkOverride 10 {1};

     

       46
       -
           }};

     

       47
       -
       }}

     

       48
       -
       '''.format(args.region, ebs_size))

     

       49
       -
       f.close()

     

       50
       -
       

     

       51
       -
       db = StateFile(get_default_state_file())

     

       52
       -
       try:

     

       53
       -
           depl = db.open_deployment("ebs-creator")

     

       54
       -
       except Exception:

     

       55
       -
           depl = db.create_deployment()

     

       56
       -
           depl.name = "ebs-creator"

     

       57
       -
       depl.logger.set_autoresponse("y")

     

       58
       -
       depl.nix_exprs = [os.path.abspath("./ebs-creator.nix"), os.path.abspath("./ebs-creator-config.nix")]

     

       59
       -
       if not args.keep: depl.destroy_resources()

     

       60
       -
       depl.deploy(allow_reboot=True)

     

       61
       -
       

     

       62
       -
       m = depl.machines['machine']

     

       63
       -
       

     

       64
       -
       # Do the installation.

     

       65
       -
       device="/dev/xvdg"

     

       66
       -
       if args.hvm:

     

       67
       -
           m.run_command('parted -s /dev/xvdg -- mklabel msdos')

     

       68
       -
           m.run_command('parted -s /dev/xvdg -- mkpart primary ext2 1M -1s')

     

       69
       -
           device="/dev/xvdg1"

     

       70
       -
       

     

       71
       -
       m.run_command("if mountpoint -q /mnt; then umount /mnt; fi")

     

       72
       -
       m.run_command("mkfs.ext4 -L nixos {0}".format(device))

     

       73
       -
       m.run_command("mkdir -p /mnt")

     

       74
       -
       m.run_command("mount {0} /mnt".format(device))

     

       75
       -
       m.run_command("touch /mnt/.ebs")

     

       76
       -
       m.run_command("mkdir -p /mnt/etc/nixos")

     

       77
       -
       

     

       78
       -
       m.run_command("nix-channel --add https://nixos.org/channels/nixos-{} nixos".format(args.channel))

     

       79
       -
       m.run_command("nix-channel --update")

     

       80
       -
       

     

       81
       -
       version = m.run_command("nix-instantiate --eval-only -A lib.nixpkgsVersion '<nixpkgs>'", capture_stdout=True).split(' ')[0].replace('"','').strip()

     

       82
       -
       print >> sys.stderr, "NixOS version is {0}".format(version)

     

       83
       -
       if args.hvm:

     

       84
       -
           m.upload_file("./amazon-base-config.nix", "/mnt/etc/nixos/amazon-base-config.nix")

     

       85
       -
           m.upload_file("./amazon-hvm-config.nix", "/mnt/etc/nixos/configuration.nix")

     

       86
       -
           m.upload_file("./amazon-hvm-install-config.nix", "/mnt/etc/nixos/amazon-hvm-install-config.nix")

     

       87
       -
           m.run_command("NIXOS_CONFIG=/etc/nixos/amazon-hvm-install-config.nix nixos-install")

     

       88
       -
       else:

     

       89
       -
           m.upload_file("./amazon-base-config.nix", "/mnt/etc/nixos/configuration.nix")

     

       90
       -
           m.run_command("nixos-install")

     

       91
       -
       

     

       92
       -
       m.run_command("umount /mnt")

     

       93
       -
       

     

       94
       -
       if args.hvm:

     

       95
       -
           ami_name = "nixos-{0}-x86_64-hvm".format(version)

     

       96
       -
           description = "NixOS {0} (x86_64; EBS root; hvm)".format(version)

     

       97
       -
       else:

     

       98
       -
           ami_name = "nixos-{0}-x86_64-ebs".format(version)

     

       99
       -
           description = "NixOS {0} (x86_64; EBS root)".format(version)

     

       100
       -
       

     

       101
       -
       

     

       102
       -
       # Wait for the snapshot to finish.

     

       103
       -
       def check():

     

       104
       -
           status = snapshot.update()

     

       105
       -
           print >> sys.stderr, "snapshot status is {0}".format(status)

     

       106
       -
           return status == '100%'

     

       107
       -
       

     

       108
       -
       m.connect()

     

       109
       -
       volume = m._conn.get_all_volumes([], filters={'attachment.instance-id': m.resource_id, 'attachment.device': "/dev/sdg"})[0]

     

       110
       -
       

     

       111
       -
       # Create a snapshot.

     

       112
       -
       snapshot = volume.create_snapshot(description=description)

     

       113
       -
       print >> sys.stderr, "created snapshot {0}".format(snapshot.id)

     

       114
       -
       

     

       115
       -
       nixops.util.check_wait(check, max_tries=120)

     

       116
       -
       

     

       117
       -
       m._conn.create_tags([snapshot.id], {'Name': ami_name})

     

       118
       -
       

     

       119
       -
       if not args.keep: depl.destroy_resources()

     

       120
       -
       

     

       121
       -
       # Register the image.

     

       122
       -
       aki = m._conn.get_all_images(filters={'manifest-location': 'ec2*pv-grub-hd0_1.03-x86_64*'})[0]

     

       123
       -
       print >> sys.stderr, "using kernel image {0} - {1}".format(aki.id, aki.location)

     

       124
       -
       

     

       125
       -
       block_map = BlockDeviceMapping()

     

       126
       -
       block_map[root_block] = BlockDeviceType(snapshot_id=snapshot.id, delete_on_termination=True, size=ebs_size, volume_type="gp2")

     

       127
       -
       block_map['/dev/sdb'] = BlockDeviceType(ephemeral_name="ephemeral0")

     

       128
       -
       block_map['/dev/sdc'] = BlockDeviceType(ephemeral_name="ephemeral1")

     

       129
       -
       block_map['/dev/sdd'] = BlockDeviceType(ephemeral_name="ephemeral2")

     

       130
       -
       block_map['/dev/sde'] = BlockDeviceType(ephemeral_name="ephemeral3")

     

       131
       -
       

     

       132
       -
       common_args = dict(

     

       133
       -
               name=ami_name,

     

       134
       -
               description=description,

     

       135
       -
               architecture="x86_64",

     

       136
       -
               root_device_name=root_block,

     

       137
       -
               block_device_map=block_map,

     

       138
       -
               virtualization_type=virtualization_type,

     

       139
       -
               delete_root_volume_on_termination=True

     

       140
       -
               )

     

       141
       -
       if not args.hvm:

     

       142
       -
           common_args['kernel_id']=aki.id

     

       143
       -
       

     

       144
       -
       ami_id = m._conn.register_image(**common_args)

     

       145
       -
       

     

       146
       -
       print >> sys.stderr, "registered AMI {0}".format(ami_id)

     

       147
       -
       

     

       148
       -
       print >> sys.stderr, "sleeping a bit..."

     

       149
       -
       time.sleep(30)

     

       150
       -
       

     

       151
       -
       print >> sys.stderr, "setting image name..."

     

       152
       -
       m._conn.create_tags([ami_id], {'Name': ami_name})

     

       153
       -
       

     

       154
       -
       print >> sys.stderr, "making image public..."

     

       155
       -
       image = m._conn.get_all_images(image_ids=[ami_id])[0]

     

       156
       -
       image.set_launch_permissions(user_ids=[], group_names=["all"])

     

       157
       -
       

     

       158
       -
       # Do a test deployment to make sure that the AMI works.

     

       159
       -
       f = open("ebs-test.nix", "w")

     

       160
       -
       f.write(

     

       161
       -
           '''

     

       162
       -
           {{

     

       163
       -
             network.description = "NixOS EBS test";

     

       164
       -
       

     

       165
       -
             resources.ec2KeyPairs.keypair.accessKeyId = "lb-nixos";

     

       166
       -
             resources.ec2KeyPairs.keypair.region = "{0}";

     

       167
       -
       

     

       168
       -
             machine = {{ config, pkgs, resources, ... }}: {{

     

       169
       -
               deployment.targetEnv = "ec2";

     

       170
       -
               deployment.ec2.accessKeyId = "lb-nixos";

     

       171
       -
               deployment.ec2.region = "{0}";

     

       172
       -
               deployment.ec2.instanceType = "{2}";

     

       173
       -
               deployment.ec2.keyPair = resources.ec2KeyPairs.keypair.name;

     

       174
       -
               deployment.ec2.securityGroups = [ "public-ssh" ];

     

       175
       -
               deployment.ec2.ami = "{1}";

     

       176
       -
             }};

     

       177
       -
           }}

     

       178
       -
           '''.format(args.region, ami_id, instance_type))

     

       179
       -
       f.close()

     

       180
       -
       

     

       181
       -
       test_depl = db.create_deployment()

     

       182
       -
       test_depl.auto_response = "y"

     

       183
       -
       test_depl.name = "ebs-creator-test"

     

       184
       -
       test_depl.nix_exprs = [os.path.abspath("./ebs-test.nix")]

     

       185
       -
       test_depl.deploy(create_only=True)

     

       186
       -
       test_depl.machines['machine'].run_command("nixos-version")

     

       187
       -
       

     

       188
       -
       # Log the AMI ID.

     

       189
       -
       f = open("ec2-amis.nix".format(args.region, image_type), "w")

     

       190
       -
       f.write("{\n")

     

       191
       -
       

     

       192
       -
       for dest in [ 'us-east-1', 'us-west-1', 'us-west-2', 'eu-west-1', 'eu-central-1', 'ap-southeast-1', 'ap-southeast-2', 'ap-northeast-1', 'sa-east-1']:

     

       193
       -
           copy_image = None

     

       194
       -
           if args.region != dest:

     

       195
       -
               try:

     

       196
       -
                   print >> sys.stderr, "copying image from region {0} to {1}".format(args.region, dest)

     

       197
       -
                   conn = boto.ec2.connect_to_region(dest)

     

       198
       -
                   copy_image = conn.copy_image(args.region, ami_id, ami_name, description=None, client_token=None)

     

       199
       -
               except :

     

       200
       -
                   print >> sys.stderr, "FAILED!"

     

       201
       -
       

     

       202
       -
               # Log the AMI ID.

     

       203
       -
               if copy_image != None:

     

       204
       -
                   f.write('  "{0}"."{1}".{2} = "{3}";\n'.format(args.channel,dest,"hvm" if args.hvm else "ebs",copy_image.image_id))

     

       205
       -
           else:

     

       206
       -
               f.write('  "{0}"."{1}".{2} = "{3}";\n'.format(args.channel,args.region,"hvm" if args.hvm else "ebs",ami_id))

     

       207
       -
       

     

       208
       -
       

     

       209
       -
       f.write("}\n")

     

       210
       -
       f.close()

     

       211
       -
       

     

       212
       -
       if not args.keep:

     

       213
       -
           test_depl.logger.set_autoresponse("y")

     

       214
       -
           test_depl.destroy_resources()

     

       215
       -
           test_depl.delete()

     

       216
       -

-53

nixos/maintainers/scripts/ec2/create-s3-amis.sh

···

       1
       -
       #! /bin/sh -e

     

       2
       -
       

     

       3
       -
       export NIXOS_CONFIG=$(dirname $(readlink -f $0))/amazon-base-config.nix

     

       4
       -
       

     

       5
       -
       version=$(nix-instantiate --eval-only '<nixpkgs/nixos>' -A config.system.nixosVersion | sed s/'"'//g)

     

       6
       -
       echo "NixOS version is $version"

     

       7
       -
       

     

       8
       -
       buildAndUploadFor() {

     

       9
       -
           system="$1"

     

       10
       -
           arch="$2"

     

       11
       -
       

     

       12
       -
           echo "building $system image..."

     

       13
       -
           nix-build '<nixpkgs/nixos>' \

     

       14
       -
               -A config.system.build.amazonImage --argstr system "$system" -o ec2-ami

     

       15
       -
       

     

       16
       -
           ec2-bundle-image -i ./ec2-ami/nixos.img --user "$AWS_ACCOUNT" --arch "$arch" \

     

       17
       -
               -c "$EC2_CERT" -k "$EC2_PRIVATE_KEY"

     

       18
       -
       

     

       19
       -
           for region in eu-west-1; do

     

       20
       -
               echo "uploading $system image for $region..."

     

       21
       -
       

     

       22
       -
               name=nixos-$version-$arch-s3

     

       23
       -
               bucket="$(echo $name-$region | tr '[A-Z]_' '[a-z]-')"

     

       24
       -
       

     

       25
       -
               if [ "$region" = eu-west-1 ]; then s3location=EU;

     

       26
       -
               elif [ "$region" = us-east-1 ]; then s3location=US;

     

       27
       -
               else s3location="$region"

     

       28
       -
               fi

     

       29
       -
       

     

       30
       -
               ec2-upload-bundle -b "$bucket" -m /tmp/nixos.img.manifest.xml \

     

       31
       -
                   -a "$EC2_ACCESS_KEY" -s "$EC2_SECRET_KEY" --location "$s3location" \

     

       32
       -
                   --url http://s3.amazonaws.com

     

       33
       -
       

     

       34
       -
               kernel=$(ec2-describe-images -o amazon --filter "manifest-location=*pv-grub-hd0_1.04-$arch*" --region "$region" | cut -f 2)

     

       35
       -
               echo "using PV-GRUB kernel $kernel"

     

       36
       -
       

     

       37
       -
               ami=$(ec2-register "$bucket/nixos.img.manifest.xml" -n "$name" -d "NixOS $system r$revision" -O "$EC2_ACCESS_KEY" -W "$EC2_SECRET_KEY" \

     

       38
       -
                   --region "$region" --kernel "$kernel" | cut -f 2)

     

       39
       -
       

     

       40
       -
               echo "AMI ID is $ami"

     

       41
       -
       

     

       42
       -
               echo "  \"14.12\".\"$region\".s3 = \"$ami\";" >> ec2-amis.nix

     

       43
       -
       

     

       44
       -
               ec2-modify-image-attribute --region "$region" "$ami" -l -a all -O "$EC2_ACCESS_KEY" -W "$EC2_SECRET_KEY"

     

       45
       -
       

     

       46
       -
               for cp_region in us-east-1 us-west-1 us-west-2 eu-central-1 ap-southeast-1 ap-southeast-2 ap-northeast-1 sa-east-1; do

     

       47
       -
                 new_ami=$(aws ec2 copy-image --source-image-id $ami --source-region $region --region $cp_region --name "$name" | json ImageId)

     

       48
       -
                 echo "  \"14.12\".\"$cp_region\".s3 = \"$new_ami\";" >> ec2-amis.nix  

     

       49
       -
               done

     

       50
       -
           done

     

       51
       -
       }

     

       52
       -
       

     

       53
       -
       buildAndUploadFor x86_64-linux x86_64

-13

nixos/maintainers/scripts/ec2/ebs-creator.nix

···

       1
       -
       {

     

       2
       -
         network.description = "NixOS EBS creator";

     

       3
       -
       

     

       4
       -
         machine =

     

       5
       -
           { config, pkgs, resources, ... }:

     

       6
       -
           { deployment.targetEnv = "ec2";

     

       7
       -
             deployment.ec2.instanceType = "c3.large";

     

       8
       -
             deployment.ec2.securityGroups = [ "public-ssh" ];

     

       9
       -
             deployment.ec2.ebsBoot = false;

     

       10
       -
             deployment.ec2.keyPair = resources.ec2KeyPairs.keypair.name;

     

       11
       -
             environment.systemPackages = [ pkgs.parted ];

     

       12
       -
           };

     

       13
       -
       }

-3

nixos/modules/virtualisation/amazon-config.nix

···

       1
       -
       {

     

       2
       -
         imports = [ <nixpkgs/nixos/modules/virtualisation/amazon-image.nix> ];

     

       3
       -
       }

+47

nixos/modules/virtualisation/amazon-grow-partition.nix

···

       1
       +
       # This module automatically grows the root partition on Amazon EC2 HVM

     

       2
       +
       # instances. This allows an instance to be created with a bigger root

     

       3
       +
       # filesystem than provided by the AMI.

     

       4
       +
       

     

       5
       +
       { config, lib, pkgs, ... }:

     

       6
       +
       

     

       7
       +
       with lib;

     

       8
       +
       

     

       9
       +
       let

     

       10
       +
       

     

       11
       +
         growpart = pkgs.stdenv.mkDerivation {

     

       12
       +
           name = "growpart";

     

       13
       +
           src = pkgs.fetchurl {

     

       14
       +
             url = "https://launchpad.net/cloud-utils/trunk/0.27/+download/cloud-utils-0.27.tar.gz";

     

       15
       +
             sha256 = "16shlmg36lidp614km41y6qk3xccil02f5n3r4wf6d1zr5n4v8vd";

     

       16
       +
           };

     

       17
       +
           patches = [ ./growpart-util-linux-2.26.patch ];

     

       18
       +
           buildPhase = ''

     

       19
       +
             cp bin/growpart $out

     

       20
       +
             sed -i 's|awk|gawk|' $out

     

       21
       +
             sed -i 's|sed|gnused|' $out

     

       22
       +
           '';

     

       23
       +
           dontInstall = true;

     

       24
       +
           dontPatchShebangs = true;

     

       25
       +
         };

     

       26
       +
       

     

       27
       +
       in

     

       28
       +
       

     

       29
       +
       {

     

       30
       +
       

     

       31
       +
         config = mkIf config.ec2.hvm {

     

       32
       +
       

     

       33
       +
           boot.initrd.extraUtilsCommands = ''

     

       34
       +
             copy_bin_and_libs ${pkgs.gawk}/bin/gawk

     

       35
       +
             copy_bin_and_libs ${pkgs.gnused}/bin/sed

     

       36
       +
             copy_bin_and_libs ${pkgs.utillinux}/sbin/sfdisk

     

       37
       +
             cp -v ${growpart} $out/bin/growpart

     

       38
       +
             ln -s sed $out/bin/gnused

     

       39
       +
           '';

     

       40
       +
       

     

       41
       +
           boot.initrd.postDeviceCommands = ''

     

       42
       +
             [ -e /dev/xvda ] && [ -e /dev/xvda1 ] && TMPDIR=/run sh $(type -P growpart) /dev/xvda 1

     

       43
       +
           '';

     

       44
       +
       

     

       45
       +
         };

     

       46
       +
       

     

       47
       +
       }

+15 -82

nixos/modules/virtualisation/amazon-image.nix

···

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

       2
        
       

     

       3
        
       with lib;

     

       4
       -
       let

     

       5
       -
         cfg = config.ec2;

     

       6
       -
       in

     

       7
        
       {

     

       8
       -
         imports = [ ../profiles/headless.nix ./ec2-data.nix ];

     

       9
        
       

     

       10
        
         config = {

     

       11
       -
           system.build.amazonImage =

     

       12
       -
             pkgs.vmTools.runInLinuxVM (

     

       13
       -
               pkgs.runCommand "amazon-image"

     

       14
       -
                 { preVM =

     

       15
       -
                     ''

     

       16
       -
                       mkdir $out

     

       17
       -
                       diskImage=$out/nixos.img

     

       18
       -
                       ${pkgs.vmTools.qemu}/bin/qemu-img create -f raw $diskImage "8G"

     

       19
       -
                       mv closure xchg/

     

       20
       -
                     '';

     

       21
       -
                   buildInputs = [ pkgs.utillinux pkgs.perl ];

     

       22
       -
                   exportReferencesGraph =

     

       23
       -
                     [ "closure" config.system.build.toplevel ];

     

       24
       -
                 }

     

       25
       -
                 ''

     

       26
       -
                   ${if cfg.hvm then ''

     

       27
       -
                     # Create a single / partition.

     

       28
       -
                     ${pkgs.parted}/sbin/parted /dev/vda mklabel msdos

     

       29
       -
                     ${pkgs.parted}/sbin/parted /dev/vda -- mkpart primary ext2 1M -1s

     

       30
       -
                     . /sys/class/block/vda1/uevent

     

       31
       -
                     mknod /dev/vda1 b $MAJOR $MINOR

     

       32
        
       

     

       33
       -
                     # Create an empty filesystem and mount it.

     

       34
       -
                     ${pkgs.e2fsprogs}/sbin/mkfs.ext4 -L nixos /dev/vda1

     

       35
       -
                     ${pkgs.e2fsprogs}/sbin/tune2fs -c 0 -i 0 /dev/vda1

     

       36
       -
                     mkdir /mnt

     

       37
       -
                     mount /dev/vda1 /mnt

     

       38
       -
                   '' else ''

     

       39
       -
                     # Create an empty filesystem and mount it.

     

       40
       -
                     ${pkgs.e2fsprogs}/sbin/mkfs.ext4 -L nixos /dev/vda

     

       41
       -
                     ${pkgs.e2fsprogs}/sbin/tune2fs -c 0 -i 0 /dev/vda

     

       42
       -
                     mkdir /mnt

     

       43
       -
                     mount /dev/vda /mnt

     

       44
       -
                   ''}

     

       45
       -
       

     

       46
       -
                   # The initrd expects these directories to exist.

     

       47
       -
                   mkdir /mnt/dev /mnt/proc /mnt/sys

     

       48
       -
       

     

       49
       -
                   mount -o bind /proc /mnt/proc

     

       50
       -
                   mount -o bind /dev /mnt/dev

     

       51
       -
                   mount -o bind /sys /mnt/sys

     

       52
       -
       

     

       53
       -
                   # Copy all paths in the closure to the filesystem.

     

       54
       -
                   storePaths=$(perl ${pkgs.pathsFromGraph} /tmp/xchg/closure)

     

       55
       -
       

     

       56
       -
                   mkdir -p /mnt/nix/store

     

       57
       -
                   echo "copying everything (will take a while)..."

     

       58
       -
                   cp -prd $storePaths /mnt/nix/store/

     

       59
       -
       

     

       60
       -
                   # Register the paths in the Nix database.

     

       61
       -
                   printRegistration=1 perl ${pkgs.pathsFromGraph} /tmp/xchg/closure | \

     

       62
       -
                       chroot /mnt ${config.nix.package}/bin/nix-store --load-db --option build-users-group ""

     

       63
       -
       

     

       64
       -
                   # Create the system profile to allow nixos-rebuild to work.

     

       65
       -
                   chroot /mnt ${config.nix.package}/bin/nix-env --option build-users-group "" \

     

       66
       -
                       -p /nix/var/nix/profiles/system --set ${config.system.build.toplevel}

     

       67
       -
       

     

       68
       -
                   # `nixos-rebuild' requires an /etc/NIXOS.

     

       69
       -
                   mkdir -p /mnt/etc

     

       70
       -
                   touch /mnt/etc/NIXOS

     

       71
       -
       

     

       72
       -
                   # `switch-to-configuration' requires a /bin/sh

     

       73
       -
                   mkdir -p /mnt/bin

     

       74
       -
                   ln -s ${config.system.build.binsh}/bin/sh /mnt/bin/sh

     

       75
       -
       

     

       76
       -
                   # Install a configuration.nix.

     

       77
       -
                   mkdir -p /mnt/etc/nixos

     

       78
       -
                   cp ${./amazon-config.nix} /mnt/etc/nixos/configuration.nix

     

       79
       -
       

     

       80
       -
                   # Generate the GRUB menu.

     

       81
       -
                   ln -s vda /dev/xvda

     

       82
       -
                   chroot /mnt ${config.system.build.toplevel}/bin/switch-to-configuration boot

     

       83
       -
       

     

       84
       -
                   umount /mnt/proc /mnt/dev /mnt/sys

     

       85
       -
                   umount /mnt

     

       86
       -
                 ''

     

       87
       -
             );

     

       88
       -
       

     

       89
       -
           fileSystems."/".device = "/dev/disk/by-label/nixos";

     

       90
        
       

     

       91
        
           boot.initrd.kernelModules = [ "xen-blkfront" ];

     

       92
        
           boot.kernelModules = [ "xen-netfront" ];

     

       0
        
       
     

       93
        
       

     

       94
        
           # Prevent the nouveau kernel module from being loaded, as it

     

       95
        
           # interferes with the nvidia/nvidia-uvm modules needed for CUDA.

···

       1
       +
       # Configuration for Amazon EC2 instances. (Note that this file is a

     

       2
       +
       # misnomer - it should be "amazon-config.nix" or so, not

     

       3
       +
       # "amazon-image.nix", since it's used not only to build images but

     

       4
       +
       # also to reconfigure instances. However, we can't rename it because

     

       5
       +
       # existing "configuration.nix" files on EC2 instances refer to it.)

     

       6
       +
       

     

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

     

       8
        
       

     

       9
        
       with lib;

     

       10
       +
       

     

       11
       +
       let cfg = config.ec2; in

     

       12
       +
       

     

       13
        
       {

     

       14
       +
         imports = [ ../profiles/headless.nix ./ec2-data.nix ./amazon-grow-partition.nix ];

     

       15
        
       

     

       16
        
         config = {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       17
        
       

     

       18
       +
           fileSystems."/" = {

     

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

     

       20
       +
             autoResize = true;

     

       21
       +
           };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       22
        
       

     

       23
        
           boot.initrd.kernelModules = [ "xen-blkfront" ];

     

       24
        
           boot.kernelModules = [ "xen-netfront" ];

     

       25
       +
           boot.kernelParams = mkIf cfg.hvm [ "console=ttyS0" ];

     

       26
        
       

     

       27
        
           # Prevent the nouveau kernel module from being loaded, as it

     

       28
        
           # interferes with the nvidia/nvidia-uvm modules needed for CUDA.

+88

nixos/modules/virtualisation/growpart-util-linux-2.26.patch

···

       1
       +
       From 1895d10a7539d055a4e0206af1e7a9e5ea32a4f7 Mon Sep 17 00:00:00 2001

     

       2
       +
       From: Juerg Haefliger <juerg.haefliger@hp.com>

     

       3
       +
       Date: Wed, 25 Mar 2015 13:59:20 +0100

     

       4
       +
       Subject: [PATCH] Support new sfdisk version 2.26

     

       5
       +
       

     

       6
       +
       The sfdisk usage with version 2.26 changed. Specifically, the option

     

       7
       +
       --show-pt-geometry and functionality for CHS have been removed.

     

       8
       +
       Also, restoring a backup MBR now needs to be done using dd.

     

       9
       +
       ---

     

       10
       +
        bin/growpart | 28 ++++++++++------------------

     

       11
       +
        1 file changed, 10 insertions(+), 18 deletions(-)

     

       12
       +
       

     

       13
       +
       diff --git a/bin/growpart b/bin/growpart

     

       14
       +
       index 595c40b..d4c995b 100755

     

       15
       +
       --- a/bin/growpart

     

       16
       +
       +++ b/bin/growpart

     

       17
       +
       @@ -28,7 +28,6 @@ PART=""

     

       18
       +
        PT_UPDATE=false

     

       19
       +
        DRY_RUN=0

     

       20
       +
        

     

       21
       +
       -MBR_CHS=""

     

       22
       +
        MBR_BACKUP=""

     

       23
       +
        GPT_BACKUP=""

     

       24
       +
        _capture=""

     

       25
       +
       @@ -133,7 +132,8 @@ bad_Usage() {

     

       26
       +
        }

     

       27
       +
        

     

       28
       +
        mbr_restore() {

     

       29
       +
       -	sfdisk --no-reread "${DISK}" ${MBR_CHS} -I "${MBR_BACKUP}"

     

       30
       +
       +	dd if="${MBR_BACKUP}-${DISK#/dev/}-0x00000000.bak" of="${DISK}" bs=1 \

     

       31
       +
       +		conv=notrunc

     

       32
       +
        }

     

       33
       +
        

     

       34
       +
        sfdisk_worked_but_blkrrpart_failed() {

     

       35
       +
       @@ -148,34 +148,26 @@ sfdisk_worked_but_blkrrpart_failed() {

     

       36
       +
        

     

       37
       +
        mbr_resize() {

     

       38
       +
        	RESTORE_HUMAN="${TEMP_D}/recovery"

     

       39
       +
       -	MBR_BACKUP="${TEMP_D}/orig.save"

     

       40
       +
       +	MBR_BACKUP="${TEMP_D}/backup"

     

       41
       +
        

     

       42
       +
        	local change_out=${TEMP_D}/change.out

     

       43
       +
        	local dump_out=${TEMP_D}/dump.out

     

       44
       +
        	local new_out=${TEMP_D}/new.out

     

       45
       +
        	local dump_mod=${TEMP_D}/dump.mod

     

       46
       +
       -	local tmp="${TEMP_D}/tmp.out"

     

       47
       +
       -	local err="${TEMP_D}/err.out"

     

       48
       +
        

     

       49
       +
       -	local _devc cyl _w1 heads _w2 sectors _w3 tot dpart

     

       50
       +
       +	local tot dpart

     

       51
       +
        	local pt_start pt_size pt_end max_end new_size change_info

     

       52
       +
        

     

       53
       +
       -	# --show-pt-geometry outputs something like

     

       54
       +
       -	#     /dev/sda: 164352 cylinders, 4 heads, 32 sectors/track

     

       55
       +
       -	rqe sfd_geom sfdisk "${DISK}" --show-pt-geometry >"${tmp}" &&

     

       56
       +
       -		read _devc cyl _w1 heads _w2 sectors _w3 <"${tmp}" &&

     

       57
       +
       -		MBR_CHS="-C ${cyl} -H ${heads} -S ${sectors}" ||

     

       58
       +
       -		fail "failed to get CHS from ${DISK}"

     

       59
       +
       +	tot=$(sfdisk --list "${DISK}" | awk '{ print $(NF-1) ; exit }') ||

     

       60
       +
       +		fail "failed to get total number of sectors from ${DISK}"

     

       61
       +
        

     

       62
       +
       -	tot=$((${cyl}*${heads}*${sectors}))

     

       63
       +
       +	debug 1 "total number of sectors of ${DISK} is ${tot}"

     

       64
       +
        

     

       65
       +
       -	debug 1 "geometry is ${MBR_CHS}. total size=${tot}"

     

       66
       +
       -	rqe sfd_dump sfdisk ${MBR_CHS} --unit=S --dump "${DISK}" \

     

       67
       +
       +	rqe sfd_dump sfdisk --dump "${DISK}" \

     

       68
       +
        		>"${dump_out}" ||

     

       69
       +
        		fail "failed to dump sfdisk info for ${DISK}"

     

       70
       +
       -

     

       71
       +
        	{

     

       72
       +
       -		echo "## sfdisk ${MBR_CHS} --unit=S --dump ${DISK}"

     

       73
       +
       +		echo "## sfdisk --dump ${DISK}"

     

       74
       +
        		cat "${dump_out}"

     

       75
       +
        	}  >"${RESTORE_HUMAN}"

     

       76
       +
        	[ $? -eq 0 ] || fail "failed to save sfdisk -d output"

     

       77
       +
       @@ -237,7 +229,7 @@ mbr_resize() {

     

       78
       +
        		exit 0

     

       79
       +
        	fi

     

       80
       +
        

     

       81
       +
       -	LANG=C sfdisk --no-reread "${DISK}" ${MBR_CHS} --force \

     

       82
       +
       +	LANG=C sfdisk --no-reread "${DISK}" --force \

     

       83
       +
        		-O "${MBR_BACKUP}" <"${new_out}" >"${change_out}" 2>&1

     

       84
       +
        	ret=$?

     

       85
       +
        	[ $ret -eq 0 ] || RESTORE_FUNC="mbr_restore"

     

       86
       +
       -- 

     

       87
       +
       2.1.4

     

       88
       +