atex 0.10__py3-none-any.whl → 0.12__py3-none-any.whl

atex/orchestrator/contest.py

@@ -0,0 +1,116 @@
+import collections
+
+from .. import util
+from .adhoc import AdHocOrchestrator
+
+
+# copy/pasted from the Contest repo, lib/virt.py
+def calculate_guest_tag(tags):
+    if "snapshottable" not in tags:
+        return None
+    name = "default"
+    if "with-gui" in tags:
+        name += "_gui"
+    if "uefi" in tags:
+        name += "_uefi"
+    if "fips" in tags:
+        name += "_fips"
+    return name
+
+
+class ContestOrchestrator(AdHocOrchestrator):
+    """
+    Orchestrator for the Contest test suite:
+        https://github.com/RHSecurityCompliance/contest
+
+    Includes SCAP content upload via rsync and other Contest-specific
+    optimizations (around VM snapshots and scheduling).
+    """
+    content_dir_on_remote = "/root/upstream-content"
+
+    def __init__(self, *args, content_dir, max_reruns=1, **kwargs):
+        """
+        'content_dir' is a filesystem path to ComplianceAsCode/content local
+        directory, to be uploaded to the tested systems.
+
+        'max_reruns' is an integer of how many times to re-try running a failed
+        test (which exited with non-0 or caused an Executor exception).
+        """
+        super().__init__(*args, **kwargs)
+        self.content_dir = content_dir
+        # indexed by test name, value being integer of how many times
+        self.reruns = collections.defaultdict(lambda: max_reruns)
+
+    def run_setup(self, sinfo):
+        super().run_setup(sinfo)
+        # upload pre-built content
+        sinfo.remote.rsync(
+            "-r", "--delete", "--exclude=.git/",
+            f"{self.content_dir}/",
+            f"remote:{self.content_dir_on_remote}",
+            func=util.subprocess_log,
+        )
+
+    @classmethod
+    def next_test(cls, to_run, all_tests, previous):
+        # fresh remote, prefer running destructive tests (which likely need
+        # clean OS) to get them out of the way and prevent them from running
+        # on a tainted OS later
+        if type(previous) is AdHocOrchestrator.SetupInfo:
+            for next_name in to_run:
+                next_tags = all_tests[next_name].get("tag", ())
+                util.debug(f"considering next_test for destructivity: {next_name}")
+                if "destructive" in next_tags:
+                    util.debug(f"chosen next_test: {next_name}")
+                    return next_name
+
+        # previous test was run and finished non-destructively,
+        # try to find a next test with the same Contest lib.virt guest tags
+        # as the previous one, allowing snapshot reuse by Contest
+        elif type(previous) is AdHocOrchestrator.FinishedInfo:
+            finished_tags = all_tests[previous.test_name].get("tag", ())
+            util.debug(f"previous finished test on {previous.remote}: {previous.test_name}")
+            # if Guest tag is None, don't bother searching
+            if finished_guest_tag := calculate_guest_tag(finished_tags):
+                for next_name in to_run:
+                    util.debug(f"considering next_test with tags {finished_tags}: {next_name}")
+                    next_tags = all_tests[next_name].get("tag", ())
+                    next_guest_tag = calculate_guest_tag(next_tags)
+                    if next_guest_tag and finished_guest_tag == next_guest_tag:
+                        util.debug(f"chosen next_test: {next_name}")
+                        return next_name
+
+        # fallback to the default next_test()
+        return super().next_test(to_run, all_tests, previous)
+
+    @staticmethod
+    def destructive(info, test_data):
+        # if Executor ended with an exception (ie. duration exceeded),
+        # consider the test destructive
+        if info.exception:
+            return True
+
+        # if the test returned non-0 exit code, it could have thrown
+        # a python exception of its own, or (if bash) aborted abruptly
+        # due to 'set -e', don't trust the remote, consider it destroyed
+        # (0 = pass, 2 = fail, anything else = bad)
+        if info.exit_code not in [0,2]:
+            return True
+
+        # if the test was destructive, assume the remote is destroyed
+        tags = test_data.get("tag", ())
+        if "destructive" in tags:
+            return True
+
+        return False
+
+    def should_be_rerun(self, info, test_data):  # noqa: ARG004, ARG002
+        remote_with_test = f"{info.remote}: '{info.test_name}'"
+
+        reruns_left = self.reruns[info.test_name]
+        util.info(f"{remote_with_test}: {reruns_left} reruns left")
+        if reruns_left > 0:
+            self.reruns[info.test_name] -= 1
+            return True
+        else:
+            return False

