···

       
159
       
159
       
 
       
`execute`

     

       
160
       
160
       
 
       


     

       
161
       
161
       
 
       
:   Execute a shell command, returning a list `(status, stdout)`.

     

       
162
       
162
       
+
       
    Takes an optional parameter `check_return` that defaults to `True`.

     

       
163
       
163
       
+
       
    Setting this parameter to `False` will not check for the return code

     

       
164
       
164
       
+
       
    and return -1 instead. This can be used for commands that shut down

     

       
165
       
165
       
+
       
    the VM and would therefore break the pipe that would be used for

     

       
166
       
166
       
+
       
    retrieving the return code.

     

       
162
       
167
       
 
       


     

       
163
       
168
       
 
       
`succeed`

     

       
164
       
169
       
 
       


     

···

       
266
       
266
       
 
       
      <listitem>

     

       
267
       
267
       
 
       
        <para>

     

       
268
       
268
       
 
       
          Execute a shell command, returning a list

     

       
269
       
269
       
-
       
          <literal>(status, stdout)</literal>.

     

       
269
       
269
       
+
       
          <literal>(status, stdout)</literal>. Takes an optional

     

       
270
       
270
       
+
       
          parameter <literal>check_return</literal> that defaults to

     

       
271
       
271
       
+
       
          <literal>True</literal>. Setting this parameter to

     

       
272
       
272
       
+
       
          <literal>False</literal> will not check for the return code

     

       
273
       
273
       
+
       
          and return -1 instead. This can be used for commands that shut

     

       
274
       
274
       
+
       
          down the VM and would therefore break the pipe that would be

     

       
275
       
275
       
+
       
          used for retrieving the return code.

     

       
270
       
276
       
 
       
        </para>

     

       
271
       
277
       
 
       
      </listitem>

     

       
272
       
278
       
 
       
    </varlistentry>

     

···

       
581
       
581
       
 
       
                    + "'{}' but it is in state ‘{}’".format(require_state, state)

     

       
582
       
582
       
 
       
                )

     

       
583
       
583
       
 
       


     

       
584
       
584
       
-
       
    def execute(self, command: str) -> Tuple[int, str]:

     

       
584
       
584
       
+
       
    def _next_newline_closed_block_from_shell(self) -> str:

     

       
585
       
585
       
+
       
        assert self.shell

     

       
586
       
586
       
+
       
        output_buffer = []

     

       
587
       
587
       
+
       
        while True:

     

       
588
       
588
       
+
       
            # This receives up to 4096 bytes from the socket

     

       
589
       
589
       
+
       
            chunk = self.shell.recv(4096)

     

       
590
       
590
       
+
       
            if not chunk:

     

       
591
       
591
       
+
       
                # Probably a broken pipe, return the output we have

     

       
592
       
592
       
+
       
                break

     

       
593
       
593
       
+
       


     

       
594
       
594
       
+
       
            decoded = chunk.decode()

     

       
595
       
595
       
+
       
            output_buffer += [decoded]

     

       
596
       
596
       
+
       
            if decoded[-1] == "\n":

     

       
597
       
597
       
+
       
                break

     

       
598
       
598
       
+
       
        return "".join(output_buffer)

     

       
599
       
599
       
+
       


     

       
600
       
600
       
+
       
    def execute(self, command: str, check_return: bool = True) -> Tuple[int, str]:

     

       
585
       
601
       
 
       
        self.connect()

     

       
586
       
602
       
 
       


     

       
587
       
587
       
-
       
        out_command = "( set -euo pipefail; {} ); echo '|!=EOF' $?\n".format(command)

     

       
603
       
603
       
+
       
        out_command = f"( set -euo pipefail; {command} ) | (base64 --wrap 0; echo)\n"

     

       
588
       
604
       
 
       
        assert self.shell

     

       
589
       
605
       
 
       
        self.shell.send(out_command.encode())

     

       
590
       
606
       
 
       


     

       
591
       
591
       
-
       
        output = ""

     

       
592
       
592
       
