atex 0.8__py3-none-any.whl → 0.9__py3-none-any.whl

atex/executor/testcontrol.py

@@ -95,7 +95,7 @@ class TestControl:
     processing test-issued commands, results and uploaded files.
     """
 
-    def __init__(self, *, control_fd, reporter, duration, testout_fd):
+    def __init__(self, *, reporter, duration, control_fd=None):
         """
         'control_fd' is a non-blocking file descriptor to be read.
 
@@ -103,16 +103,15 @@ class TestControl:
         and uploaded files will be written to.
 
         'duration' is a class Duration instance.
-
-        'testout_fd' is an optional file descriptor handle which the test uses
-        to write its output to - useful here for the 'result' control word and
-        its protocol, which allows "hardlinking" the fd to a real file name.
         """
-        self.control_fd = control_fd
-        self.stream = NonblockLineReader(control_fd)
         self.reporter = reporter
         self.duration = duration
-        self.testout_fd = testout_fd
+        if control_fd:
+            self.control_fd = control_fd
+            self.stream = NonblockLineReader(control_fd)
+        else:
+            self.control_fd = None
+            self.stream = None
         self.eof = False
         self.in_progress = None
         self.partial_results = collections.defaultdict(dict)
@@ -120,6 +119,20 @@ class TestControl:
         self.reconnect = None
         self.nameless_result_seen = False
 
+    def reassign(self, new_fd):
+        """
+        Assign a new control file descriptor to read test control from,
+        replacing a previous one. Useful on test reconnect.
+        """
+        err = "tried to assign new control fd while"
+        if self.in_progress:
+            raise BadControlError(f"{err} old one is reading non-control binary data")
+        elif self.stream and self.stream.bytes_read != 0:
+            raise BadControlError(f"{err} old one is in the middle of reading a control line")
+        self.eof = False
+        self.control_fd = new_fd
+        self.stream = NonblockLineReader(new_fd)
+
     def process(self):
         """
         Read from the control file descriptor and potentially perform any
@@ -143,7 +156,7 @@ class TestControl:
         except BufferFullError as e:
             raise BadControlError(str(e)) from None
 
-        util.debug(f"got control line: {line}")
+        util.debug(f"got control line: {line} // eof: {self.stream.eof}")
 
         if self.stream.eof:
             self.eof = True
@@ -254,28 +267,28 @@ class TestControl:
             except ValueError as e:
                 raise BadReportJSONError(f"file entry {file_name} length: {str(e)}") from None
 
-            with self.reporter.open_tmpfile() as fd:
-                while file_length > 0:
-                    try:
-                        # try a more universal sendfile first, fall back to splice
+            try:
+                with self.reporter.open_file(file_name, name) as f:
+                    fd = f.fileno()
+                    while file_length > 0:
                         try:
-                            written = os.sendfile(fd, self.control_fd, None, file_length)
-                        except OSError as e:
-                            if e.errno == 22:  # EINVAL
-                                written = os.splice(self.control_fd, fd, file_length)
-                            else:
-                                raise
-                    except BlockingIOError:
+                            # try a more universal sendfile first, fall back to splice
+                            try:
+                                written = os.sendfile(fd, self.control_fd, None, file_length)
+                            except OSError as e:
+                                if e.errno == 22:  # EINVAL
+                                    written = os.splice(self.control_fd, fd, file_length)
+                                else:
+                                    raise
+                        except BlockingIOError:
+                            yield
+                            continue
+                        if written == 0:
+                            raise BadControlError("EOF when reading data")
+                        file_length -= written
                         yield
-                        continue
-                    if written == 0:
-                        raise BadControlError("EOF when reading data")
-                    file_length -= written
-                    yield
-                try:
-                    self.reporter.link_tmpfile_to(fd, file_name, name)
-                except FileExistsError:
-                    raise BadReportJSONError(f"file '{file_name}' already exists") from None
+            except FileExistsError:
+                raise BadReportJSONError(f"file '{file_name}' already exists") from None
 
         # either store partial result + return,
         # or load previous partial result and merge into it
