commit a37d157601e57a1fcbf1803f92922c2c9bb73611 · pyrox.dev/nixpkgs

+27 -6

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

···

       3
       3
        
       from queue import Queue, Empty

     

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

     

       5
       5
        
       from xml.sax.saxutils import XMLGenerator

     

       6
       6
       +
       from colorama import Style

     

       6
       7
        
       import queue

     

       7
       8
        
       import io

     

       8
       9
        
       import _thread

     
···

       151
       152
        
               self.xml.startDocument()

     

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

     

       153
       154
        
       

     

       155
       155
       +
               self._print_serial_logs = True

     

       156
       156
       +
       

     

       154
       157
        
           def close(self) -> None:

     

       155
       158
        
               self.xml.endElement("logfile")

     

       156
       159
        
               self.xml.endDocument()

     
···

       174
       177
        
               self.drain_log_queue()

     

       175
       178
        
               self.log_line(message, attributes)

     

       176
       179
        
       

     

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

     

       178
       178
       -
               self.queue.put(message)

     

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

     

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

     

       182
       182
       +
               if self._print_serial_logs:

     

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

     

       184
       184
       +
       

     

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

     

       186
       186
       +
               self.queue.put(item)

     

       179
       187
        
       

     

       180
       188
        
           def drain_log_queue(self) -> None:

     

       181
       189
        
               try:

     

       182
       190
        
                   while True:

     

       183
       191
        
                       item = self.queue.get_nowait()

     

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

     

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

     

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

     

       193
       193
       +
                       del item["msg"]

     

       194
       194
       +
                       self.log_line(msg, item)

     

       186
       195
        
               except Empty:

     

       187
       196
        
                   pass

     

       188
       197
        
       

     
···

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

     

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

     

       329
       338
        
       

     

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

     

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

     

       341
       341
       +
       

     

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

     

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

     

       332
       344
        
               my_attrs.update(attrs)

     
···

       784
       796
        
                       # Ignore undecodable bytes that may occur in boot menus

     

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

     

       786
       798
        
                       self.last_lines.put(line)

     

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

     

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

     

       799
       799
       +
                       self.log_serial(line)

     

       789
       800
        
       

     

       790
       801
        
               _thread.start_new_thread(process_serial_output, ())

     

       791
       802
        
       

     
···

       925
       936
        
           for machine in machines:

     

       926
       937
        
               if machine.is_up():

     

       927
       938
        
                   machine.execute("sync")

     

       939
       939
       +
       

     

       940
       940
       +
       

     

       941
       941
       +
       def serial_stdout_on() -> None:

     

       942
       942
       +
           global log

     

       943
       943
       +
           log._print_serial_logs = True

     

       944
       944
       +
       

     

       945
       945
       +
       

     

       946
       946
       +
       def serial_stdout_off() -> None:

     

       947
       947
       +
           global log

     

       948
       948
       +
           log._print_serial_logs = False

     

       928
       949
        
       

     

       929
       950
        
       

     

       930
       951
        
       @contextmanager

+1 -1

nixos/lib/testing-python.nix

···

       25
       25
        
             name = "nixos-test-driver";

     

       26
       26
        
       

     

       27
       27
        
             nativeBuildInputs = [ makeWrapper ];

     

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

     

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

     

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

     

       30
       30
        
       

     

       31
       31
        
             dontUnpack = true;