Add altp package for parallel execution

This patch adds altp package that is an alternative implementation
of ltp package, using asyncio for parallel tests execution. In order to
use it, please set ASYNC_RUN before run.

The altp package also introduces a new UI for parallel execution and it
replaces paramiko library with asyncssh, since paramiko doesn't support
coroutines.

Beware this is an EXPERIMENTAL support and it's not the ending version.

.github/workflows/linting.yml

@@ -10,7 +10,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.6", "3.7", "3.8", "3.9", "3.10", "3.11"]
+        python-version: ["3.6", "3.7", "3.8", "3.9", "3.10", "3.11.0"]
 
     steps:
     - name: Show OS
@@ -31,4 +31,4 @@ jobs:
       run: python3 runltp-ng --help
 
     - name: Lint with pylint
-      run: pylint --rcfile=pylint.ini ltp
+      run: pylint --rcfile=pylint.ini ltp altp

.github/workflows/tests.yml

@@ -10,7 +10,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.6", "3.7", "3.8", "3.9", "3.10", "3.11"]
+        python-version: ["3.6", "3.7", "3.8", "3.9", "3.10", "3.11.0"]
 
     steps:
     - name: Show OS
@@ -25,7 +25,7 @@ jobs:
         python-version: ${{ matrix.python-version }}
 
     - name: Install dependencies
-      run: python3 -m pip install pytest pytest-xdist
+      run: python3 -m pip install asyncssh pytest pytest-asyncio
 
     - name: Test with pytest
-      run: python3 -m pytest -n 8 -m "not qemu and not ssh"
+      run: python3 -m pytest -m "not qemu and not ssh and not ltx"

Makefile

@@ -12,8 +12,10 @@ INSTALL_DIR		:= $(BASE_DIR)/runltp-ng.d
 
 install:
 	mkdir -p $(INSTALL_DIR)/ltp
+	mkdir -p $(INSTALL_DIR)/altp
 
 	install -m 00644 $(top_srcdir)/tools/runltp-ng/ltp/*.py $(INSTALL_DIR)/ltp
+	install -m 00644 $(top_srcdir)/tools/runltp-ng/ltp/*.py $(INSTALL_DIR)/altp
 	install -m 00775 $(top_srcdir)/tools/runltp-ng/runltp-ng $(BASE_DIR)/runltp-ng
 
 include $(top_srcdir)/include/mk/generic_leaf_target.mk

README.md

@@ -116,6 +116,27 @@ Once a new SUT class is implemented and placed inside the `ltp` package folder,
 `runltp-ng -s help` command can be used to see if application correctly
 recognise it.
 
+Parallel execution
+==================
+
+The tool now supports a new experimental feature that is implemented inside the
+`altp` folder. This particular feature permits to execute multiple tests in
+parallel when using host execution or SSH protocol.
+
+To enable the new parallel execution feature, please set the `ASYNC_RUN` flag
+as following:
+
+    # run syscalls testing suite in parallel on host using 16 workers
+    ASYNC_RUN=1 ./runltp-ng --run-suite syscalls --workers 16
+
+    # run syscalls testing suite in parallel via SSH using 16 workers
+    # NOTE: asyncssh package must be installed in the system
+    ./runltp-ng --sut=ssh:host myhost.com:user=root:key_file=myhost_id_rsa \
+        --run-suite syscalls --workers 16
+
+Unfortunately, `paramiko` doesn't support parallel commands execution, so we
+switched into `asyncssh` library that is also way more easy to use.
+
 Development
 ===========
 

altp/__init__.py

@@ -0,0 +1,136 @@
+"""
+.. module:: __init__
+    :platform: Linux
+    :synopsis: ltp package definition
+
+.. moduleauthor:: Andrea Cervesato <andrea.cervesato@suse.com>
+"""
+import sys
+import signal
+import typing
+import asyncio
+from altp.events import EventsHandler
+
+
+class LTPException(Exception):
+    """
+    The most generic exception that is raised by any ltp package when
+    something bad happens.
+    """
+    pass
+
+
+events = EventsHandler()
+
+
+def get_event_loop() -> asyncio.BaseEventLoop:
+    """
+    Return the current asyncio event loop.
+    """
+    loop = None
+
+    try:
+        loop = asyncio.get_running_loop()
+    except (AttributeError, RuntimeError):
+        pass
+
+    if not loop:
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            pass
+
+    if not loop:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+
+    return loop
+
+
+def create_task(coro: typing.Coroutine) -> asyncio.Task:
+    """
+    Create a new task.
+    """
+    loop = get_event_loop()
+    task = loop.create_task(coro)
+
+    return task
+
+
+def cancel_tasks(loop: asyncio.AbstractEventLoop) -> None:
+    """
+    Cancel all asyncio running tasks.
+    """
+    to_cancel = None
+
+    # pylint: disable=no-member
+    if sys.version_info >= (3, 7):
+        to_cancel = asyncio.all_tasks(loop=loop)
+    else:
+        to_cancel = asyncio.Task.all_tasks(loop=loop)
+
+    if not to_cancel:
+        return
+
+    for task in to_cancel:
+        if task.cancelled():
+            continue
+
+        task.cancel()
+
+    # pylint: disable=deprecated-argument
+    if sys.version_info >= (3, 10):
+        loop.run_until_complete(
+            asyncio.gather(*to_cancel, return_exceptions=True))
+    else:
+        loop.run_until_complete(
+            asyncio.gather(*to_cancel, loop=loop, return_exceptions=True))
+
+    for task in to_cancel:
+        if task.cancelled():
+            continue
+
+        if task.exception() is not None:
+            loop.call_exception_handler({
+                'message': 'unhandled exception during asyncio.run() shutdown',
+                'exception': task.exception(),
+                'task': task,
+            })
+
+
+def to_thread(coro: callable, *args: typing.Any) -> typing.Any:
+    """
+    Run coroutine inside a thread. This is useful for blocking I/O operations.
+    """
+    loop = get_event_loop()
+    return loop.run_in_executor(None, coro, *args)
+
+
+def run(coro: typing.Coroutine) -> typing.Any:
+    """
+    Run coroutine inside running event loop and it cancel all loop
+    tasks at the end. Useful when we want to run the main() function.
+    """
+    loop = get_event_loop()
+
+    def handler() -> None:
+        cancel_tasks(loop)
+
+        # we don't have to handle signal again
+        loop.remove_signal_handler(signal.SIGTERM)
+        loop.add_signal_handler(signal.SIGINT, lambda: None)
+
+    for sig in (signal.SIGTERM, signal.SIGINT):
+        loop.add_signal_handler(sig, handler)
+
+    try:
+        return loop.run_until_complete(coro)
+    finally:
+        cancel_tasks(loop)
+
+
+__all__ = [
+    "LTPException",
+    "events",
+    "get_event_loop"
+]