robotframework-pabot 5.2.0b1__tar.gz → 5.2.0rc2__tar.gz

{robotframework_pabot-5.2.0b1 → robotframework_pabot-5.2.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robotframework-pabot
-Version: 5.2.0b1
+Version: 5.2.0rc2
 Summary: Parallel test runner for Robot Framework
 Home-page: https://pabot.org
 Download-URL: https://pypi.python.org/pypi/robotframework-pabot
@@ -118,10 +118,11 @@ pabot [--verbose|--testlevelsplit|--command .. --end-command|
         --shard i/n|
         --artifacts extensions|--artifactsinsubfolders|
         --resourcefile file|--argumentfile[num] file|--suitesfrom file
-        --ordering <FILENAME> [static|dynamic] [skip|run_all]|
+        --ordering file [static|dynamic] [skip|run_all]|
         --chunk|
         --pabotprerunmodifier modifier|
         --no-rebot|
+        --pabotconsole [verbose|dotted|quiet|none]|
         --help|--version]
       [robot options] [path ...]
 ```
@@ -193,7 +194,7 @@ Supports all [Robot Framework command line options](https://robotframework.org/r
 
 **--resourcefile [FILEPATH]**          
   Indicator for a file that can contain shared variables for distributing resources. This needs to be used together with 
-  pabotlib option. Resource file syntax is same as Windows ini files. Where a section is a shared set of variables.
+  pabotlib option. Resource file syntax is same as Windows ini files where a section is a shared set of variables.
 
 **--argumentfile[INTEGER] [FILEPATH]**          
   Run same suites with multiple [argumentfile](http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#argument-files) options.
@@ -206,10 +207,10 @@ Supports all [Robot Framework command line options](https://robotframework.org/r
   Optionally read suites from output.xml file. Failed suites will run first and longer running ones will be executed 
   before shorter ones.
 
-**--ordering [FILE PATH] [MODE] [FAILURE POLICY]**   
+**--ordering [FILEPATH] [MODE] [FAILURE POLICY]**   
   Optionally give execution order from a file. See README.md section: [Controlling execution order, mode and level of parallelism](#controlling-execution-order-mode-and-level-of-parallelism)
-  - MODE (optional): [static (default)|dynamic]
-  - FAILURE POLICY (optional, only in dynamic mode): [skip|run_all (default)]
+  - MODE (optional): [ static (default) | dynamic ]
+  - FAILURE POLICY (optional, only in dynamic mode): [ skip | run_all (default) ]
 
 **--chunk**   
   Optionally chunk tests to PROCESSES number of robot runs. This can save time because all the suites will share the same 
@@ -226,6 +227,28 @@ Supports all [Robot Framework command line options](https://robotframework.org/r
   for scenarios where Rebot should be run later due to large log files, ensuring better memory and resource availability. 
   Subprocess results are stored in the pabot_results folder.
 
+**--pabotconsole [MODE]**
+  The --pabotconsole option controls how much output is printed to the console.
+  Note that all Pabot’s own messages are always logged to pabot_manager.log, regardless of the selected console mode.
+
+  The available options are:
+  - verbose (default):
+    Prints all messages to the console, corresponding closely to what is written to the log file.
+  - dotted:
+    Prints important messages, warnings, and errors to the console, along with execution progress using the following notation:
+
+      - PASS = .
+      - FAIL = F
+      - SKIP = s
+    
+    Note that each Robot Framework process is represented by a single character. 
+    Depending on the execution parameters, individual tests may not have their own status character; 
+    instead, the status may represent an entire suite or a group of tests.
+  - quiet:
+    Similar to dotted, but suppresses execution progress output.
+  - none:
+    Produces no console output at all.
+
 **--help**             
   Print usage instructions.
  
@@ -491,7 +514,7 @@ pabot_results/
 │       ├── robot_stdout.out
 │       ├── robot_stderr.out
 │       └── artifacts...
-pabot_manager.log            # Pabot's own main log. Basically same than prints in console
+└── pabot_manager.log        # Pabot's own main log.
 ```
 
 Each `PABOTQUEUEINDEX` folder contains as default:

{robotframework_pabot-5.2.0b1 → robotframework_pabot-5.2.0rc2}/README.md

@@ -95,10 +95,11 @@ pabot [--verbose|--testlevelsplit|--command .. --end-command|
         --shard i/n|
         --artifacts extensions|--artifactsinsubfolders|
         --resourcefile file|--argumentfile[num] file|--suitesfrom file
-        --ordering <FILENAME> [static|dynamic] [skip|run_all]|
+        --ordering file [static|dynamic] [skip|run_all]|
         --chunk|
         --pabotprerunmodifier modifier|
         --no-rebot|
+        --pabotconsole [verbose|dotted|quiet|none]|
         --help|--version]
       [robot options] [path ...]
 ```
@@ -170,7 +171,7 @@ Supports all [Robot Framework command line options](https://robotframework.org/r
 
 **--resourcefile [FILEPATH]**          
   Indicator for a file that can contain shared variables for distributing resources. This needs to be used together with 
-  pabotlib option. Resource file syntax is same as Windows ini files. Where a section is a shared set of variables.
+  pabotlib option. Resource file syntax is same as Windows ini files where a section is a shared set of variables.
 
 **--argumentfile[INTEGER] [FILEPATH]**          
   Run same suites with multiple [argumentfile](http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#argument-files) options.
@@ -183,10 +184,10 @@ Supports all [Robot Framework command line options](https://robotframework.org/r
   Optionally read suites from output.xml file. Failed suites will run first and longer running ones will be executed 
   before shorter ones.
 
-**--ordering [FILE PATH] [MODE] [FAILURE POLICY]**   
+**--ordering [FILEPATH] [MODE] [FAILURE POLICY]**   
   Optionally give execution order from a file. See README.md section: [Controlling execution order, mode and level of parallelism](#controlling-execution-order-mode-and-level-of-parallelism)
-  - MODE (optional): [static (default)|dynamic]
-  - FAILURE POLICY (optional, only in dynamic mode): [skip|run_all (default)]
+  - MODE (optional): [ static (default) | dynamic ]
+  - FAILURE POLICY (optional, only in dynamic mode): [ skip | run_all (default) ]
 
 **--chunk**   
   Optionally chunk tests to PROCESSES number of robot runs. This can save time because all the suites will share the same 
@@ -203,6 +204,28 @@ Supports all [Robot Framework command line options](https://robotframework.org/r
   for scenarios where Rebot should be run later due to large log files, ensuring better memory and resource availability. 
   Subprocess results are stored in the pabot_results folder.
 
+**--pabotconsole [MODE]**
+  The --pabotconsole option controls how much output is printed to the console.
+  Note that all Pabot’s own messages are always logged to pabot_manager.log, regardless of the selected console mode.
+
+  The available options are:
+  - verbose (default):
+    Prints all messages to the console, corresponding closely to what is written to the log file.
+  - dotted:
+    Prints important messages, warnings, and errors to the console, along with execution progress using the following notation:
+
+      - PASS = .
+      - FAIL = F
+      - SKIP = s
+    
+    Note that each Robot Framework process is represented by a single character. 
+    Depending on the execution parameters, individual tests may not have their own status character; 
+    instead, the status may represent an entire suite or a group of tests.
+  - quiet:
+    Similar to dotted, but suppresses execution progress output.
+  - none:
+    Produces no console output at all.
+
 **--help**             
   Print usage instructions.
  
@@ -468,7 +491,7 @@ pabot_results/
 │       ├── robot_stdout.out
 │       ├── robot_stderr.out
 │       └── artifacts...
-pabot_manager.log            # Pabot's own main log. Basically same than prints in console
+└── pabot_manager.log        # Pabot's own main log.
 ```
 
 Each `PABOTQUEUEINDEX` folder contains as default:

{robotframework_pabot-5.2.0b1 → robotframework_pabot-5.2.0rc2}/src/pabot/ProcessManager.py

@@ -1,12 +1,12 @@
 import os
 import sys
 import time
-import signal
 import threading
 import subprocess
 import datetime
 import queue
 import locale
+import signal
 
 try:
     import psutil
@@ -28,26 +28,14 @@ class ProcessManager:
         self.processes = []
         self.lock = threading.Lock()
         self.writer = get_writer()
+        self.interrupted = False
+        # Note: Signal handling is done in pabot.py's main_program() to ensure
+        # PabotLib is shut down gracefully before process termination
+        # This ProcessManager will check the interrupted flag set by pabot.py's keyboard_interrupt()
 
-        # Install SIGINT only in main thread
-        try:
-            if threading.current_thread() is threading.main_thread():
-                signal.signal(signal.SIGINT, self._handle_sigint)
-            else:
-                self.writer.write(
-                    "[ProcessManager] (test mode) signal handlers disabled (not in main thread)"
-                )
-        except Exception as e:
-            self.writer.write(f"[WARN] Could not register signal handler: {e}")
-
-    # -------------------------------
-    # SIGNAL HANDLING
-    # -------------------------------
-
-    def _handle_sigint(self, signum, frame):
-        self.writer.write("[ProcessManager] Ctrl+C detected — terminating all subprocesses", color=Color.RED)
-        self.terminate_all()
-        sys.exit(130)
+    def set_interrupted(self):
+        """Called by pabot.py when CTRL+C is received."""
+        self.interrupted = True
 
     # -------------------------------
     # OUTPUT STREAM READERS
@@ -213,7 +201,7 @@ class ProcessManager:
 
         self.writer.write(
             f"[ProcessManager] Terminating process tree PID={process.pid}",
-            color=Color.YELLOW
+            level='debug'
         )
 
         # PRIMARY: psutil (best reliability)
@@ -304,11 +292,13 @@ class ProcessManager:
         if verbose:
             self.writer.write(
                 f"{ts} [PID:{process.pid}] [{pool_id}] [ID:{item_index}] "
-                f"EXECUTING PARALLEL {item_name}:\n{' '.join(cmd)}"
+                f"EXECUTING PARALLEL {item_name}:\n{' '.join(cmd)}",
+                level='debug'
             )
         else:
             self.writer.write(
-                f"{ts} [PID:{process.pid}] [{pool_id}] [ID:{item_index}] EXECUTING {item_name}"
+                f"{ts} [PID:{process.pid}] [{pool_id}] [ID:{item_index}] EXECUTING {item_name}",
+                level='debug'
             )
 
         # Start logging thread
@@ -327,28 +317,76 @@ class ProcessManager:
         while rc is None:
             rc = process.poll()
 
+            # INTERRUPT CHECK - terminate process gracefully when CTRL+C is pressed
+            if self.interrupted:
+                ts = datetime.datetime.now()
+                self.writer.write(
+                    f"{ts} [PID:{process.pid}] [{pool_id}] [ID:{item_index}] "
+                    f"Process {item_name} interrupted by user (Ctrl+C)",
+                    color=Color.YELLOW, level='warning'
+                )
+                self._terminate_tree(process)
+                rc = -1
+
+                # Dryrun process to mark all tests as failed due to user interrupt
+                this_dir = os.path.dirname(os.path.abspath(__file__))
+                listener_path = os.path.join(this_dir, "listener", "interrupt_listener.py")
+                dry_run_env = env.copy() if env else os.environ.copy()
+                before, after = split_on_first(cmd, "-A")
+                dryrun_cmd = before + ["--dryrun", '--listener', listener_path, '-A'] + after
+
+                self.writer.write(
+                    f"{ts} [PID:{process.pid}] [{pool_id}] [ID:{item_index}] "
+                    f"Starting dry run to mark test as failed due to user interrupt: {' '.join(dryrun_cmd)}",
+                    level='debug'
+                )
+                try:
+                    subprocess.run(
+                        dryrun_cmd,
+                        env=dry_run_env,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        timeout=3,
+                        text=True,
+                    )
+                except subprocess.TimeoutExpired as e:
+                    self.writer.write(f"Dry-run timed out after 3s: {e}", level='debug')
+                break
+
             # TIMEOUT CHECK
             if timeout and (time.time() - start > timeout):
                 ts = datetime.datetime.now()
                 self.writer.write(
                     f"{ts} [PID:{process.pid}] [{pool_id}] [ID:{item_index}] "
-                    f"Process {item_name} killed due to exceeding the maximum timeout of {timeout} seconds"
+                    f"Process {item_name} killed due to exceeding the maximum timeout of {timeout} seconds",
+                    color=Color.YELLOW, level='warning'
                 )
                 self._terminate_tree(process)
                 rc = -1
 
                 # Dryrun process to mark all tests as failed due to timeout
                 this_dir = os.path.dirname(os.path.abspath(__file__))
-                listener_path = os.path.join(this_dir, "timeout_listener.py")
+                listener_path = os.path.join(this_dir, "listener", "timeout_listener.py")
                 dry_run_env = env.copy() if env else os.environ.copy()
                 before, after = split_on_first(cmd, "-A")
                 dryrun_cmd = before + ["--dryrun", '--listener', listener_path, '-A'] + after
 
                 self.writer.write(
                     f"{ts} [PID:{process.pid}] [{pool_id}] [ID:{item_index}] "
-                    f"Starting dry run to mark tests as failed due to timeout: {' '.join(dryrun_cmd)}"
+                    f"Starting dry run to mark test as failed due to timeout: {' '.join(dryrun_cmd)}",
+                    level='debug'
                 )
-                subprocess.run(dryrun_cmd, env=dry_run_env, stdout=subprocess.PIPE, stderr=subprocess.PIPE)                
+                try:
+                    subprocess.run(
+                        dryrun_cmd,
+                        env=dry_run_env,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        timeout=3,
+                        text=True,
+                    )
+                except subprocess.TimeoutExpired as e:
+                    self.writer.write(f"Dry-run timed out after 3s: {e}", level='debug')
 
                 break
 
@@ -357,7 +395,8 @@ class ProcessManager:
                 ts = datetime.datetime.now()
                 self.writer.write(
                     f"{ts} [PID:{process.pid}] [{pool_id}] [ID:{item_index}] still running "
-                    f"{item_name} after {(counter * 0.1):.1f}s"
+                    f"{item_name} after {(counter * 0.1):.1f}s",
+                    level='debug'
                 )
                 ping_interval += 50
                 next_ping += ping_interval

{robotframework_pabot-5.2.0b1 → robotframework_pabot-5.2.0rc2}/src/pabot/__init__.py

@@ -7,4 +7,4 @@ try:
 except ImportError:
     pass
 
-__version__ = "5.2.0b1"
+__version__ = "5.2.0rc2"

{robotframework_pabot-5.2.0b1 → robotframework_pabot-5.2.0rc2}/src/pabot/arguments.py

@@ -174,6 +174,7 @@ def _parse_pabot_args(args):  # type: (List[str]) -> Tuple[List[str], Dict[str,
         "shardcount": 1,
         "chunk": False,
         "no-rebot": False,
+        "pabotconsole": "verbose",
     }
 
     # Arguments that are flags (boolean)