-
       
        status_code_pattern = re.compile(r"(.*)\|\!=EOF\s+(\d+)")

     

       
607
       
607
       
+
       
        # Get the output

     

       
608
       
608
       
+
       
        output = base64.b64decode(self._next_newline_closed_block_from_shell())

     

       
593
       
609
       
 
       


     

       
594
       
594
       
-
       
        while True:

     

       
595
       
595
       
-
       
            chunk = self.shell.recv(4096).decode(errors="ignore")

     

       
596
       
596
       
-
       
            match = status_code_pattern.match(chunk)

     

       
597
       
597
       
-
       
            if match:

     

       
598
       
598
       
-
       
                output += match[1]

     

       
599
       
599
       
-
       
                status_code = int(match[2])

     

       
600
       
600
       
-
       
                return (status_code, output)

     

       
601
       
601
       
-
       
            output += chunk

     

       
610
       
610
       
+
       
        if not check_return:

     

       
611
       
611
       
+
       
            return (-1, output.decode())

     

       
612
       
612
       
+
       


     

       
613
       
613
       
+
       
        # Get the return code

     

       
614
       
614
       
+
       
        self.shell.send("echo ${PIPESTATUS[0]}\n".encode())

     

       
615
       
615
       
+
       
        rc = int(self._next_newline_closed_block_from_shell().strip())

     

       
616
       
616
       
+
       


     

       
617
       
617
       
+
       
        return (rc, output.decode())

     

       
602
       
618
       
 
       


     

       
603
       
619
       
 
       
    def shell_interact(self) -> None:

     

       
604
       
620
       
 
       
        """Allows you to interact with the guest shell

     

···

       
95
       
95
       
 
       
          "mkswap /dev/vda1 -L swap",

     

       
96
       
96
       
 
       
          # Install onto /mnt

     

       
97
       
97
       
 
       
          "nix-store --load-db < ${pkgs.closureInfo {rootPaths = [installedSystem];}}/registration",

     

       
98
       
98
       
-
       
          "nixos-install --root /mnt --system ${installedSystem} --no-root-passwd",

     

       
98
       
98
       
+
       
          "nixos-install --root /mnt --system ${installedSystem} --no-root-passwd --no-channel-copy >&2",

     

       
99
       
99
       
 
       
      )

     

       
100
       
100
       
 
       
      machine.shutdown()

     

       
101
       
101
       
 
       


     
···

       
110
       
110
       
 
       
      )

     

       
111
       
111
       
 
       


     

       
112
       
112
       
 
       
      # Hibernate machine

     

       
113
       
113
       
-
       
      hibernate.succeed("systemctl hibernate &")

     

       
113
       
113
       
+
       
      hibernate.execute("systemctl hibernate &", check_return=False)

     

       
114
       
114
       
 
       
      hibernate.wait_for_shutdown()

     

       
115
       
115
       
 
       


     

       
116
       
116
       
 
       
      # Restore machine from hibernation, validate our ramfs file is there.

     

···

       
18
       
18
       
 
       
  testScript =

     

       
19
       
19
       
 
       
    ''

     

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

     

       
21
       
21
       
-
       
      machine.execute("systemctl kexec &")

     

       
21
       
21
       
+
       
      machine.execute("systemctl kexec &", check_return=False)

     

       
22
       
22
       
 
       
      machine.connected = False

     

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

     

       
24
       
24
       
 
       
    '';

     

···

       
392
       
392
       
 
       
        machine.succeed("touch /testpath")

     

       
393
       
393
       
 
       
        machine.wait_until_succeeds("test -f /testpath-modified")

     

       
394
       
394
       
 
       


     

       
395
       
395
       
-
       
        machine.succeed("rm /testpath /testpath-modified")

     

       
395
       
395
       
+
       
        machine.succeed("rm /testpath")

     

       
396
       
396
       
+
       
        machine.succeed("rm /testpath-modified")

     

       
396
       
397
       
 
       
        switch_to_specialisation("with-path-modified")

     

       
397
       
398
       
 
       


     

       
398
       
399
       
 
       
        machine.succeed("touch /testpath")