···

       
3
       
 
       
from queue import Queue, Empty

     

       
4
       
 
       
from typing import Tuple, Any, Callable, Dict, Iterator, Optional, List, Iterable

     

       
5
       
 
       
from xml.sax.saxutils import XMLGenerator

     

       
0
       
 
       

     

       
6
       
 
       
import queue

     

       
7
       
 
       
import io

     

       
8
       
 
       
import _thread

     
···

       
151
       
 
       
        self.xml.startDocument()

     

       
152
       
 
       
        self.xml.startElement("logfile", attrs={})

     

       
153
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
154
       
 
       
    def close(self) -> None:

     

       
155
       
 
       
        self.xml.endElement("logfile")

     

       
156
       
 
       
        self.xml.endDocument()

     
···

       
174
       
 
       
        self.drain_log_queue()

     

       
175
       
 
       
        self.log_line(message, attributes)

     

       
176
       
 
       


     

       
177
       
-
       
    def enqueue(self, message: Dict[str, str]) -> None:

     

       
178
       
-
       
        self.queue.put(message)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
179
       
 
       


     

       
180
       
 
       
    def drain_log_queue(self) -> None:

     

       
181
       
 
       
        try:

     

       
182
       
 
       
            while True:

     

       
183
       
 
       
                item = self.queue.get_nowait()

     

       
184
       
-
       
                attributes = {"machine": item["machine"], "type": "serial"}

     

       
185
       
-
       
                self.log_line(self.sanitise(item["msg"]), attributes)

     

       
0
       
 
       

     

       
186
       
 
       
        except Empty:

     

       
187
       
 
       
            pass

     

       
188
       
 
       


     
···

       
327
       
 
       
    def log(self, msg: str) -> None:

     

       
328
       
 
       
        self.logger.log(msg, {"machine": self.name})

     

       
329
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
330
       
 
       
    def nested(self, msg: str, attrs: Dict[str, str] = {}) -> _GeneratorContextManager:

     

       
331
       
 
       
        my_attrs = {"machine": self.name}

     

       
332
       
 
       
        my_attrs.update(attrs)

     
···

       
784
       
 
       
                # Ignore undecodable bytes that may occur in boot menus

     

       
785
       
 
       
                line = _line.decode(errors="ignore").replace("\r", "").rstrip()

     

       
786
       
 
       
                self.last_lines.put(line)

     

       
787
       
-
       
                eprint("{} # {}".format(self.name, line))

     

       
788
       
-
       
                self.logger.enqueue({"msg": line, "machine": self.name})

     

       
789
       
 
       


     

       
790
       
 
       
        _thread.start_new_thread(process_serial_output, ())

     

       
791
       
 
       


     
···

       
925
       
 
       
    for machine in machines:

     

       
926
       
 
       
        if machine.is_up():

     

       
927
       
 
       
            machine.execute("sync")

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
928
       
 
       


     

       
929
       
 
       


     

       
930
       
 
       
@contextmanager

     

···

       
3
       
 
       
from queue import Queue, Empty

     

       
4
       
 
       
from typing import Tuple, Any, Callable, Dict, Iterator, Optional, List, Iterable

     

       
5
       
 
       
from xml.sax.saxutils import XMLGenerator

     

       
6
       
+
       
from colorama import Style

     

       
7
       
 
       
import queue

     

       
8
       
 
       
import io

     

       
9
       
 
       
import _thread

     
···

       
152
       
 
       
        self.xml.startDocument()

     

       
153
       
 
       
        self.xml.startElement("logfile", attrs={})

     

       
154
       
 
       


     

       
155
       
+
       
        self._print_serial_logs = True

     

       
156
       
+
       


     

       
157
       
 
       
    def close(self) -> None:

     

       
158
       
 
       
        self.xml.endElement("logfile")

     

       
159
       
 
       
        self.xml.endDocument()

     
···

       
177
       
 
       
        self.drain_log_queue()

     

       
178
       
 
       
        self.log_line(message, attributes)

     

       