@@ -304,7 +317,7 @@ class TestControl:
             if not testout:
                 raise BadReportJSONError("'testout' specified, but empty")
             try:
-                self.reporter.link_tmpfile_to(self.testout_fd, testout, name)
+                self.reporter.link_testout(testout, name)
             except FileExistsError:
                 raise BadReportJSONError(f"file '{testout}' already exists") from None
 

atex/fmf.py

@@ -1,4 +1,5 @@
 import re
+import collections
 from pathlib import Path
 
 # from system-wide sys.path
@@ -32,21 +33,44 @@ class FMFTests:
     """
     # TODO: usage example ^^^^
 
-    def __init__(self, fmf_tree, plan_name, context=None):
+    def __init__(
+        self, fmf_tree, plan_name=None, *,
+        names=None, filters=None, conditions=None, excludes=None,
+        context=None,
+    ):
         """
         'fmf_tree' is filesystem path somewhere inside fmf metadata tree,
         or a root fmf.Tree instance.
 
         'plan_name' is fmf identifier (like /some/thing) of a tmt plan
-        to use for discovering tests.
+        to use for discovering tests. If None, a dummy (empty) plan is used.
 
-        'context' is a dict like {'distro': 'rhel-9.6'} used for filtering
-        discovered tests.
+        'names', 'filters', 'conditions' and 'exclude' (all tuple/list)
+        are fmf tree filters (resolved by the fmf module), overriding any
+        existing tree filters in the plan's discover phase specifies, where:
+
+            'names' are test regexes like ["/some/test", "/another/test"]
+
+            'filters' are fmf-style filter expressions, as documented on
+            https://fmf.readthedocs.io/en/stable/modules.html#fmf.filter
+
+            'conditions' are python expressions whose namespace locals()
+            are set up to be a dictionary of the fmf tree. When any of the
+            expressions returns True, the tree is returned, ie.
+                ["environment['FOO'] == 'BAR'"]
+                ["'enabled' not in locals() or enabled"]
+            Note that KeyError is silently ignored and treated as False.
+
+            'excludes' are test regexes to exclude, format same as 'names'
+
+        'context' is a dict like {'distro': 'rhel-9.6'} used for additional
+        adjustment of the discovered fmf metadata.
         """
         # list of packages to install, as extracted from plan
         self.prepare_pkgs = []
         # list of scripts to run, as extracted from plan
         self.prepare_scripts = []
+        self.finish_scripts = []
         # dict of environment, as extracted from plan
         self.plan_env = {}
         # dict indexed by test name, value is dict with fmf-parsed metadata
@@ -54,21 +78,28 @@ class FMFTests:
         # dict indexed by test name, value is pathlib.Path of relative path
         # of the fmf metadata root towards the test metadata location
         self.test_dirs = {}
-        # fmf.Context instance, as used for test discovery
-        self.context = fmf.Context(**context) if context else fmf.Context()
 
+        # fmf.Context instance, as used for test discovery
+        context = fmf.Context(**context) if context else fmf.Context()
+        # allow the user to pass fmf.Tree directly, greatly speeding up the
+        # instantiation of multiple FMFTests instances
         tree = fmf_tree.copy() if isinstance(fmf_tree, fmf.Tree) else fmf.Tree(fmf_tree)
-        tree.adjust(context=self.context)
+        tree.adjust(context=context)
 
         # Path of the metadata root
         self.root = Path(tree.root)
 
         # lookup the plan first
-        plan = tree.find(plan_name)
-        if not plan:
-            raise ValueError(f"plan {plan_name} not found in {tree.root}")
-        if "test" in plan.data:
-            raise ValueError(f"plan {plan_name} appears to be a test")
+        if plan_name:
+            plan = tree.find(plan_name)
+            if not plan:
+                raise ValueError(f"plan {plan_name} not found in {tree.root}")
+            if "test" in plan.data:
+                raise ValueError(f"plan {plan_name} appears to be a test")
+        # fall back to a dummy plan
+        else:
+            class plan:  # noqa: N801
+                data = {}
 
         # gather and merge plan-defined environment variables
         #
@@ -88,13 +119,16 @@ class FMFTests:
         #     script:
         #       - some-command
         for entry in listlike(plan.data, "prepare"):
-            if "how" not in entry:
-                continue
-            if entry["how"] == "install":
+            if entry.get("how") == "install":
                 self.prepare_pkgs += listlike(entry, "package")
-            elif entry["how"] == "shell":
+            elif entry.get("how") == "shell":
                 self.prepare_scripts += listlike(entry, "script")
 
+        # gather all finish scripts, same as prepare scripts
+        for entry in listlike(plan.data, "finish"):
+            if entry.get("how") == "shell":
+                self.finish_scripts += listlike(entry, "script")
+
         # gather all tests selected by the plan
         #
         # discover:
@@ -105,49 +139,50 @@ class FMFTests:
         #       - some-test-regex
         #     exclude:
         #       - some-test-regex
-        if "discover" in plan.data:
-            discover = plan.data["discover"]
-            if not isinstance(discover, list):
-                discover = (discover,)
-
-            for entry in discover:
-                if entry.get("how") != "fmf":
-                    continue
-
-                filtering = {}
-                for meta_name in ("filter", "test", "exclude"):
-                    if value := listlike(entry, meta_name):
-                        filtering[meta_name] = value
-
-                children = tree.prune(
-                    names=filtering.get("test"),
-                    filters=filtering.get("filter"),
-                )
-                for child in children:
-                    # excludes not supported by .prune(), we have to do it here
-                    excludes = filtering.get("exclude")
-                    if excludes and any(re.match(x, child.name) for x in excludes):
-                        continue
-                    # only enabled tests
-                    if "enabled" in child.data and not child.data["enabled"]:
-                        continue
-                    # no manual tests and no stories
-                    if child.data.get("manual") or child.data.get("story"):
-                        continue
-                    # after adjusting above, any adjusts are useless, free some space
-                    if "adjust" in child.data:
-                        del child.data["adjust"]
-
-                    self.tests[child.name] = child.data
-                    # child.sources ie. ['/abs/path/to/some.fmf', '/abs/path/to/some/node.fmf']
-                    self.test_dirs[child.name] = \
-                        Path(child.sources[-1]).parent.relative_to(self.root)
-
-    def match(self, regex):
-        """
-        Yield test names that match 'regex', simulating how tmt discovers tests.
-        """
-        yield from (name for name in self.tests if re.match(regex, name))
+        plan_filters = collections.defaultdict(list)
+        for entry in listlike(plan.data, "discover"):
+            if entry.get("how") != "fmf":
+                continue
+            for meta_name in ("filter", "test", "exclude"):
+                if value := listlike(entry, meta_name):
+                    plan_filters[meta_name] += value
+
+        prune_kwargs = {}
+        if names:
+            prune_kwargs["names"] = names
+        elif "test" in plan_filters:
+            prune_kwargs["names"] = plan_filters["test"]
+        if filters:
+            prune_kwargs["filters"] = filters
+        elif "filter" in plan_filters:
+            prune_kwargs["filters"] = plan_filters["filter"]
+        if conditions:
+            prune_kwargs["conditions"] = conditions
+        if not excludes:
+            excludes = plan_filters.get("exclude")
+
+        # actually discover the tests
+        for child in tree.prune(**prune_kwargs):
+            # excludes not supported by .prune(), we have to do it here
+            if excludes and any(re.match(x, child.name) for x in excludes):
+                continue
+            # only tests
+            if "test" not in child.data:
+                continue
+            # only enabled tests
+            if "enabled" in child.data and not child.data["enabled"]:
+                continue
+            # no manual tests and no stories
+            if child.data.get("manual") or child.data.get("story"):
+                continue
+            # after adjusting above, any adjusts are useless, free some space
+            if "adjust" in child.data:
+                del child.data["adjust"]
+
+            self.tests[child.name] = child.data
+            # child.sources ie. ['/abs/path/to/some.fmf', '/abs/path/to/some/node.fmf']
+            self.test_dirs[child.name] = \
+                Path(child.sources[-1]).parent.relative_to(self.root)
 
 
 def test_pkg_requires(data, key="require"):
@@ -200,18 +235,3 @@ def all_pkg_requires(fmf_tests, key="require"):
 # context. Any other filters are applied afterwards to allow modification
 # of tree metadata by the adjust expressions. Ie.
 #     {'distro': 'rhel-9.6.0', 'arch': 'x86_64'}
-
-#Platform = collections.namedtuple("Platform", ["distro", "arch"])
-#
-#
-#def combine_platforms(fmf_path, plan_name, platforms):
-#    # TODO: document
-#    fmf_tests = {}
-#    tree = fmf.Tree(fmf_path)
-#    for platform in platforms:
-#        context = {"distro": platform.distro, "arch": platform.arch}
-#        fmf_tests[platform] = FMFTests(tree, plan_name, context=context)
-#    return fmf_tests
-
-# TODO: in Orchestrator, when a Provisioner becomes free, have it pick a test
-#       from the appropriate tests[platform] per the Provisioner's platform

atex/orchestrator/__init__.py

@@ -1,2 +1,3 @@
-from .aggregator import CSVAggregator  # noqa: F401
-from .orchestrator import Orchestrator  # noqa: F401
+#from .aggregator import CSVAggregator, JSONAggregator  # noqa: F401
+from .aggregator import JSONAggregator  # noqa: F401
+from .orchestrator import Orchestrator, OrchestratorError, FailedSetupError  # noqa: F401

atex/orchestrator/aggregator.py

@@ -1,4 +1,3 @@
-import csv
 import gzip
 import json
 import shutil
@@ -6,77 +5,82 @@ import threading
 from pathlib import Path
 
 
-class CSVAggregator:
-    """
-    Collects reported results as a GZIP-ed CSV and files (logs) from multiple
-    test runs under a shared directory.
+class JSONAggregator:
     """
+    Collects reported results as a GZIP-ed line-JSON and files (logs) from
+    multiple test runs under a shared directory.
+
+    Note that the aggregated JSON file *does not* use the test-based JSON format
+    described by executor/RESULTS.md - both use JSON, but are very different.
+
+    This aggergated format uses a top-level array (on each line) with a fixed
+    field order:
 
-    class _ExcelWithUnixNewline(csv.excel):
-        lineterminator = "\n"
+        platform, status, test name, subtest name, files, note
+
+    All these are strings except 'files', which is another (nested) array
+    of strings.
+
+    If a field is missing in the source result, it is translated to a null
+    value.
+    """
 