atex/provisioner/__init__.py

@@ -56,10 +56,6 @@ class Provisioner:
     that .get_remote() will ever return a Remote. Ie. the caller can call
     .provision(count=math.inf) to receive as many remotes as the Provisioner
     can possibly supply.
-
-    TODO: remove .defer_stop() (or stop_defer) and mention this below:
-    Note that .stop() or .defer_stop() may be called from a different
-    thread, asynchronously to any other functions.
     """
 
     def provision(self, count=1):
@@ -93,18 +89,6 @@ class Provisioner:
         """
         raise NotImplementedError(f"'stop' not implemented for {self.__class__.__name__}")
 
-    def stop_defer(self):
-        """
-        Enable an external caller to stop the Provisioner instance,
-        deferring resource deallocation to the caller.
-
-        Return an iterable of argument-free thread-safe callables that can be
-        called, possibly in parallel, to free up resources.
-        Ie. a list of 200 .release() functions, to be called in a thread pool
-        by the user, speeding up cleanup.
-        """
-        return (self.stop,)
-
     def __enter__(self):
         try:
             self.start()

atex/provisioner/libvirt/libvirt.py

@@ -260,7 +260,19 @@ class LibvirtCloningProvisioner(Provisioner):
             # by libvirt natively (because treating nvram as a storage pool
             # is a user hack)
             for p in conn.listAllStoragePools():
-                p.refresh()
+                # retry a few times to work around a libvirt race condition
+                for _ in range(10):
+                    try:
+                        p.refresh()
+                    except libvirt.libvirtError as e:
+                        if "domain is not running" in str(e):
+                            break
+                        elif "has asynchronous jobs running" in str(e):
+                            continue
+                        else:
+                            raise
+                    else:
+                        break
             try:
                 nvram_vol = conn.storageVolLookupByPath(nvram_path)
             except libvirt.libvirtError as e:

atex/provisioner/testingfarm/api.py

@@ -2,6 +2,7 @@ import os
 import re
 import time
 import tempfile
+import datetime
 import textwrap
 import threading
 import subprocess
@@ -14,11 +15,11 @@ from ... import util
 import json
 import urllib3
 
-DEFAULT_API_URL = "https://api.testing-farm.io/v0.1"
+DEFAULT_API_URL = "https://api.testing-farm.io"
 
 DEFAULT_RESERVE_TEST = {
     "url": "https://github.com/RHSecurityCompliance/atex-reserve",
-    "ref": "v0.10",
+    "ref": "0.12",
     "path": ".",
     "name": "/plans/reserve",
 }
