···

       
9
       
 
       


     

       
10
       
 
       
let

     

       
11
       
 
       
  # A testScript fragment that prepares a disk with some empty, unpartitioned

     

       
12
       
-
       
  # space. and uses it to boot the test with. Takes a single argument `machine`

     

       
13
       
-
       
  # from which the diskImage is extracted.

     

       
14
       
-
       
  useDiskImage = machine: ''

     

       
15
       
-
       
    import os

     

       
16
       
-
       
    import shutil

     

       
17
       
-
       
    import subprocess

     

       
18
       
-
       
    import tempfile

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
19
       
 
       


     

       
20
       
-
       
    tmp_disk_image = tempfile.NamedTemporaryFile()

     

       
21
       
 
       


     

       
22
       
-
       
    shutil.copyfile("${machine.system.build.diskImage}/nixos.img", tmp_disk_image.name)

     

       
23
       
 
       


     

       
24
       
-
       
    subprocess.run([

     

       
25
       
-
       
      "${machine.virtualisation.qemu.package}/bin/qemu-img",

     

       
26
       
-
       
      "resize",

     

       
27
       
-
       
      "-f",

     

       
28
       
-
       
      "raw",

     

       
29
       
-
       
      tmp_disk_image.name,

     

       
30
       
-
       
      "+32M",

     

       
31
       
-
       
    ])

     

       
32
       
 
       


     

       
33
       
-
       
    # Set NIX_DISK_IMAGE so that the qemu script finds the right disk image.

     

       
34
       
-
       
    os.environ['NIX_DISK_IMAGE'] = tmp_disk_image.name

     

       
35
       
-
       
  '';

     

       
36
       
 
       


     

       
37
       
 
       
  common =

     

       
38
       
 
       
    {

     
···

       
98
       
 
       
    testScript =

     

       
99
       
 
       
      { nodes, ... }:

     

       
100
       
 
       
      ''

     

       
101
       
-
       
        ${useDiskImage nodes.machine}

     

       
102
       
 
       


     

       
103
       
 
       
        machine.start()

     

       
104
       
 
       
        machine.wait_for_unit("multi-user.target")

     
···

       
128
       
 
       
    testScript =

     

       
129
       
 
       
      { nodes, ... }:

     

       
130
       
 
       
      ''

     

       
131
       
-
       
        ${useDiskImage nodes.machine}

     

       
132
       
 
       


     

       
133
       
 
       
        machine.start()

     

       
134
       
 
       
        machine.wait_for_unit("multi-user.target")

     
···

       
196
       
 
       
    testScript =

     

       
197
       
 
       
      { nodes, ... }:

     

       
198
       
 
       
      ''

     

       
199
       
-
       
        ${useDiskImage nodes.machine}

     

       
200
       
 
       


     

       
201
       
 
       
        machine.start()

     

       
202
       
 
       
        machine.wait_for_unit("multi-user.target")

     

···

       
9
       
 
       


     

       
10
       
 
       
let

     

       
11
       
 
       
  # A testScript fragment that prepares a disk with some empty, unpartitioned

     

       
12
       
+
       
  # space. and uses it to boot the test with.

     

       
13
       
+
       
  # Takes two arguments, `machine` from which the diskImage is extracted,

     

       
14
       
+
       
  # as well an optional `sizeDiff` (defaulting to +32M), describing how should

     

       
15
       
+
       
  # be resized.

     

       
16
       
+
       
  useDiskImage =

     

       
17
       
+
       
    {

     

       
18
       
+
       
      machine,

     

       
19
       
+
       
      sizeDiff ? "+32M",

     

       
20
       
+
       
    }:

     

       
21
       
+
       
    ''

     

       
22
       
+
       
      import os

     

       
23
       
+
       
      import shutil

     

       
24
       
+
       
      import subprocess

     

       
25
       
+
       
      import tempfile

     

       
26
       
 
       


     

       
27
       
+
       
      tmp_disk_image = tempfile.NamedTemporaryFile()

     

       
28
       
 
       


     

       
29
       
+
       
      shutil.copyfile("${machine.system.build.diskImage}/nixos.img", tmp_disk_image.name)

     

       
30
       
 
       


     

       
31
       
+
       
      subprocess.run([

     

       
32
       
+
       
        "${machine.virtualisation.qemu.package}/bin/qemu-img",

     

       
33
       
+
       
        "resize",

     

       
34
       
+
       
        "-f",

     

       
35
       
+
       
        "raw",

     

       
36
       
+
       
        tmp_disk_image.name,

     

       
37
       
+
       
        "${sizeDiff}",

     

       
38
       
+
       
      ])

     

       
39
       
 
       


     

       
40
       
+
       
      # Set NIX_DISK_IMAGE so that the qemu script finds the right disk image.

     

       
41
       
+
       
      os.environ['NIX_DISK_IMAGE'] = tmp_disk_image.name

     

       
42
       
+
       
    '';

     

       
43
       
 
       


     

       
44
       
 
       
  common =

     

       
45
       
 
       
    {

     
···

       
105
       
 
       
    testScript =

     

       
106
       
 
       
      { nodes, ... }:

     

       
107
       
 
       
      ''

     

       
108
       
+
       
        ${useDiskImage { inherit (nodes) machine; }}

     

       
109
       
 
       


     

       
110
       
 
       
        machine.start()

     

       
111
       
 
       
        machine.wait_for_unit("multi-user.target")

     
···

       
135
       
 
       
    testScript =

     

       
136
       
 
       
      { nodes, ... }:

     

       
137
       
 
       
      ''

     

       
138
       
+
       
        ${useDiskImage { inherit (nodes) machine; }}

     

       
139
       
 
       


     

       
140
       
 
       
        machine.start()

     

       
141
       
 
       
        machine.wait_for_unit("multi-user.target")

     
···

       
203
       
 
       
    testScript =

     

       
204
       
 
       
      { nodes, ... }:

     

       
205
       
 
       
      ''

     

       
206
       
+
       
        ${useDiskImage { inherit (nodes) machine; }}

     

       
207
       
 
       


     

       
208
       
 
       
        machine.start()

     

       
209
       
 
       
        machine.wait_for_unit("multi-user.target")