robotframework-pabot 5.0.0__py3-none-any.whl → 5.2.0b1__py3-none-any.whl

pabot/pabot.py

@@ -48,6 +48,7 @@ from glob import glob
 from io import BytesIO, StringIO
 from multiprocessing.pool import ThreadPool
 from natsort import natsorted
+from pathlib import Path
 
 from robot import __version__ as ROBOT_VERSION
 from robot import rebot
@@ -83,6 +84,7 @@ from .execution_items import (
     create_dependency_tree,
 )
 from .result_merger import merge
+from .writer import get_writer
 
 try:
     import queue  # type: ignore
@@ -100,10 +102,10 @@ try:
 except ImportError:
     METADATA_AVAILABLE = False
 
-from typing import IO, Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 CTRL_C_PRESSED = False
-MESSAGE_QUEUE = queue.Queue()
+#MESSAGE_QUEUE = queue.Queue()
 EXECUTION_POOL_IDS = []  # type: List[int]
 EXECUTION_POOL_ID_LOCK = threading.Lock()
 POPEN_LOCK = threading.Lock()
@@ -130,6 +132,15 @@ _ALL_ELAPSED = []  # type: List[Union[int, float]]
 # Python version check for supporting importlib.metadata (requires Python 3.8+)
 IS_PYTHON_3_8_OR_NEWER = sys.version_info >= (3, 8)
 
+_PROCESS_MANAGER = None
+
+def _ensure_process_manager():
+    global _PROCESS_MANAGER
+    if _PROCESS_MANAGER is None:
+        from pabot.ProcessManager import ProcessManager
+        _PROCESS_MANAGER = ProcessManager()
+    return _PROCESS_MANAGER
+
 
 def read_args_from_readme():
     """Reads a specific section from package METADATA or development README.md if available."""