@@ -34,10 +35,10 @@ _http = urllib3.PoolManager(
     maxsize=10,
     block=True,
     retries=urllib3.Retry(
-        total=10,
+        total=24,
         # account for API restarts / short outages
-        backoff_factor=60,
-        backoff_max=600,
+        backoff_factor=10,
+        backoff_max=3600,
         # retry on API server errors too, not just connection issues
         status=10,
         status_forcelist={403,404,408,429,500,502,503,504},
@@ -85,8 +86,8 @@ class TestingFarmAPI:
         self.api_url = url
         self.api_token = token or os.environ.get("TESTING_FARM_API_TOKEN")
 
-    def _query(self, method, path, *args, headers=None, auth=True, **kwargs):
-        url = f"{self.api_url}{path}"
+    def _query(self, method, path, *args, headers=None, auth=True, version="v0.1", **kwargs):
+        url = f"{self.api_url}/{version}{path}"
         if self.api_token and auth:
             if headers is not None:
                 headers["Authorization"] = f"Bearer {self.api_token}"
@@ -137,7 +138,7 @@ class TestingFarmAPI:
             if not self.api_token:
                 raise ValueError("composes() requires an auth token to identify ranch")
             ranch = self.whoami()["token"]["ranch"]
-        return self._query("GET", f"/composes/{ranch}")
+        return self._query("GET", f"/composes/{ranch}", version="v0.2")
 
     def search_requests(
         self, *, state, ranch=None,
@@ -180,6 +181,52 @@ class TestingFarmAPI:
 
         return self._query("GET", "/requests", fields=fields, auth=mine)
 
+    def search_requests_paged(self, *args, page=43200, **kwargs):
+        """
+        An unofficial wrapper for search_requests() that can search a large
+        interval incrementally (in "pages") and yield batches of results.
+
+        Needs 'created_after', with 'created_before' defaulting to now().
+
+        'page' specifies the time interval of one page, in seconds.
+
+        'args' and 'kwargs' are passed to search_requests().
+        """
+        assert "created_after" in kwargs, "at least 'created_after' is needed for paging"
+
+        def from_iso8601(date):
+            dt = datetime.datetime.fromisoformat(date)
+            # if no TZ is specified, treat it as UTC, not localtime
+            if dt.tzinfo is None:
+                dt = dt.replace(tzinfo=datetime.UTC)
+            # convert to UTC
+            else:
+                dt = dt.astimezone(datetime.UTC)
+            return dt
+
+        after = from_iso8601(kwargs["created_after"])
+        if kwargs.get("created_before"):
+            before = from_iso8601(kwargs["created_before"])
+        else:
+            before = datetime.datetime.now(datetime.UTC)
+
+        # scale down page size to fit between after/before
+        page = min(page, (before - after).total_seconds())
+
+        start = after
+        while start < before:
+            end = start + datetime.timedelta(seconds=page)
+            # clamp to real 'before'
+            end = min(end, before)
+            new_kwargs = kwargs | {
+                "created_after": start.isoformat(),
+                "created_before": end.isoformat(),
+            }
+            found = self.search_requests(*args, **new_kwargs)
+            if found is not None:
+                yield from found
+            start = end
+
     def get_request(self, request_id):
         """
         'request_id' is the UUID (string) of the request.
@@ -438,7 +485,6 @@ class Reserve:
         'api' is a TestingFarmAPI instance - if unspecified, a sensible default
         will be used.
         """
-        util.info(f"will reserve compose:{compose} on arch:{arch} for {timeout}min")
         spec = {
             "test": {
                 "fmf": reserve_test or DEFAULT_RESERVE_TEST,
@@ -571,7 +617,8 @@ class Reserve:
             #  installs our ssh pubkey into authorized_keys)
             ssh_attempt_cmd = (
                 "ssh", "-q", "-i", ssh_key.absolute(), "-oConnectionAttempts=60",
-               "-oStrictHostKeyChecking=no", "-oUserKnownHostsFile=/dev/null",
+                "-oStrictHostKeyChecking=no", "-oUserKnownHostsFile=/dev/null",
+                "-oBatchMode=yes",
                 f"{ssh_user}@{ssh_host}", "exit 123",
             )
             while True:

atex/provisioner/testingfarm/testingfarm.py

@@ -1,6 +1,7 @@
 import time
 import tempfile
 import threading
+import concurrent.futures
 
 from ... import connection, util
 from .. import Provisioner, Remote
@@ -49,7 +50,12 @@ class TestingFarmRemote(Remote, connection.ssh.ManagedSSHConnection):
 
 
 class TestingFarmProvisioner(Provisioner):
+    # maximum number of TF requests the user can .provision(),
+    # as a last safety measure against Orchestrator(remotes=math.inf)
     absolute_max_remotes = 100
+    # number of parallel threads running HTTP DELETE calls to cancel
+    # TF requests on .stop() or Context Manager exit
+    stop_release_workers = 10
 
     def __init__(self, compose, arch="x86_64", *, max_retries=10, **reserve_kwargs):
         """
@@ -129,6 +135,7 @@ class TestingFarmProvisioner(Provisioner):
         # instantiate a class Reserve from the Testing Farm api module
         # (which typically provides context manager, but we use its .reserve()
         #  and .release() functions directly)
+        util.info(f"{repr(self)}: reserving new remote")
         tf_reserve = api.Reserve(
             compose=self.compose,
             arch=self.arch,
@@ -154,29 +161,25 @@ class TestingFarmProvisioner(Provisioner):
             self.ssh_key, self.ssh_pubkey = util.ssh_keygen(self._tmpdir.name)
 
     def stop(self):
-        with self.lock:
-            # abort reservations in progress
-            while self.reserving:
-                # testingfarm api.Reserve instances
-                self.reserving.pop().release()
-            # cancel/release all Remotes ever created by us
-            while self.remotes:
-                # TestingFarmRemote instances
-                self.remotes.pop().release()
-            # explicitly remove the tmpdir rather than relying on destructor
-            self._tmpdir.cleanup()
-            self._tmpdir = None
+        release_funcs = []
 
-    def stop_defer(self):
-        callables = []
         with self.lock:
-            callables += (f.release for f in self.reserving)
+            release_funcs += (f.release for f in self.reserving)
             self.reserving = []
-            callables += (r.release for r in self.remotes)
-            self.remotes = []  # just in case
-            callables.append(self._tmpdir.cleanup)
+            release_funcs += (r.release for r in self.remotes)
+            self.remotes = []  # just in case of a later .start()
+
+        # parallelize at most stop_release_workers TF API release (DELETE) calls
+        if release_funcs:
+            workers = min(len(release_funcs), self.stop_release_workers)
+            with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as ex:
+                for func in release_funcs:
+                    ex.submit(func)
+
+        with self.lock:
+            # explicitly remove the tmpdir rather than relying on destructor
+            self._tmpdir.cleanup()
             self._tmpdir = None
-        return callables
 
     def provision(self, count=1):
         with self.lock:
@@ -198,10 +201,11 @@ class TestingFarmProvisioner(Provisioner):
                 # always non-blocking
                 return None
             except (api.TestingFarmError, connection.ssh.SSHError) as e:
+                exc_str = f"{type(e).__name__}({e})"
                 with self.lock:
                     if self.retries > 0:
                         util.warning(
-                            f"caught while reserving a TF system: {repr(e)}, "
+                            f"caught while reserving a TF system: {exc_str}, "
                             f"retrying ({self.retries} left)",
                         )
                         self.retries -= 1
@@ -212,7 +216,7 @@ class TestingFarmProvisioner(Provisioner):
                             return None
                     else:
                         util.warning(
-                            f"caught while reserving a TF system: {repr(e)}, "
+                            f"caught while reserving a TF system: {exc_str}, "
                             "exhausted all retries, giving up",
                         )
                         raise

atex/util/log.py

@@ -30,7 +30,7 @@ skip_levels = {
 
 def _log_msg(logger_func, *args, stacklevel=1, **kwargs):
     # inspect.stack() is MUCH slower
-    caller = inspect.currentframe().f_back.f_back
+    caller = inspect.currentframe().f_back.f_back  # TODO: sys._getframe(2)
     extra_levels = 2  # skip this func and the debug/info/warning parent
     while caller.f_back:
         code = caller.f_code

atex/util/subprocess.py

@@ -1,6 +1,6 @@
 import subprocess
 
-from .log import debug, extradebug
+from .log import extradebug
 
 
 def subprocess_run(cmd, **kwargs):
@@ -9,7 +9,7 @@ def subprocess_run(cmd, **kwargs):
     """
     # when logging, skip current stack frame - report the place we were called
     # from, not util.subprocess_run itself
-    debug(f"running: '{cmd}' with {kwargs=}")
+    extradebug(f"running: '{cmd}' with {kwargs=}")
     return subprocess.run(cmd, **kwargs)
 
 
@@ -17,7 +17,7 @@ def subprocess_output(cmd, *, check=True, text=True, **kwargs):
     """
     A wrapper simulating subprocess.check_output() via a modern .run() API.
     """
-    debug(f"running: '{cmd}' with {check=}, {text=} and {kwargs=}")
+    extradebug(f"running: '{cmd}' with {check=}, {text=} and {kwargs=}")
     proc = subprocess.run(cmd, check=check, text=text, stdout=subprocess.PIPE, **kwargs)
     return proc.stdout.rstrip("\n") if text else proc.stdout
 
@@ -26,7 +26,7 @@ def subprocess_Popen(cmd, **kwargs):  # noqa: N802
     """
     A simple wrapper for the real subprocess.Popen() that logs the command used.
     """
-    debug(f"running: '{cmd}' with {kwargs=}")
+    extradebug(f"running: '{cmd}' with {kwargs=}")
     return subprocess.Popen(cmd, **kwargs)
 
 
@@ -56,7 +56,7 @@ def subprocess_stream(cmd, *, stream="stdout", check=False, input=None, **kwargs
         all_kwargs["stdin"] = subprocess.PIPE
     all_kwargs |= kwargs
 
-    debug(f"running: '{cmd}' with {all_kwargs=}")
+    extradebug(f"running: '{cmd}' with {all_kwargs=}")
     proc = subprocess.Popen(cmd, **all_kwargs)
 
     def generate_lines():
@@ -80,7 +80,7 @@ def subprocess_log(cmd, **kwargs):
 
     Uses subprocess_stream() to gather the lines.
     """
-    debug(f"running: '{cmd}' with {kwargs=}")
+    extradebug(f"running: '{cmd}' with {kwargs=}")
     _, lines = subprocess_stream(cmd, **kwargs)
     for line in lines:
         extradebug(line)

{atex-0.10.dist-info → atex-0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atex
-Version: 0.10
+Version: 0.12
 Summary: Ad-hoc Test EXecutor
 Project-URL: Homepage, https://github.com/RHSecurityCompliance/atex
 License-Expression: GPL-3.0-or-later

{atex-0.10.dist-info → atex-0.12.dist-info}/RECORD

@@ -1,44 +1,45 @@
 atex/__init__.py,sha256=LdX67gprtHYeAkjLhFPKzpc7ECv2rHxUbHKDGbGXO1c,517
 atex/fmf.py,sha256=gkJXIaRO7_KvwJR-V6Tc1NVn4a9Hq7hoBLQLhxYIdbg,8834
-atex/aggregator/__init__.py,sha256=uNnYSyDGXjknxckI8MFfl-C8_gin8FwQchiq-UOyP6I,1744
-atex/aggregator/json.py,sha256=x1zim9O2olzBh185NYWo5N96fixB2oxCamoOZwmgR9w,3330
-atex/cli/__init__.py,sha256=X5XxkDEDXE4tJAjwt5ShRHCFTXDK-2zvxQ34opmueUc,2768
-atex/cli/fmf.py,sha256=HfbTgFbCwK4Nuyq6vtGutcq_4-4kj-tmoqzXUn3AYtY,3573
+atex/aggregator/__init__.py,sha256=8mN-glHdzR4icKAUGO4JPodsTrLMdJoeuZsO2CTbhyU,1773
+atex/aggregator/json.py,sha256=tpoUZoZM8EMYhZKwVr4LRtgEIDjRxC11BIKVXZKYPOs,10441
+atex/cli/__init__.py,sha256=Ew2z-gC0jvOmU_DqYgXVQla3p1rTnrz64I63q52aHv4,2899
+atex/cli/fmf.py,sha256=pvj_OIp6XT_nVUwziL7-v_HNbyAtuUmb7k_Ey_KkFJc,3616
 atex/cli/libvirt.py,sha256=6tt5ANb8XBBRXOQsYPTWILThKqf-gvt5AZh5Dctg2PA,3782
-atex/cli/testingfarm.py,sha256=HGlqrkhanUMo2CqKxmM3ACgptWtxm0gICyEGf7O6Qc0,9078
+atex/cli/testingfarm.py,sha256=MXfcKnzbmr71LrTpJcIghC6SfB4EBkKXh3Yy5SZlUUc,10744
 atex/connection/__init__.py,sha256=dj8ZBcEspom7Z_UjecfLGBRNvLZ3dyGR9q19i_B4xpY,3880
 atex/connection/podman.py,sha256=1T56gh1TgbcQWpTIJHL4NaxZOI6aMg7Xp7sn6PQQyBk,1911
 atex/connection/ssh.py,sha256=9A57b9YR_HI-kIu06Asic1y__JPVXEheDZxjbG2Qcsc,13460
-atex/executor/__init__.py,sha256=XCfhi7QDELjey7N1uzhMjc46Kp1Jsd5bOCf52I27SCE,85
+atex/executor/__init__.py,sha256=nmYJCbC36fRGGkjoniFJmsq-sqFw8YS2ndf4q_loVM0,471
 atex/executor/duration.py,sha256=x06sItKOZi6XA8KszQwZGpIb1Z_L-HWqIwZKo2SDo0s,1759
-atex/executor/executor.py,sha256=JLFR9cZjSlUdAlAlLct6WuzmYbtjGtSobxvsToQum6M,15738
-atex/executor/reporter.py,sha256=MceFmHFt0bTEClBZbRI1WnFbfMhR0e1noOzcu7gjKuQ,3403
-atex/executor/scripts.py,sha256=riJAQWsV-BFGkJwR2Dmf3R0ZRRZJs9w9iYnPpYaQNaE,5618
-atex/executor/testcontrol.py,sha256=mVrLwQUnDRfUq-5diz-80UvCWWxn1TkcBgmAKhKNb5E,12696
+atex/executor/executor.py,sha256=WJXPWQo6VQhZgXORVVyvTDAdOQbbZz26E7FpwizbGIk,16126
+atex/executor/reporter.py,sha256=QbzBkaXuhI6lsTYrTlp7O5W9d6etR0KjDdH-J59cXWM,3357
+atex/executor/scripts.py,sha256=1u5ZEGJ7nIvkqbRK3uVusOkineVM8DXo4kAlH2MdQbg,5877
+atex/executor/testcontrol.py,sha256=iju_Cl32D8NHH1ePN1lykR1noP8-0eBDLQ5-V_9DqF0,12834
 atex/orchestrator/__init__.py,sha256=8Q1YknyibilXLjWRYkHm_Mr2HMm0SRw8Zv39KypeASM,2059
-atex/orchestrator/adhoc.py,sha256=GnvHLlCHeJ_nQ8doEjMuDzqmu4XZorI7ZzOtG_C08tU,18451
-atex/provisioner/__init__.py,sha256=2eepmEznq94tbam9VSWbsGFrZZpWeNSVlsTczGxjNuQ,4667
+atex/orchestrator/adhoc.py,sha256=VUwHX71Vb6eRLzW3Z3KDZdck7p0PiwzAZrOuUKMkwtM,19667
+atex/orchestrator/contest.py,sha256=SuxT9uZtcs_DEsA3hHyKgrIWNrDeqCCWd3-hy3sHytY,4572
+atex/provisioner/__init__.py,sha256=6hZxQlvTQ0yWWqCRCPqWMoYuim5wDMCcDIYHF-nIfMs,4013
 atex/provisioner/libvirt/VM_PROVISION,sha256=7pkZ-ozgTyK4qNGC-E-HUznr4IhbosWSASbB72Gknl8,2664
 atex/provisioner/libvirt/__init__.py,sha256=pKG5IpZSC2IHs5wL2ecQx_fd9AzAXEbZmDzA7RyZsfM,119
-atex/provisioner/libvirt/libvirt.py,sha256=rtxowv5DpgcWsGRXYF29n6S9x_cgXRVgqY41DiFu920,18431
+atex/provisioner/libvirt/libvirt.py,sha256=ZKctK2B51olvWvLxz2pZ2s6LtX_7EJ43LvlyJHnI1Ho,18955
 atex/provisioner/libvirt/locking.py,sha256=AXtDyidZNmUoMmrit26g9iTHDqInrzL_RSQEoc_EAXw,5669
 atex/provisioner/libvirt/setup-libvirt.sh,sha256=oCMy9SCnbC_QuAzO2sFwvB5ui1kMQ6uviHsgdXyoFXc,2428
 atex/provisioner/podman/__init__.py,sha256=dM0JzQXWX7edtWSc0KH0cMFXAjArFn2Vme4j_ZMsdYA,138
 atex/provisioner/podman/podman.py,sha256=ztRypoakSf-jF04iER58tEMUZ4Y6AuzIpNpFXp44bB4,4997
 atex/provisioner/testingfarm/__init__.py,sha256=kZncgLGdRCR4FMaRQr2GTwJ8vjlA-24ri8JO2ueZJuw,113
-atex/provisioner/testingfarm/api.py,sha256=UcMN61nBr3wqEd5KSR5Xhv1-TS7nSPFvk2byb6PdIs8,21811
-atex/provisioner/testingfarm/testingfarm.py,sha256=OI-a99xALaiYf-y5037WFVxY1g2H2y1xEKxHBdUQvfg,8271
+atex/provisioner/testingfarm/api.py,sha256=K3s87rWNqZ6q1AMkjYaNTNqIOZR-Bl1JonbKx67O9pQ,23549
+atex/provisioner/testingfarm/testingfarm.py,sha256=yvQzWat92B4UnJNZzCLI8mpAKf_QvHUKyKbjlk5123Q,8573
 atex/util/__init__.py,sha256=cWHFbtQ4mDlKe6lXyPDWRmWJOTcHDGfVuW_-GYa8hB0,1473
 atex/util/dedent.py,sha256=SEuJMtLzqz3dQ7g7qyZzEJ9VYynVlk52tQCJY-FveXo,603
 atex/util/libvirt.py,sha256=kDZmT6xLYEZkQNLZY98gJ2M48DDWXxHF8rQY9PnjB3U,660
-atex/util/log.py,sha256=KVR7ep8n5wtghsvBFCtHiPsMAQBdAmK83E_Jec5t4cU,2230
+atex/util/log.py,sha256=GfdbLtpRkQoIkRU7AqWDWbJV7yZIpS4MsXhUomZqWjQ,2256
 atex/util/named_mapping.py,sha256=UBMe9TetjV-DGPhjYjJ42YtC40FVPKAAEROXl9MA5fo,4700
 atex/util/path.py,sha256=x-kXqiWCVodfZWbEwtC5A8LFvutpDIPYv2m0boZSlXU,504
 atex/util/ssh_keygen.py,sha256=9yuSl2yBV7pG3Qfsf9tossVC00nbIUrAeLdbwTykpjk,384
-atex/util/subprocess.py,sha256=PQBxcQJPapP1ZLO4LqENyrxxCbNAxtJDNNlBV5DcD9k,2953
+atex/util/subprocess.py,sha256=_oQN8CNgGoH9GAR6nZlpujYe2HjXFBcCuIkLPw-IxJ4,2971
 atex/util/threads.py,sha256=c8hsEc-8SqJGodInorv_6JxpiHiSkGFGob4qbMmOD2M,3531
-atex-0.10.dist-info/METADATA,sha256=evOBYvVboY2T8eGrAKy64UpyeuFKSMLGz8pUz8Sstm8,3050
-atex-0.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-atex-0.10.dist-info/entry_points.txt,sha256=pLqJdcfeyQTgup2h6dWb6SvkHhtOl-W5Eg9zV8moK0o,39
-atex-0.10.dist-info/licenses/COPYING.txt,sha256=oEuj51jdmbXcCUy7pZ-KE0BNcJTR1okudRp5zQ0yWnU,670
-atex-0.10.dist-info/RECORD,,
+atex-0.12.dist-info/METADATA,sha256=v2DW_JNAKGa7yF6IVOpICXMant1I2qQNlj69Vxcv3rs,3050
+atex-0.12.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+atex-0.12.dist-info/entry_points.txt,sha256=pLqJdcfeyQTgup2h6dWb6SvkHhtOl-W5Eg9zV8moK0o,39
+atex-0.12.dist-info/licenses/COPYING.txt,sha256=oEuj51jdmbXcCUy7pZ-KE0BNcJTR1okudRp5zQ0yWnU,670
+atex-0.12.dist-info/RECORD,,

{atex-0.10.dist-info → atex-0.12.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any