-    def __init__(self, csv_file, storage_dir):
+    def __init__(self, json_file, storage_dir):
         """
-        'csv_file' is a string/Path to a .csv.gz file with aggregated results.
+        'json_file' is a string/Path to a .json.gz file with aggregated results.
 
         'storage_dir' is a string/Path of the top-level parent for all
         per-platform / per-test files uploaded by tests.
         """
         self.lock = threading.RLock()
         self.storage_dir = Path(storage_dir)
-        self.csv_file = Path(csv_file)
-        self.csv_writer = None
-        self.results_gzip_handle = None
+        self.json_file = Path(json_file)
+        self.json_gzip_fobj = None
 
     def open(self):
-        if self.csv_file.exists():
-            raise FileExistsError(f"{self.csv_file} already exists")
-        f = gzip.open(self.csv_file, "wt", newline="")
-        try:
-            self.csv_writer = csv.writer(f, dialect=self._ExcelWithUnixNewline)
-        except:
-            f.close()
-            raise
-        self.results_gzip_handle = f
+        if self.json_file.exists():
+            raise FileExistsError(f"{self.json_file} already exists")
+        self.json_gzip_fobj = gzip.open(self.json_file, "wt", newline="\n")
 
         if self.storage_dir.exists():
             raise FileExistsError(f"{self.storage_dir} already exists")
         self.storage_dir.mkdir()
 
     def close(self):
