commit 29db54c373ec765b43d15b1b8f3d7a73075bea9b · pyrox.dev/nixpkgs

+33

nixos/doc/manual/development/running-nixos-tests-interactively.section.md

···

       24
       24
        
       you to inspect the state of the VMs after the test (e.g. to debug the

     

       25
       25
        
       test script).

     

       26
       26
        
       

     

       27
       27
       +
       ## Shell access in interactive mode {#sec-nixos-test-shell-access}

     

       28
       28
       +
       

     

       29
       29
       +
       The function `<yourmachine>.shell_interact()` grants access to a shell running

     

       30
       30
       +
       inside a virtual machine. To use it, replace `<yourmachine>` with the name of a

     

       31
       31
       +
       virtual machine defined in the test, for example: `machine.shell_interact()`.

     

       32
       32
       +
       Keep in mind that this shell may not display everything correctly as it is

     

       33
       33
       +
       running within an interactive Python REPL, and logging output from the virtual

     

       34
       34
       +
       machine may overwrite input and output from the guest shell:

     

       35
       35
       +
       

     

       36
       36
       +
       ```py

     

       37
       37
       +
       >>> machine.shell_interact()

     

       38
       38
       +
       machine: Terminal is ready (there is no initial prompt):

     

       39
       39
       +
       $ hostname

     

       40
       40
       +
       machine

     

       41
       41
       +
       ```

     

       42
       42
       +
       

     

       43
       43
       +
       As an alternative, you can proxy the guest shell to a local TCP server by first

     

       44
       44
       +
       starting a TCP server in a terminal using the command:

     

       45
       45
       +
       

     

       46
       46
       +
       ```ShellSession

     

       47
       47
       +
       $ socat 'READLINE,PROMPT=$ ' tcp-listen:4444,reuseaddr`

     

       48
       48
       +
       ```

     

       49
       49
       +
       

     

       50
       50
       +
       In the terminal where the test driver is running, connect to this server by

     

       51
       51
       +
       using:

     

       52
       52
       +
       

     

       53
       53
       +
       ```py

     

       54
       54
       +
       >>> machine.shell_interact("tcp:127.0.0.1:4444")

     

       55
       55
       +
       ```

     

       56
       56
       +
       

     

       57
       57
       +
       Once the connection is established, you can enter commands in the socat terminal

     

       58
       58
       +
       where socat is running.

     

       59
       59
       +
       

     

       27
       60
        
       ## Reuse VM state {#sec-nixos-test-reuse-vm-state}

     

       28
       61
        
       

     

       29
       62
        
       You can re-use the VM states coming from a previous run by setting the

+40

nixos/doc/manual/from_md/development/running-nixos-tests-interactively.section.xml

···

       25
       25
        
           completion. This allows you to inspect the state of the VMs after

     

       26
       26
        
           the test (e.g. to debug the test script).

     

       27
       27
        
         </para>

     

       28
       28
       +
         <section xml:id="sec-nixos-test-shell-access">

     

       29
       29
       +
           <title>Shell access in interactive mode</title>

     

       30
       30
       +
           <para>

     

       31
       31
       +
             The function

     

       32
       32
       +
             <literal>&lt;yourmachine&gt;.shell_interact()</literal> grants

     

       33
       33
       +
             access to a shell running inside a virtual machine. To use it,

     

       34
       34
       +
             replace <literal>&lt;yourmachine&gt;</literal> with the name of a

     

       35
       35
       +
             virtual machine defined in the test, for example:

     

       36
       36
       +
             <literal>machine.shell_interact()</literal>. Keep in mind that

     

       37
       37
       +
             this shell may not display everything correctly as it is running

     

       38
       38
       +
             within an interactive Python REPL, and logging output from the

     

       39
       39
       +
             virtual machine may overwrite input and output from the guest

     

       40
       40
       +
             shell:

     

       41
       41
       +
           </para>

     

       42
       42
       +
           <programlisting language="python">

     

       43
       43
       +
       &gt;&gt;&gt; machine.shell_interact()

     

       44
       44
       +
       machine: Terminal is ready (there is no initial prompt):

     

       45
       45
       +
       $ hostname

     

       46
       46
       +
       machine

     

       47
       47
       +
       </programlisting>

     

       48
       48
       +
           <para>

     

       49
       49
       +
             As an alternative, you can proxy the guest shell to a local TCP

     

       50
       50
       +
             server by first starting a TCP server in a terminal using the

     

       51
       51
       +
             command:

     

       52
       52
       +
           </para>

     

       53
       53
       +
           <programlisting>

     

       54
       54
       +
       $ socat 'READLINE,PROMPT=$ ' tcp-listen:4444,reuseaddr`

     

       55
       55
       +
       </programlisting>

     

       56
       56
       +
           <para>

     

       57
       57
       +
             In the terminal where the test driver is running, connect to this

     

       58
       58
       +
             server by using:

     

       59
       59
       +
           </para>

     

       60
       60
       +
           <programlisting language="python">

     

       61
       61
       +
       &gt;&gt;&gt; machine.shell_interact(&quot;tcp:127.0.0.1:4444&quot;)

     

       62
       62
       +
       </programlisting>

     

       63
       63
       +
           <para>

     

       64
       64
       +
             Once the connection is established, you can enter commands in the

     

       65
       65
       +
             socat terminal where socat is running.

     

       66
       66
       +
           </para>

     

       67
       67
       +
         </section>

     

       28
       68
        
         <section xml:id="sec-nixos-test-reuse-vm-state">

     

       29
       69
        
           <title>Reuse VM state</title>

     

       30
       70
        
           <para>