179
       
 
       


     

       
180
       
+
       
    def log_serial(self, message: str, machine: str) -> None:

     

       
181
       
+
       
        self.enqueue({"msg": message, "machine": machine, "type": "serial"})

     

       
182
       
+
       
        if self._print_serial_logs:

     

       
183
       
+
       
            eprint(Style.DIM + "{} # {}".format(machine, message) + Style.RESET_ALL)

     

       
184
       
+
       


     

       
185
       
+
       
    def enqueue(self, item: Dict[str, str]) -> None:

     

       
186
       
+
       
        self.queue.put(item)

     

       
187
       
 
       


     

       
188
       
 
       
    def drain_log_queue(self) -> None:

     

       
189
       
 
       
        try:

     

       
190
       
 
       
            while True:

     

       
191
       
 
       
                item = self.queue.get_nowait()

     

       
192
       
+
       
                msg = self.sanitise(item["msg"])

     

       
193
       
+
       
                del item["msg"]

     

       
194
       
+
       
                self.log_line(msg, item)

     

       
195
       
 
       
        except Empty:

     

       
196
       
 
       
            pass

     

       
197
       
 
       


     
···

       
336
       
 
       
    def log(self, msg: str) -> None:

     

       
337
       
 
       
        self.logger.log(msg, {"machine": self.name})

     

       
338
       
 
       


     

       
339
       
+
       
    def log_serial(self, msg: str) -> None:

     

       
340
       
+
       
        self.logger.log_serial(msg, self.name)

     

       
341
       
+
       


     

       
342
       
 
       
    def nested(self, msg: str, attrs: Dict[str, str] = {}) -> _GeneratorContextManager:

     

       
343
       
 
       
        my_attrs = {"machine": self.name}

     

       
344
       
 
       
        my_attrs.update(attrs)

     
···

       
796
       
 
       
                # Ignore undecodable bytes that may occur in boot menus

     

       
797
       
 
       
                line = _line.decode(errors="ignore").replace("\r", "").rstrip()

     

       
798
       
 
       
                self.last_lines.put(line)

     

       
799
       
+
       
                self.log_serial(line)

     

       
0
       
 
       

     

       
800
       
 
       


     

       
801
       
 
       
        _thread.start_new_thread(process_serial_output, ())

     

       
802
       
 
       


     
···

       
936
       
 
       
    for machine in machines:

     

       
937
       
 
       
        if machine.is_up():

     

       
938
       
 
       
            machine.execute("sync")

     

       
939
       
+
       


     

       
940
       
+
       


     

       
941
       
+
       
def serial_stdout_on() -> None:

     

       
942
       
+
       
    global log

     

       
943
       
+
       
    log._print_serial_logs = True

     

       
944
       
+
       


     

       
945
       
+
       


     

       
946
       
+
       
def serial_stdout_off() -> None:

     

       
947
       
+
       
    global log

     

       
948
       
+
       
    log._print_serial_logs = False

     

       
949
       
 
       


     

       
950
       
 
       


     

       
951
       
 
       
@contextmanager

     

···

       
25
       
 
       
      name = "nixos-test-driver";

     

       
26
       
 
       


     

       
27
       
 
       
      nativeBuildInputs = [ makeWrapper ];

     

       
28
       
-
       
      buildInputs = [ (python3.withPackages (p: [ p.ptpython ])) ];

     

       
29
       
 
       
      checkInputs = with python3Packages; [ pylint black mypy ];

     

       
30
       
 
       


     

       
31
       
 
       
      dontUnpack = true;

     

···

       
25
       
 
       
      name = "nixos-test-driver";

     

       
26
       
 
       


     

       
27
       
 
       
      nativeBuildInputs = [ makeWrapper ];

     

       
28
       
+
       
      buildInputs = [ (python3.withPackages (p: [ p.ptpython p.colorama ])) ];

     

       
29
       
 
       
      checkInputs = with python3Packages; [ pylint black mypy ];

     

       
30
       
 
       


     

       
31
       
 
       
      dontUnpack = true;