-        self.results_gzip_handle.close()
-        self.results_gzip_handle = None
-        self.csv_writer = None
+        if self.json_gzip_fobj:
+            self.json_gzip_fobj.close()
+            self.json_gzip_fobj = None
 
     def __enter__(self):
-        self.open()
-        return self
+        try:
+            self.open()
+            return self
+        except Exception:
+            self.close()
+            raise
 
     def __exit__(self, exc_type, exc_value, traceback):
         self.close()
 
-    def ingest(self, platform, test_name, json_file, files_dir):
+    def ingest(self, platform, test_name, results_file, files_dir):
         """
-        Process 'json_file' (string/Path) for reported results and append them
-        to the overall aggregated CSV file, recursively copying over the dir
-        structure under 'files_dir' (string/Path) under the respective platform
-        and test name in the aggregated files storage dir.
+        Process 'results_file' (string/Path) for reported results and append
+        them to the overall aggregated line-JSON file, recursively copying over
+        the dir structure under 'files_dir' (string/Path) under the respective
+        platform and test name in the aggregated storage dir.
         """
-        # parse the JSON separately, before writing any CSV lines, to ensure
-        # that either all results from the test are ingested, or none at all
-        # (if one of the lines contains JSON errors)
-        csv_lines = []
-        with open(json_file) as json_fobj:
-            for raw_line in json_fobj:
-                result_line = json.loads(raw_line)
+        platform_dir = self.storage_dir / platform
+        test_dir = platform_dir / test_name.lstrip("/")
+        if test_dir.exists():
+            raise FileExistsError(f"{test_dir} already exists for {test_name}")
 