@@ -200,6 +201,7 @@ def _parse_pabot_args(args):  # type: (List[str]) -> Tuple[List[str], Dict[str,
         "suitesfrom": str,
         "artifacts": _parse_artifacts,
         "shard": _parse_shard,
+        "pabotconsole": str,
     }
 
     argumentfiles = []
@@ -234,7 +236,12 @@ def _parse_pabot_args(args):  # type: (List[str]) -> Tuple[List[str], Dict[str,
         if arg_name == "command":
             try:
                 end_index = args.index("--end-command", i)
-                pabot_args["command"] = args[i + 1 : end_index]
+                pabot_args["use_user_command"] = True
+                cmd_lines = args[i + 1 : end_index]
+                cmd = []
+                for line in cmd_lines:
+                    cmd.extend(line.split())
+                pabot_args["command"] = cmd
                 i = end_index + 1
                 continue
             except ValueError:
@@ -284,6 +291,17 @@ def _parse_pabot_args(args):  # type: (List[str]) -> Tuple[List[str], Dict[str,
                     # move index past ordering args only
                     i += 2 + i_mode_offset + i_failure_offset
                     continue
+                elif arg_name == "pabotconsole":
+                    console_type = args[i + 1]
+                    valid_types = ("verbose", "dotted", "quiet", "none")
+                    if console_type not in valid_types:
+                        raise DataError(
+                            f"Invalid value for --pabotconsole: {console_type}. "
+                            f"Valid values are: {', '.join(valid_types)}"
+                        )
+                    pabot_args["pabotconsole"] = console_type
+                    i += 2
+                    continue
                 else:
                     value = value_args[arg_name](args[i + 1])
                     if arg_name == "shard":