@@ -194,8 +205,13 @@ def extract_section(lines, start_marker="<!-- START DOCSTRING -->", end_marker="
         if end_marker in line:
             break
         if inside_section:
-            # Remove Markdown links but keep the text
-            extracted_lines.append(re.sub(r'\[([^\]]+)\]\(https?://[^\)]+\)', r'\1', line))
+            # Remove Markdown hyperlinks but keep text
+            line = re.sub(r'\[([^\]]+)\]\(https?://[^\)]+\)', r'\1', line)
+            # Remove Markdown section links but keep text
+            line = re.sub(r'\[([^\]]+)\]\(#[^\)]+\)', r'\1', line)
+            # Remove ** and backticks `
+            line = re.sub(r'(\*\*|`)', '', line)
+            extracted_lines.append(line)
 
     return "".join(extracted_lines).strip()
 
@@ -210,7 +226,7 @@ class Color:
 
 
 def execute_and_wait_with(item):
-    # type: ('QueueItem') -> None
+    # type: ('QueueItem') -> int
     global CTRL_C_PRESSED, _NUMBER_OF_ITEMS_TO_BE_EXECUTED
     is_last = _NUMBER_OF_ITEMS_TO_BE_EXECUTED == 1
     _NUMBER_OF_ITEMS_TO_BE_EXECUTED -= 1
@@ -229,6 +245,7 @@ def execute_and_wait_with(item):
         run_cmd, run_options = _create_command_for_execution(
             caller_id, datasources, is_last, item, outs_dir
         )
+        rc = 0
         if item.hive:
             _hived_execute(
                 item.hive,
@@ -241,7 +258,7 @@ def execute_and_wait_with(item):
                 item.index,
             )
         else:
-            _try_execute_and_wait(
+            rc = _try_execute_and_wait(
                 run_cmd,
                 run_options,
                 outs_dir,
@@ -259,6 +276,7 @@ def execute_and_wait_with(item):
         )
     except:
         _write(traceback.format_exc())
+    return rc
 
 
 def _create_command_for_execution(caller_id, datasources, is_last, item, outs_dir):
@@ -276,6 +294,7 @@ def _create_command_for_execution(caller_id, datasources, is_last, item, outs_di
             item.index,
             item.last_level,
             item.processes,
+            item.skip,
         )
         + datasources
     )
@@ -312,7 +331,7 @@ def _try_execute_and_wait(
     process_timeout=None,
     sleep_before_start=0
 ):
-    # type: (List[str], List[str], str, str, bool, int, str, int, bool, Optional[int], int) -> None
+    # type: (List[str], List[str], str, str, bool, int, str, int, bool, Optional[int], int) -> int
     plib = None
     is_ignored = False
     if _pabotlib_in_use():
@@ -354,7 +373,8 @@ def _try_execute_and_wait(
         show_stdout_on_failure,
     )
     if is_ignored and os.path.isdir(outs_dir):
-        shutil.rmtree(outs_dir)
+        _rmtree_with_path(outs_dir)
+    return rc
 
 
 def _result_to_stdout(
@@ -551,88 +571,39 @@ def _run(
     process_timeout,
     sleep_before_start,
 ):
-    # type: (List[str], List[str], IO[Any], IO[Any], str, bool, int, int, str, Optional[int], int) -> Tuple[Union[subprocess.Popen[bytes], subprocess.Popen], Tuple[int, float]]
     timestamp = datetime.datetime.now()
+
     if sleep_before_start > 0:
-        _write(
-            "%s [%s] [ID:%s] SLEEPING %s SECONDS BEFORE STARTING %s"
-            % (timestamp, pool_id, item_index, sleep_before_start, item_name),
-        )
+        _write(f"{timestamp} [{pool_id}] [ID:{item_index}] SLEEPING {sleep_before_start} SECONDS BEFORE STARTING {item_name}")
         time.sleep(sleep_before_start)
-    timestamp = datetime.datetime.now()
+
     command_name = run_command[-1].replace(" ", "_")
     argfile_path = os.path.join(outs_dir, f"{command_name}_argfile.txt")
     _write_internal_argument_file(run_options, filename=argfile_path)
-    cmd = ' '.join(run_command + ['-A'] + [argfile_path])
-    if PY2:
-        cmd = cmd.decode("utf-8").encode(SYSTEM_ENCODING)
-    # avoid hitting https://bugs.python.org/issue10394
-    with POPEN_LOCK:
-        my_env = os.environ.copy()
-        syslog_file = my_env.get("ROBOT_SYSLOG_FILE", None)
-        if syslog_file:
-            my_env["ROBOT_SYSLOG_FILE"] = os.path.join(
-                outs_dir, os.path.basename(syslog_file)
-            )
-        process = subprocess.Popen(
-            cmd, shell=True, stderr=stderr, stdout=stdout, env=my_env
-        )
-    if verbose:
-        _write_with_id(
-            process,
-            pool_id,
-            item_index,
-            "EXECUTING PARALLEL %s with command:\n%s" % (item_name, cmd),
-            timestamp=timestamp,
-        )
-    else:
-        _write_with_id(
-            process,
-            pool_id,
-            item_index,
-            "EXECUTING %s" % item_name,
-            timestamp=timestamp,
-        )
-    return process, _wait_for_return_code(
-        process, item_name, pool_id, item_index, process_timeout
-    )
-
-
-def _wait_for_return_code(process, item_name, pool_id, item_index, process_timeout):
-    rc = None
-    elapsed = 0
-    ping_time = ping_interval = 150
-    while rc is None:
-        rc = process.poll()
-        time.sleep(0.1)
-        elapsed += 1
-
-        if process_timeout and elapsed / 10.0 >= process_timeout:
-            process.terminate()
-            process.wait()
-            rc = (
-                -1
-            )  # Set a return code indicating that the process was killed due to timeout
-            _write_with_id(
-                process,
-                pool_id,
-                item_index,
-                "Process %s killed due to exceeding the maximum timeout of %s seconds"
-                % (item_name, process_timeout),
-            )
-            break
 
-        if elapsed == ping_time:
-            ping_interval += 50
-            ping_time += ping_interval
-            _write_with_id(
-                process,
-                pool_id,
-                item_index,
-                "still running %s after %s seconds" % (item_name, elapsed / 10.0),
-            )
+    cmd = run_command + ['-A', argfile_path]
+    my_env = os.environ.copy()
+    syslog_file = my_env.get("ROBOT_SYSLOG_FILE", None)
+    if syslog_file:
+        my_env["ROBOT_SYSLOG_FILE"] = os.path.join(outs_dir, os.path.basename(syslog_file))
+
+    log_path = os.path.join(outs_dir, f"{command_name}_{item_index}.log")
+
+    manager = _ensure_process_manager()
+    process, (rc, elapsed) = manager.run(
+        cmd,
+        env=my_env,
+        stdout=stdout,
+        stderr=stderr,
+        timeout=process_timeout,
+        verbose=verbose,
+        item_name=item_name,
+        log_file=log_path,
+        pool_id=pool_id,
+        item_index=item_index,
+    )
 
-    return rc, elapsed / 10.0
+    return process, (rc, elapsed)
 
 
 def _read_file(file_handle):
@@ -692,6 +663,7 @@ def _options_for_executor(
     queueIndex,
     last_level,
     processes,
+    skip,
 ):
     options = options.copy()
     options["log"] = "NONE"
@@ -728,6 +700,11 @@ def _options_for_executor(
         options["argumentfile"] = argfile
     if options.get("test", False) and options.get("include", []):
         del options["include"]
+    if skip:
+        this_dir = os.path.dirname(os.path.abspath(__file__))
+        listener_path = os.path.join(this_dir, "skip_listener.py")
+        options["dryrun"] = True
+        options["listener"].append(listener_path)
     return _set_terminal_coloring_options(options)
 
 
@@ -750,10 +727,13 @@ def _modify_options_for_argfile_use(argfile, options):
 
 
 def _replace_base_name(new_name, options, key):
-    if isinstance(options.get(key, None), str):
-        options[key] = new_name + '.' + options[key].split('.', 1)[1]
+    if isinstance(options.get(key), str):
+        options[key] = f"{new_name}.{options[key].split('.', 1)[1]}" if '.' in options[key] else new_name
     elif key in options:
-        options[key] = [new_name + '.' + s.split('.', 1)[1] for s in options.get(key, [])]
+        options[key] = [
+            f"{new_name}.{s.split('.', 1)[1]}" if '.' in s else new_name
+            for s in options.get(key, [])
+        ]
 
 
 def _set_terminal_coloring_options(options):
@@ -1438,6 +1418,117 @@ def keyboard_interrupt(*args):
     CTRL_C_PRESSED = True
 
 
+def _get_depends(item):
+    return getattr(item.execution_item, "depends", [])
+
+
+def _dependencies_satisfied(item, completed):
+    return all(dep in completed for dep in _get_depends(item))
+
+
+def _collect_transitive_dependents(failed_name, pending_items):
+    """
+    Returns all pending items that (directly or indirectly) depend on failed_name.
+    """
+    to_skip = set()
+    queue = [failed_name]
+
+    # Build dependency map once
+    depends_map = {
+        item.execution_item.name: set(_get_depends(item))
+        for item in pending_items
+    }
+
+    while queue:
+        current = queue.pop(0)
+        for item_name, deps in depends_map.items():
+            if current in deps and item_name not in to_skip:
+                to_skip.add(item_name)
+                queue.append(item_name)
+
+    return to_skip
+
+
+def _parallel_execute_dynamic(
+    items,
+    processes,
+    datasources,
+    outs_dir,
+    opts_for_run,
+    pabot_args,
+):
+    original_signal_handler = signal.signal(signal.SIGINT, keyboard_interrupt)
+
+    max_processes = processes or len(items)
+    pool = ThreadPool(max_processes)
+
+    pending = set(items)
+    running = {}
+    completed = set()
+    failed = set()
+
+    failure_policy = pabot_args.get("ordering", {}).get("failure_policy", "run_all")
+    lock = threading.Lock()
+
+    def on_complete(it, rc):
+        nonlocal pending, running, completed, failed
+
+        with lock:
+            running.pop(it, None)
+            completed.add(it.execution_item.name)
+
+            if rc != 0:
+                failed.add(it.execution_item.name)
+
+                if failure_policy == "skip":
+                    to_skip_names = _collect_transitive_dependents(
+                        it.execution_item.name,
+                        pending,
+                    )
+
+                    for other in list(pending):
+                        if other.execution_item.name in to_skip_names:
+                            _write(
+                                f"Skipping '{other.execution_item.name}' because dependency "
+                                f"'{it.execution_item.name}' failed (transitive).",
+                                Color.YELLOW,
+                            )
+                            other.skip = True
+
+    try:
+        while pending or running:
+            with lock:
+                ready = [
+                    item for item in list(pending)
+                    if _dependencies_satisfied(item, completed)
+                ]
+
+                while ready and len(running) < max_processes:
+                    item = ready.pop(0)
+                    pending.remove(item)
+
+                    result = pool.apply_async(
+                        execute_and_wait_with,
+                        (item,),
+                        callback=lambda rc, it=item: on_complete(it, rc),
+                    )
+                    running[item] = result
+
+            dynamic_items = _get_dynamically_created_execution_items(
+                datasources, outs_dir, opts_for_run, pabot_args
+            )
+            if dynamic_items:
+                with lock:
+                    for di in dynamic_items:
+                        pending.add(di)
+
+            time.sleep(0.1)
+
+    finally:
+        pool.close()
+        signal.signal(signal.SIGINT, original_signal_handler)
+
+
 def _parallel_execute(
     items, processes, datasources, outs_dir, opts_for_run, pabot_args
 ):
@@ -1473,15 +1564,30 @@ def _output_dir(options, cleanup=True):
     outputdir = options.get("outputdir", ".")
     outpath = os.path.join(outputdir, "pabot_results")
     if cleanup and os.path.isdir(outpath):
-        shutil.rmtree(outpath)
+        _rmtree_with_path(outpath)
     return outpath
 
 
-def _get_timestamp_id(timestamp_str):
-    return datetime.datetime.strptime(timestamp_str, "%Y-%m-%d %H:%M:%S.%f").strftime("%Y%m%d_%H%M%S")
+def _rmtree_with_path(path):
+    """
+    Remove a directory tree and, if a PermissionError occurs,
+    re-raise it with the absolute path included in the message.
+    """
+    try:
+        shutil.rmtree(path)
+    except PermissionError as e:
+        abs_path = os.path.abspath(path)
+        raise PermissionError(f"Failed to delete path {abs_path}") from e
+
+
+def _get_timestamp_id(timestamp_str, add_timestamp):
+    # type: (str, bool) -> Optional[str]
+    if add_timestamp:
+        return str(datetime.datetime.strptime(timestamp_str, "%Y-%m-%d %H:%M:%S.%f").strftime("%Y%m%d_%H%M%S"))
+    return None
 
 
-def _copy_output_artifacts(options, timestamp_id, file_extensions=None, include_subfolders=False, index=None):
+def _copy_output_artifacts(options, timestamp_id=None, file_extensions=None, include_subfolders=False, index=None):
     file_extensions = file_extensions or ["png"]
     pabot_outputdir = _output_dir(options, cleanup=False)
     outputdir = options.get("outputdir", ".")
@@ -1505,9 +1611,9 @@ def _copy_output_artifacts(options, timestamp_id, file_extensions=None, include_
                     dst_folder_path = os.path.join(outputdir, subfolder_path)
                     if not os.path.isdir(dst_folder_path):
                         os.makedirs(dst_folder_path)
-                dst_file_name = "-".join([timestamp_id, prefix, file_name])
-                if index:
-                    dst_file_name = "-".join([timestamp_id, index, prefix, file_name])
+                dst_file_name_parts = [timestamp_id, index, prefix, file_name]
+                filtered_name = [str(p) for p in dst_file_name_parts if p is not None]
+                dst_file_name = "-".join(filtered_name)
                 shutil.copy2(
                     os.path.join(location, file_name),
                     os.path.join(dst_folder_path, dst_file_name),
@@ -1517,16 +1623,34 @@ def _copy_output_artifacts(options, timestamp_id, file_extensions=None, include_
 
 
 def _check_pabot_results_for_missing_xml(base_dir, command_name, output_xml_name):
+    """
+    Check for missing Robot Framework output XML files in pabot result directories,
+    taking into account the optional timestamp added by the -T option.
+
+    Args:
+        base_dir: The root directory containing pabot subdirectories
+        command_name: Name of the command that generated the output (used for fallback stderr filename)
+        output_xml_name: Expected XML filename, e.g., 'output.xml'
+
+    Returns:
+        List of paths to stderr output files for directories where the XML is missing.
+    """
     missing = []
+    # Prepare regex to match timestamped filenames like output-YYYYMMDD-hhmmss.xml
+    name_stem = os.path.splitext(output_xml_name)[0]
+    name_suffix = os.path.splitext(output_xml_name)[1]
+    pattern = re.compile(rf"^{re.escape(name_stem)}(-\d{{8}}-\d{{6}})?{re.escape(name_suffix)}$")
+
     for root, dirs, _ in os.walk(base_dir):
         if root == base_dir:
             for subdir in dirs:
                 subdir_path = os.path.join(base_dir, subdir)
-                has_xml = any(fname.endswith(output_xml_name) for fname in os.listdir(subdir_path))
+                # Check if any file matches the expected XML name or timestamped variant
+                has_xml = any(pattern.match(fname) for fname in os.listdir(subdir_path))
                 if not has_xml:
-                    command_name = command_name.replace(" ", "_")
-                    missing.append(os.path.join(subdir_path, f'{command_name}_stderr.out'))
-            break
+                    sanitized_cmd = command_name.replace(" ", "_")
+                    missing.append(os.path.join(subdir_path, f"{sanitized_cmd}_stderr.out"))
+            break  # only check immediate subdirectories
     return missing
 
 
@@ -1551,7 +1675,7 @@ def _report_results(outs_dir, pabot_args, options, start_time_string, tests_root
         outputs = []  # type: List[str]
         for index, _ in pabot_args["argumentfiles"]:
             copied_artifacts = _copy_output_artifacts(
-                options, _get_timestamp_id(start_time_string), pabot_args["artifacts"], pabot_args["artifactsinsubfolders"], index
+                options, _get_timestamp_id(start_time_string, pabot_args["artifactstimestamps"]), pabot_args["artifacts"], pabot_args["artifactsinsubfolders"], index
             )
             outputs += [
                 _merge_one_run(
@@ -1560,7 +1684,7 @@ def _report_results(outs_dir, pabot_args, options, start_time_string, tests_root
                     tests_root_name,
                     stats,
                     copied_artifacts,
-                    timestamp_id=_get_timestamp_id(start_time_string),
+                    timestamp_id=_get_timestamp_id(start_time_string, pabot_args["artifactstimestamps"]),
                     outputfile=os.path.join("pabot_results", "output%s.xml" % index),
                 )
             ]
@@ -1607,16 +1731,35 @@ def _write_stats(stats):
     _write("===================================================")
 
 
+def add_timestamp_to_filename(file_path: str, timestamp: str) -> str:
+    """
+    Rename the given file by inserting a timestamp before the extension.
+    Format: YYYYMMDD-hhmmss
+    Example: output.xml -> output-20251222-152233.xml
+    """
+    file_path = Path(file_path)
+    if not file_path.exists():
+        raise FileNotFoundError(f"{file_path} does not exist")
+
+    new_name = f"{file_path.stem}-{timestamp}{file_path.suffix}"
+    new_path = file_path.with_name(new_name)
+    file_path.rename(new_path)
+    return str(new_path)
+
+
 def _report_results_for_one_run(
     outs_dir, pabot_args, options, start_time_string, tests_root_name, stats
 ):
     copied_artifacts = _copy_output_artifacts(
-        options, _get_timestamp_id(start_time_string), pabot_args["artifacts"], pabot_args["artifactsinsubfolders"]
+        options, _get_timestamp_id(start_time_string, pabot_args["artifactstimestamps"]), pabot_args["artifacts"], pabot_args["artifactsinsubfolders"]
     )
     output_path = _merge_one_run(
-        outs_dir, options, tests_root_name, stats, copied_artifacts, _get_timestamp_id(start_time_string)
+        outs_dir, options, tests_root_name, stats, copied_artifacts, _get_timestamp_id(start_time_string, pabot_args["artifactstimestamps"])
     )
     _write_stats(stats)
+    ts = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
+    if "timestampoutputs" in options and options["timestampoutputs"]:
+        output_path = add_timestamp_to_filename(output_path, ts)
     if (
         "report" in options
         and options["report"].upper() == "NONE"
@@ -1629,7 +1772,7 @@ def _report_results_for_one_run(
     else:
         _write("Output:  %s" % output_path)
         options["output"] = None  # Do not write output again with rebot
-    return rebot(output_path, **_options_for_rebot(options, start_time_string, _now()))
+    return rebot(output_path, **_options_for_rebot(options, start_time_string, ts))
 
 
 def _merge_one_run(
@@ -1640,7 +1783,16 @@ def _merge_one_run(
         os.path.join(options.get("outputdir", "."), outputfile)
     )
     filename = options.get("output") or "output.xml"
-    files = natsorted(glob(os.path.join(_glob_escape(outs_dir), f"**/*{filename}"), recursive=True))
+    base_name, ext = os.path.splitext(filename)
+    # Glob all candidates
+    candidate_files = glob(os.path.join(outs_dir, "**", f"*{base_name}*{ext}"), recursive=True)
+
+    # Regex: basename or basename-YYYYMMDD-hhmmss.ext
+    ts_pattern = re.compile(rf"^{re.escape(base_name)}(?:-\d{{8}}-\d{{6}})?{re.escape(ext)}$")
+
+    files = [f for f in candidate_files if ts_pattern.search(os.path.basename(f))]
+    files = natsorted(files)
+
     if not files:
         _write('WARN: No output files in "%s"' % outs_dir, Color.YELLOW)
         return ""
@@ -1691,19 +1843,9 @@ def _glob_escape(pathname):
     return drive + pathname
 
 
-def _writer():
-    while True:
-        message = MESSAGE_QUEUE.get()
-        if message is None:
-            MESSAGE_QUEUE.task_done()
-            return
-        print(message)
-        sys.stdout.flush()
-        MESSAGE_QUEUE.task_done()
-
-
 def _write(message, color=None):
-    MESSAGE_QUEUE.put(_wrap_with(color, message))
+    writer = get_writer()
+    writer.write(message, color=color)
 
 
 def _wrap_with(color, message):
@@ -1716,19 +1858,19 @@ def _is_output_coloring_supported():
     return sys.stdout.isatty() and os.name in Color.SUPPORTED_OSES
 
 
-def _start_message_writer():
-    t = threading.Thread(target=_writer)
-    t.start()
-
-
-def _stop_message_writer():
-    MESSAGE_QUEUE.put(None)
-    MESSAGE_QUEUE.join()
+def _is_port_available(port):
+    """Check if a given port on localhost is available."""
+    with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s:
+        try:
+            s.bind(("localhost", port))
+            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            return True
+        except OSError:
+            return False
 
 
-def _get_free_port(pabot_args):
-    if pabot_args["pabotlibport"] != 0:
-        return pabot_args["pabotlibport"]
+def _get_free_port():
+    """Return a free TCP port on localhost."""
     with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s:
         s.bind(("localhost", 0))
         s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
@@ -1737,29 +1879,43 @@ def _get_free_port(pabot_args):
 
 def _start_remote_library(pabot_args):  # type: (dict) -> Optional[subprocess.Popen]
     global _PABOTLIBURI
-    free_port = _get_free_port(pabot_args)
-    _PABOTLIBURI = "%s:%s" % (pabot_args["pabotlibhost"], free_port)
-    if not pabot_args["pabotlib"]:
+    # If pabotlib is not enabled, do nothing
+    if not pabot_args.get("pabotlib"):
         return None
-    if pabot_args.get("resourcefile") and not os.path.exists(
-        pabot_args["resourcefile"]
-    ):
+
+    host = pabot_args.get("pabotlibhost", "127.0.0.1")
+    port = pabot_args.get("pabotlibport", 8270)
+
+    # If host is default and user specified a non-zero port, check if it's available
+    if host == "127.0.0.1" and port != 0 and not _is_port_available(port):
+        _write(
+            f"Warning: specified pabotlibport {port} is already in use. "
+            "A free port will be assigned automatically.",
+            Color.YELLOW,
+        )
+        port = _get_free_port()
+
+    # If host is default and port = 0, assign a free port
+    if host == "127.0.0.1" and port == 0:
+        port = _get_free_port()
+
+    _PABOTLIBURI = f"{host}:{port}"
+    resourcefile = pabot_args.get("resourcefile") or ""
+    if resourcefile and not os.path.exists(resourcefile):
         _write(
             "Warning: specified resource file doesn't exist."
             " Some tests may fail or continue forever.",
             Color.YELLOW,
         )
-        pabot_args["resourcefile"] = None
-    return subprocess.Popen(
-        '"{python}" -m {pabotlibname} {resourcefile} {pabotlibhost} {pabotlibport}'.format(
-            python=sys.executable,
-            pabotlibname=pabotlib.__name__,
-            resourcefile=pabot_args.get("resourcefile"),
-            pabotlibhost=pabot_args["pabotlibhost"],
-            pabotlibport=free_port,
-        ),
-        shell=True,
-    )
+        resourcefile = ""
+    cmd = [
+        sys.executable,
+        "-m", pabotlib.__name__,
+        resourcefile,
+        pabot_args["pabotlibhost"],
+        str(port),
+    ]
+    return subprocess.Popen(cmd)
 
 
 def _stop_remote_library(process):  # type: (subprocess.Popen) -> None
@@ -1807,8 +1963,9 @@ class QueueItem(object):
         hive=None,
         processes=0,
         timeout=None,
+        skip=False,
     ):
-        # type: (List[str], str, Dict[str, object], ExecutionItem, List[str], bool, Tuple[str, Optional[str]], Optional[str], int, Optional[int]) -> None
+        # type: (List[str], str, Dict[str, object], ExecutionItem, List[str], bool, Tuple[str, Optional[str]], Optional[str], int, Optional[int], bool) -> None
         self.datasources = datasources
         self.outs_dir = (
             outs_dir.encode("utf-8") if PY2 and is_unicode(outs_dir) else outs_dir
@@ -1828,6 +1985,7 @@ class QueueItem(object):
         self.processes = processes
         self.timeout = timeout
         self.sleep_before_start = execution_item.get_sleep()
+        self.skip = skip
 
     @property
     def index(self):
@@ -2022,7 +2180,16 @@ def _get_dynamically_created_execution_items(
     if not _pabotlib_in_use():
         return None
     plib = Remote(_PABOTLIBURI)
-    new_suites = plib.run_keyword("get_added_suites", [], {})
+    try:
+        new_suites = plib.run_keyword("get_added_suites", [], {})
+    except RuntimeError as err:
+        _write(
+            "[WARN] PabotLib unreachable during post-run phase, "
+            "assuming no dynamically added suites. "
+            "Original error: %s",
+            err,
+        )
+        new_suites = []
     if len(new_suites) == 0:
         return None
     suite_group = [DynamicSuiteItem(s, v) for s, v in new_suites]
@@ -2054,6 +2221,7 @@ def main(args=None):
 
 def main_program(args):
     global _PABOTLIBPROCESS
+    outs_dir = None
     args = args or sys.argv[1:]
     if len(args) == 0:
         print(
@@ -2067,7 +2235,6 @@ def main_program(args):
     start_time_string = _now()
     # NOTE: timeout option
     try:
-        _start_message_writer()
         options, datasources, pabot_args, opts_for_run = parse_args(args)
         if pabot_args["help"]:
             help_print = __doc__.replace(
@@ -2075,15 +2242,22 @@ def main_program(args):
                     read_args_from_readme()
                 )
             print(help_print.replace("[PABOT_VERSION]", PABOT_VERSION))
-            return 0
+            return 251
         if len(datasources) == 0:
             print("[ " + _wrap_with(Color.RED, "ERROR") + " ]: No datasources given.")
             print("Try --help for usage information.")
             return 252
+        outs_dir = _output_dir(options)
+
+        # These ensure MessageWriter and ProcessManager are ready before any parallel execution.
+        writer = get_writer(log_dir=outs_dir)
+        _ensure_process_manager()
+        _write(f"Initialized logging in {outs_dir}")
+
         _PABOTLIBPROCESS = _start_remote_library(pabot_args)
         if _pabotlib_in_use():
             _initialize_queue_index()
-        outs_dir = _output_dir(options)
+
         suite_groups = _group_suites(outs_dir, datasources, options, pabot_args)
         if pabot_args["verbose"]:
             _write("Suite names resolved in %s seconds" % str(time.time() - start_time))
@@ -2094,16 +2268,30 @@ def main_program(args):
         execution_items = _create_execution_items(
             suite_groups, datasources, outs_dir, options, opts_for_run, pabot_args
         )
-        while execution_items:
-            items = execution_items.pop(0)
-            _parallel_execute(
-                items,
+        if pabot_args.get("ordering", {}).get("mode") == "dynamic":
+            # flatten stages
+            all_items = []
+            for stage in execution_items:
+                all_items.extend(stage)
+            _parallel_execute_dynamic(
+                all_items,
                 pabot_args["processes"],
                 datasources,
                 outs_dir,
                 opts_for_run,
                 pabot_args,
             )
+        else:
+            while execution_items:
+                items = execution_items.pop(0)
+                _parallel_execute(
+                    items,
+                    pabot_args["processes"],
+                    datasources,
+                    outs_dir,
+                    opts_for_run,
+                    pabot_args,
+                    )
         if pabot_args["no-rebot"]:
             _write((
                 "All tests were executed, but the --no-rebot argument was given, "
@@ -2111,7 +2299,7 @@ def main_program(args):
                 f"All results have been saved in the {outs_dir} folder."
             ))
             _write("===================================================")
-            return 0 if not _ABNORMAL_EXIT_HAPPENED else 252
+            return 253
         result_code = _report_results(
             outs_dir,
             pabot_args,
@@ -2124,24 +2312,62 @@ def main_program(args):
         version_print = __doc__.replace("\nPLACEHOLDER_README.MD\n", "")
         print(version_print.replace("[PABOT_VERSION]", PABOT_VERSION))
         print(i.message)
+        return 251
     except DataError as err:
         print(err.message)
         return 252
     except Exception:
-        _write("[ERROR] EXCEPTION RAISED DURING PABOT EXECUTION", Color.RED)
-        _write(
-            "[ERROR] PLEASE CONSIDER REPORTING THIS ISSUE TO https://github.com/mkorpela/pabot/issues",
-            Color.RED,
-        )
-        _write("Pabot: %s" % PABOT_VERSION)
-        _write("Python: %s" % sys.version)
-        _write("Robot Framework: %s" % ROBOT_VERSION)
-        raise
+        if not CTRL_C_PRESSED:
+            _write("[ERROR] EXCEPTION RAISED DURING PABOT EXECUTION", Color.RED)
+            _write(
+                "[ERROR] PLEASE CONSIDER REPORTING THIS ISSUE TO https://github.com/mkorpela/pabot/issues",
+                Color.RED,
+            )
+            _write("Pabot: %s" % PABOT_VERSION)
+            _write("Python: %s" % sys.version)
+            _write("Robot Framework: %s" % ROBOT_VERSION)
+            import traceback
+            traceback.print_exc()
+            sys.exit(255)
+        else:
+            _write("[ERROR] Execution stopped by user (Ctrl+C)", Color.RED)
+            sys.exit(253)
     finally:
-        if _PABOTLIBPROCESS:
-            _stop_remote_library(_PABOTLIBPROCESS)
-        _print_elapsed(start_time, time.time())
-        _stop_message_writer()
+        # Ensure that writer exists
+        writer = None
+        try:
+            if outs_dir is not None:
+                writer = get_writer(log_dir=outs_dir)
+        except Exception as e:
+            print(f"[WARN] Could not initialize writer in finally: {e}")
+        # Try to stop remote library
+        try:
+            if _PABOTLIBPROCESS:
+                _stop_remote_library(_PABOTLIBPROCESS)
+        except Exception as e:
+            if writer:
+                writer.write(f"[WARN] Failed to stop remote library cleanly: {e}", Color.YELLOW)
+            else:
+                print(f"[WARN] Failed to stop remote library cleanly: {e}")
+        # print elapsed time
+        try:
+            _print_elapsed(start_time, time.time())
+        except Exception as e:
+            if writer:
+                writer.write(f"[WARN] Failed to print elapsed time: {e}", Color.YELLOW)
+            else:
+                print(f"[WARN] Failed to print elapsed time: {e}")
+        # Flush and stop writer
+        if writer:
+            try:
+                writer.flush()
+                writer.write("Logs flushed successfully.")
+            except Exception as e:
+                print(f"[WARN] Could not flush writer: {e}")
+            try:
+                writer.stop()
+            except Exception as e:
+                print(f"[WARN] Could not stop writer: {e}")
 
 
 def _parse_ordering(filename):  # type: (str) -> List[ExecutionItem]
@@ -2189,7 +2415,7 @@ def _check_ordering(ordering_file, suite_names):  # type: (List[ExecutionItem],
 def _group_suites(outs_dir, datasources, options, pabot_args):
     suite_names = solve_suite_names(outs_dir, datasources, options, pabot_args)
     _verify_depends(suite_names)
-    ordering_arg = _parse_ordering(pabot_args.get("ordering")) if (pabot_args.get("ordering")) is not None else None
+    ordering_arg = _parse_ordering(pabot_args.get("ordering").get("file")) if (pabot_args.get("ordering")) is not None else None
     if ordering_arg:
         _verify_depends(ordering_arg)
         if options.get("name"):