-                result_name = result_line.get("name")
-                if result_name:
-                    # sub-result; prefix test name
-                    result_name = f"{test_name}/{result_name}"
-                else:
-                    # result for test itself; use test name
-                    result_name = test_name
+        # parse the results separately, before writing any aggregated output,
+        # to ensure that either all results from the test are ingested, or none
+        # at all (ie. if one of the result lines contains JSON errors)
+        output_lines = []
+        with open(results_file) as results_fobj:
+            for raw_line in results_fobj:
+                result_line = json.loads(raw_line)
 
                 file_names = []
                 if "testout" in result_line:
@@ -84,23 +88,24 @@ class CSVAggregator:
                 if "files" in result_line:
                     file_names += (f["name"] for f in result_line["files"])
 
-                csv_lines.append((
+                output_line = (
                     platform,
                     result_line["status"],
-                    result_name,
-                    result_line.get("note", ""),
-                    *file_names,
-                ))
+                    test_name,
+                    result_line.get("name"),
+                    file_names,
+                    result_line.get("note"),
+                )
+                encoded = json.dumps(output_line, indent=None)
+                output_lines.append(encoded)
+
+        output_str = "\n".join(output_lines) + "\n"
 
         with self.lock:
-            self.csv_writer.writerows(csv_lines)
-            self.results_gzip_handle.flush()
+            self.json_gzip_fobj.write(output_str)
+            self.json_gzip_fobj.flush()
 
-        Path(json_file).unlink()
+        Path(results_file).unlink()
 
-        platform_dir = self.storage_dir / platform
         platform_dir.mkdir(exist_ok=True)
-        test_dir = platform_dir / test_name.lstrip("/")
-        if test_dir.exists():
-            raise FileExistsError(f"{test_dir} already exists for {test_name}")
-        shutil.move(files_dir, test_dir, copy_function=shutil.copy)
+        shutil.move(files_dir, test_dir)