+17 -8

nixos/lib/test-driver/test_driver/machine.py

···

       549
       549
        
       

     

       550
       550
        
               return (rc, output.decode())

     

       551
       551
        
       

     

       552
       552
       -
           def shell_interact(self) -> None:

     

       553
       553
       -
               """Allows you to interact with the guest shell

     

       552
       552
       +
           def shell_interact(self, address: Optional[str] = None) -> None:

     

       553
       553
       +
               """Allows you to interact with the guest shell for debugging purposes.

     

       554
       554
        
       

     

       555
       555
       -
               Should only be used during test development, not in the production test."""

     

       555
       555
       +
               @address string passed to socat that will be connected to the guest shell.

     

       556
       556
       +
               Check the `Running Tests interactivly` chapter of NixOS manual for an example.

     

       557
       557
       +
               """

     

       556
       558
        
               self.connect()

     

       557
       557
       -
               self.log("Terminal is ready (there is no initial prompt):")

     

       559
       559
       +
       

     

       560
       560
       +
               if address is None:

     

       561
       561
       +
                   address = "READLINE,prompt=$ "

     

       562
       562
       +
                   self.log("Terminal is ready (there is no initial prompt):")

     

       558
       563
        
       

     

       559
       564
        
               assert self.shell

     

       560
       560
       -
               subprocess.run(

     

       561
       561
       -
                   ["socat", "READLINE,prompt=$ ", f"FD:{self.shell.fileno()}"],

     

       562
       562
       -
                   pass_fds=[self.shell.fileno()],

     

       563
       563
       -
               )

     

       565
       565
       +
               try:

     

       566
       566
       +
                   subprocess.run(

     

       567
       567
       +
                       ["socat", address, f"FD:{self.shell.fileno()}"],

     

       568
       568
       +
                       pass_fds=[self.shell.fileno()],

     

       569
       569
       +
                   )

     

       570
       570
       +
                   # allow users to cancel this command without breaking the test

     

       571
       571
       +
               except KeyboardInterrupt:

     

       572
       572
       +
                   pass

     

       564
       573
        
       

     

       565
       574
        
           def console_interact(self) -> None:

     

       566
       575
        
               """Allows you to interact with QEMU's stdin