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

atex/provision/testingfarm/testingfarm.py

@@ -0,0 +1,236 @@
+import time
+import tempfile
+import threading
+
+from ... import connection, util
+from .. import Provisioner, Remote
+
+from . import api
+
+
+class TestingFarmRemote(Remote, connection.ssh.ManagedSSHConn):
+    """
+    Built on the official Remote API, pulling in the Connection API
+    as implemented by ManagedSSHConn.
+    """
+
+    def __init__(self, ssh_options, *, release_hook, provisioner):
+        """
+        'ssh_options' are a dict, passed to ManagedSSHConn __init__().
+
+        'release_hook' is a callable called on .release() in addition
+        to disconnecting the connection.
+        """
+        # start with empty ssh options, we'll fill them in later
+        super().__init__(options=ssh_options)
+        self.release_hook = release_hook
+        self.provisioner = provisioner
+        self.lock = threading.RLock()
+        self.release_called = False
+
+    def release(self):
+        with self.lock:
+            if not self.release_called:
+                self.release_called = True
+            else:
+                return
+        self.release_hook(self)
+        self.disconnect()
+
+    # not /technically/ a valid repr(), but meh
+    def __repr__(self):
+        class_name = self.__class__.__name__
+        compose = self.provisioner.compose
+        arch = self.provisioner.arch
+        return f"{class_name}({compose} @ {arch}, {hex(id(self))})"
+
+#    def alive(self):
+#        return self.valid
+
+    # TODO: def __str__(self):  as root@1.2.3.4 and arch, ranch, etc.
+
+
+class TestingFarmProvisioner(Provisioner):
+    # TODO: have max_systems as (min,default,max) tuple; have an algorithm that
+    #       starts at default and scales up/down as needed
+
+    def __init__(self, compose, arch="x86_64", *, max_systems=1, timeout=60, max_retries=10):
+        """
+        'compose' is a Testing Farm compose to prepare.
+
+        'arch' is an architecture associated with the compose.
+
+        'max_systems' is an int of how many systems to reserve (and keep
+        reserved) in an internal pool.
+
+        'timeout' is the maximum Testing Farm pipeline timeout (waiting for
+        a system + OS installation + reservation time).
+
+        'max_retries' is a maximum number of provisioning (Testing Farm) errors
+        that will be reprovisioned before giving up.
+        """
+        super().__init__()
+        self.compose = compose  # TODO: translate "centos9" to "CentOS-Stream-9"
+        self.arch = arch
+        self.max_systems = max_systems
+        self.timeout = timeout
+        self.retries = max_retries
+        self._tmpdir = None
+        self.ssh_key = self.ssh_pubkey = None
+        self.queue = util.ThreadQueue(daemon=True)
+        self.tf_api = api.TestingFarmAPI()
+
+        # TF Reserve instances (not Remotes) actively being provisioned,
+        # in case we need to call their .release() on abort
+        self.reserving = []
+
+        # active TestingFarmRemote instances, ready to be handed over to the user,
+        # or already in use by the user
+        self.remotes = []
+
+    def _wait_for_reservation(self, tf_reserve, initial_delay):
+        # assuming this function will be called many times, attempt to
+        # distribute load on TF servers
+        # (we can sleep here as this code is running in a separate thread)
+        if initial_delay:
+            util.debug(f"delaying for {initial_delay}s to distribute load")
+            time.sleep(initial_delay)
+
+        # 'machine' is api.Reserve.ReservedMachine namedtuple
+        machine = tf_reserve.reserve()
+
+        # connect our Remote to the machine via its class Connection API
+        ssh_options = {
+            "Hostname": machine.host,
+            "User": machine.user,
+            "Port": machine.port,
+            "IdentityFile": machine.ssh_key,
+        }
+
+        def release_hook(remote):
+            # remove from the list of remotes inside this Provisioner
+            with self.lock:
+                try:
+                    self.remotes.remove(remote)
+                except ValueError:
+                    pass
+            # call TF API, cancel the request, etc.
+            tf_reserve.release()
+
+        remote = TestingFarmRemote(
+            ssh_options,
+            release_hook=release_hook,
+            provisioner=self,
+        )
+        remote.connect()
+
+        # since the system is fully ready, stop tracking its reservation
+        # and return the finished Remote instance
+        with self.lock:
+            self.remotes.append(remote)
+            self.reserving.remove(tf_reserve)
+
+        return remote
+
+    def _schedule_one_reservation(self, initial_delay=None):
+        # instantiate a class Reserve from the Testing Farm api module
+        # (which typically provides context manager, but we use its .reserve()
+        #  and .release() functions directly)
+        tf_reserve = api.Reserve(
+            compose=self.compose,
+            arch=self.arch,
+            timeout=self.timeout,
+            ssh_key=self.ssh_key,
+            api=self.tf_api,
+        )
+
+        # add it to self.reserving even before we schedule a provision,
+        # to avoid races on suddent abort
+        with self.lock:
+            self.reserving.append(tf_reserve)
+
+        # start a background wait
+        self.queue.start_thread(
+            target=self._wait_for_reservation,
+            args=(tf_reserve, initial_delay),
+        )
+
+    def start(self):
+        with self.lock:
+            self._tmpdir = tempfile.TemporaryDirectory()
+            self.ssh_key, self.ssh_pubkey = util.ssh_keygen(self._tmpdir.name)
+            # start up all initial reservations
+            for i in range(self.max_systems):
+                delay = (api.API_QUERY_DELAY / self.max_systems) * i
+                #self.queue.start_thread(target=self._schedule_one_reservation, args=(delay,))
+                self._schedule_one_reservation(delay)
+
+    def stop(self):
+        with self.lock:
+            # abort reservations in progress
+            for tf_reserve in self.reserving:
+                tf_reserve.release()
+            self.reserving = []
+            # cancel/release all Remotes ever created by us
+            for remote in self.remotes:
+                remote.release()
+            self.remotes = []  # just in case
+            # explicitly remove the tmpdir rather than relying on destructor
+            self._tmpdir.cleanup()
+            self._tmpdir = None
+
+    def stop_defer(self):
+        callables = []
+        with self.lock:
+            callables += (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)
+            self._tmpdir = None
+        return callables
+
+    def get_remote(self, block=True):
+        # fill .release()d remotes back up with reservations
+        with self.lock:
+            deficit = self.max_systems - len(self.remotes) - len(self.reserving)
+            for i in range(deficit):
+                delay = (api.API_QUERY_DELAY / deficit) * i
+                self._schedule_one_reservation(delay)
+
+        while True:
+            # otherwise wait on a queue of Remotes being provisioned
+            try:
+                return self.queue.get(block=block)  # thread-safe
+            except util.ThreadQueue.Empty:
+                # always non-blocking
+                return None
+            except (api.TestingFarmError, connection.ssh.SSHError) as e:
+                with self.lock:
+                    if self.retries > 0:
+                        util.warning(
+                            f"caught while reserving a TF system: {repr(e)}, "
+                            f"retrying ({self.retries} left)",
+                        )
+                        self.retries -= 1
+                        self._schedule_one_reservation()
+                        if block:
+                            continue
+                        else:
+                            return None
+                    else:
+                        util.warning(
+                            f"caught while reserving a TF system: {repr(e)}, "
+                            "exhausted all retries, giving up",
+                        )
+                        raise
+
+    # not /technically/ a valid repr(), but meh
+    def __repr__(self):
+        class_name = self.__class__.__name__
+        reserving = len(self.reserving)
+        remotes = len(self.remotes)
+        return (
+            f"{class_name}({self.compose} @ {self.arch}, {reserving} reserving, "
+            f"{remotes} remotes, {hex(id(self))})"
+        )

atex/util/__init__.py

@@ -1,7 +1,3 @@
-"""
-TODO some description about utilities
-"""
-
 import importlib as _importlib
 import pkgutil as _pkgutil
 import inspect as _inspect
@@ -17,21 +13,21 @@ def __dir__():
 # (function to avoid polluting global namespace with extra variables)
 def _import_submodules():
     for info in _pkgutil.iter_modules(__spec__.submodule_search_locations):
-        mod = _importlib.import_module(f'.{info.name}', __name__)
+        mod = _importlib.import_module(f".{info.name}", __name__)
 
         # if the module defines __all__, just use it
-        if hasattr(mod, '__all__'):
+        if hasattr(mod, "__all__"):
             keys = mod.__all__
         else:
             # https://docs.python.org/3/reference/executionmodel.html#binding-of-names
-            keys = (x for x in dir(mod) if not x.startswith('_'))
+            keys = (x for x in dir(mod) if not x.startswith("_"))
 
         for key in keys:
             attr = getattr(mod, key)
 
             # avoid objects that belong to other known modules
             # (ie. imported function from another util module)
-            if hasattr(attr, '__module__'):
+            if hasattr(attr, "__module__"):
                 if attr.__module__ != mod.__name__:
                     continue
             # avoid some common pollution / imports
@@ -39,8 +35,7 @@ def _import_submodules():
             if _inspect.ismodule(attr):
                 continue
             # do not override already processed objects (avoid duplicates)
-            if key in __all__:
-                raise AssertionError(f"tried to override already-imported '{key}'")
+            assert key not in __all__, f"tried to override already-imported '{key}'"
 
             globals()[key] = attr
             __all__.append(key)

atex/util/dedent.py

@@ -22,4 +22,4 @@ def dedent(text):
     Like textwrap.dedent(), but also strip leading and trailing spaces/newlines
     up to the content.
     """
-    return textwrap.dedent(text.lstrip('\n').rstrip(' \n'))
+    return textwrap.dedent(text.lstrip("\n").rstrip(" \n"))

atex/util/log.py

@@ -2,7 +2,15 @@ import inspect
 import logging
 from pathlib import Path
 
-_logger = logging.getLogger('atex')
+_logger = logging.getLogger("atex")
+
+
+def in_debug_mode():
+    """
+    Return True if the root logger is using the DEBUG (or more verbose) level.
+    """
+    root_level = logging.getLogger().level
+    return root_level > 0 and root_level <= logging.DEBUG
 
 
 def _format_msg(msg, *, skip_frames=0):
@@ -13,7 +21,7 @@ def _format_msg(msg, *, skip_frames=0):
 
     # bottom of the stack, or runpy executed module
     for frame_info in stack:
-        if frame_info.function == '<module>':
+        if frame_info.function == "<module>":
             break
     module = frame_info
 
@@ -24,21 +32,21 @@ def _format_msg(msg, *, skip_frames=0):
     # if the function has 'self' and it looks like a class instance,
     # prepend it to the function name
     p_locals = parent.frame.f_locals
-    if 'self' in p_locals:
-        self = p_locals['self']
-        if hasattr(self, '__class__') and inspect.isclass(self.__class__):
-            function = f'{self.__class__.__name__}.{function}'
+    if "self" in p_locals:
+        self = p_locals["self"]
+        if hasattr(self, "__class__") and inspect.isclass(self.__class__):
+            function = f"{self.__class__.__name__}.{function}"
 
     # don't report module name of a function if it's the same as running module
     if parent.filename != module.filename:
-        parent_modname = parent.frame.f_globals['__name__']
+        parent_modname = parent.frame.f_globals["__name__"]
         # avoid everything having the package name prefixed
-        parent_modname = parent_modname.partition('.')[2] or parent_modname
-        return f'{parent_modname}.{function}:{parent.lineno}: {msg}'
-    elif parent.function != '<module>':
-        return f'{function}:{parent.lineno}: {msg}'
+        parent_modname = parent_modname.partition(".")[2] or parent_modname
+        return f"{parent_modname}.{function}:{parent.lineno}: {msg}"
+    elif parent.function != "<module>":
+        return f"{function}:{parent.lineno}: {msg}"
     else:
-        return f'{Path(parent.filename).name}:{parent.lineno}: {msg}'
+        return f"{Path(parent.filename).name}:{parent.lineno}: {msg}"
 
 
 def debug(msg, *, skip_frames=0):

atex/util/path.py

@@ -0,0 +1,16 @@
+import os
+
+
+def normalize_path(path):
+    """
+    Transform a potentially dangerous path (leading slash, relative ../../../
+    leading beyond parent, etc.) to a safe one.
+
+    Always returns a relative path.
+    """
+    # the magic here is to treat any dangerous path as starting at /
+    # and resolve any weird constructs relative to /, and then simply
+    # strip off the leading / and use it as a relative path
+    path = path.lstrip("/")
+    path = os.path.normpath(f"/{path}")
+    return path[1:]

atex/util/ssh_keygen.py

@@ -0,0 +1,14 @@
+import subprocess
+from pathlib import Path
+
+from .subprocess import subprocess_run
+
+
+def ssh_keygen(dest_dir, key_type="rsa"):
+    dest_dir = Path(dest_dir)
+    subprocess_run(
+        ("ssh-keygen", "-t", key_type, "-N", "", "-f", dest_dir / f"key_{key_type}"),
+        stdout=subprocess.DEVNULL,
+        check=True,
+    )
+    return (dest_dir / "key_rsa", dest_dir / "key_rsa.pub")

atex/util/subprocess.py

@@ -3,29 +3,30 @@ import subprocess
 from .log import debug
 
 
-def _format_subprocess_cmd(cmd):
-    return cmd
-#    if isinstance(cmd, (list, tuple)):
-#        return ' '.join(str(x) for x in cmd)
-#    else:
-#        return cmd
-
-
 def subprocess_run(cmd, *, skip_frames=0, **kwargs):
     """
     A simple wrapper for the real subprocess.run() that logs the command used.
     """
     # when logging, skip current stack frame - report the place we were called
     # from, not util.subprocess_run itself
-    debug(f'running: {_format_subprocess_cmd(cmd)}', skip_frames=skip_frames+1)
+    debug(f"running: {cmd}", skip_frames=skip_frames+1)
     return subprocess.run(cmd, **kwargs)
 
 
+def subprocess_output(cmd, *, skip_frames=0, check=True, text=True, **kwargs):
+    """
+    A wrapper simulating subprocess.check_output() via a modern .run() API.
+    """
+    debug(f"running: {cmd}", skip_frames=skip_frames+1)
+    proc = subprocess.run(cmd, check=check, text=text, stdout=subprocess.PIPE, **kwargs)
+    return proc.stdout.rstrip("\n") if text else proc.stdout
+
+
 def subprocess_Popen(cmd, *, skip_frames=0, **kwargs):  # noqa: N802
     """
     A simple wrapper for the real subprocess.Popen() that logs the command used.
     """
-    debug(f'running: {_format_subprocess_cmd(cmd)}', skip_frames=skip_frames+1)
+    debug(f"running: {cmd}", skip_frames=skip_frames+1)
     return subprocess.Popen(cmd, **kwargs)
 
 
@@ -38,12 +39,12 @@ def subprocess_stream(cmd, *, check=False, skip_frames=0, **kwargs):
 
     To capture both stdout and stderr as yielded lines, use subprocess.STDOUT.
     """
-    debug(f'running: {_format_subprocess_cmd(cmd)}', skip_frames=skip_frames+1)
-    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, universal_newlines=True, **kwargs)
+    debug(f"running: {cmd}", skip_frames=skip_frames+1)
+    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, text=True, **kwargs)
 
     def generate_lines():
         for line in proc.stdout:
-            yield line.rstrip('\n')
+            yield line.rstrip("\n")
         code = proc.wait()
         if code > 0 and check:
             raise subprocess.CalledProcessError(cmd=cmd, returncode=code)

atex/util/threads.py

@@ -0,0 +1,55 @@
+import collections
+import queue
+import threading
+
+# TODO: documentation; this is like concurrent.futures, but with daemon=True support
+
+
+class ThreadQueue:
+    ThreadReturn = collections.namedtuple("ThreadReturn", ("thread", "returned", "exception"))
+    Empty = queue.Empty
+
+    def __init__(self, daemon=False):
+        self.queue = queue.SimpleQueue()
+        self.daemon = daemon
+        self.threads = set()
+
+    def _wrapper(self, func, *args, **kwargs):
+        current_thread = threading.current_thread()
+        try:
+            ret = func(*args, **kwargs)
+            result = self.ThreadReturn(current_thread, ret, None)
+        except Exception as e:
+            result = self.ThreadReturn(current_thread, None, e)
+        self.queue.put(result)
+
+    def start_thread(self, target, name=None, args=None, kwargs=None):
+        args = args or ()
+        kwargs = kwargs or {}
+        t = threading.Thread(
+            target=self._wrapper,
+            name=name,
+            args=(target, *args),
+            kwargs=kwargs,
+            daemon=self.daemon,
+        )
+        t.start()
+        self.threads.add(t)
+
+    # get one return value from any thread's function, like .as_completed()
+    # or concurrent.futures.FIRST_COMPLETED
+    def get(self, block=True, timeout=None):
+        if block and timeout is None and not self.threads:
+            raise AssertionError("no threads are running, would block forever")
+        treturn = self.queue.get(block=block, timeout=timeout)
+        self.threads.remove(treturn.thread)
+        if treturn.exception is not None:
+            raise treturn.exception
+        else:
+            return treturn.returned
+
+    # wait for all threads to finish (ignoring queue contents)
+    def join(self):
+        while self.threads:
+            t = self.threads.pop()
+            t.join()

{atex-0.5.dist-info → atex-0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atex
-Version: 0.5
+Version: 0.8
 Summary: Ad-hoc Test EXecutor
 Project-URL: Homepage, https://github.com/RHSecurityCompliance/atex
 License-Expression: GPL-3.0-or-later
@@ -8,7 +8,7 @@ License-File: COPYING.txt
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Testing
-Requires-Python: >=3.9
+Requires-Python: >=3.11
 Requires-Dist: fmf>=1.6
 Requires-Dist: urllib3<3,>=2
 Description-Content-Type: text/markdown
@@ -45,8 +45,103 @@ BREAK. DO NOT USE IT (for now).
 Unless specified otherwise, any content within this repository is distributed
 under the GNU GPLv3 license, see the [COPYING.txt](COPYING.txt) file for more.
 
+## Parallelism and cleanup
+
+There are effectively 3 methods of running things in parallel in Python:
+
+- `threading.Thread` (and related `concurrent.futures` classes)
+- `multiprocessing.Process` (and related `concurrent.futures` classes)
+- `asyncio`
+
+and there is no clear winner (in terms of cleanup on `SIGTERM` or Ctrl-C):
+
+- `Thread` has signal handlers only in the main thread and is unable to
+  interrupt any running threads without super ugly workarounds like `sleep(1)`
+  in every thread, checking some "pls exit" variable
+- `Process` is too heavyweight and makes sharing native Python objects hard,
+  but it does handle signals in each process individually
+- `asyncio` handles interrupting perfectly (every `try`/`except`/`finally`
+  completes just fine, `KeyboardInterrupt` is raised in every async context),
+  but async python is still (3.14) too weird and unsupported
+  - `asyncio` effectively re-implements `subprocess` with a slightly different
+    API, same with `asyncio.Transport` and derivatives reimplementing `socket`
+  - 3rd party libraries like `requests` or `urllib3` don't support it, one needs
+    to resort to spawning these in separate threads anyway
+  - same with `os.*` functions and syscalls
+  - every thing exposed via API needs to have 2 copies - async and non-async,
+    making it unbearable
+  - other stdlib bugs, ie. "large" reads returning BlockingIOError sometimes
+
+The approach chosen by this project was to use `threading.Thread`, and
+implement thread safety for classes and their functions that need it.  
+For example:
+
+```python
+class MachineReserver:
+    def __init__(self):
+        self.lock = threading.RLock()
+        self.job = None
+        self.proc = None
+
+    def reserve(self, ...):
+        try:
+            ...
+            job = schedule_new_job_on_external_service()
+            with self.lock:
+                self.job = job
+            ...
+            while not reserved(self.job):
+                time.sleep(60)
+            ...
+            with self.lock:
+                self.proc = subprocess.Popen(["ssh", f"{user}@{host}", ...)
+            ...
+            return machine
+        except Exception:
+            self.abort()
+            raise
+
+    def abort(self):
+        with self.lock:
+            if self.job:
+                cancel_external_service(self.job)
+                self.job = None
+            if self.proc:
+                self.proc.kill()
+                self.proc = None
+```
+
+Here, it is expected for `.reserve()` to be called in a long-running thread that
+provisions a new machine on some external service, waits for it to be installed
+and reserved, connects an ssh session to it and returns it back.
+
+But equally, `.abort()` can be called from an external thread and clean up any
+non-pythonic resources (external jobs, processes, temporary files, etc.) at
+which point **we don't care what happens to .reserve()**, it will probably fail
+with some exception, but doesn't do any harm.
+
+Here is where `daemon=True` threads come in handy - we can simply call `.abort()`
+from a `KeyboardInterrupt` (or `SIGTERM`) handle in the main thread, and just
+exit, automatically killing any leftover threads that are uselessly sleeping.  
+(Realistically, we might want to spawn new threads to run many `.abort()`s in
+parallel, but the main thread can wait for those just fine.)
+
+It is not perfect, but it's probably the best Python can do.
+
+Note that races can still occur between a resource being reserved and written
+to `self.*` for `.abort()` to free, so resource de-allocation is not 100%
+guaranteed, but single-threaded interrupting has the same issue.  
+Do have fallbacks (ie. max reserve times on the external service).
+
+Also note that `.reserve()` and `.abort()` could be also called by a context
+manager as `__enter__` and `__exit__`, ie. by a non-threaded caller (running
+everything in the main thread).
+
+
 ## Unsorted notes
 
+TODO: codestyle from contest
+
 ```
 - this is not tmt, the goal is to make a python toolbox *for* making runcontest
   style tools easily, not to replace those tools with tmt-style CLI syntax

atex-0.8.dist-info/RECORD

@@ -0,0 +1,37 @@
+atex/__init__.py,sha256=LdX67gprtHYeAkjLhFPKzpc7ECv2rHxUbHKDGbGXO1c,517
+atex/fmf.py,sha256=ofbrJx2362qHAxERS-WulK4TMpbp0C4HQ-Js917Ll9w,7871
+atex/cli/__init__.py,sha256=erHv68SsybRbdgJ60013y9jVqY1ec-cb9T9ThPCJ_HY,2408
+atex/cli/fmf.py,sha256=5DbA-3rfbFZ41fJ5z7Tiz5FmuZhXNC7gRAQfIGX7pXc,2516
+atex/cli/testingfarm.py,sha256=wdN26TE9jZ0ozet-JBQQgIcRi0WIV3u_i-7_YYi_SUg,7248
+atex/connection/__init__.py,sha256=xFwGOvlFez1lIt1AD6WXgEEIbsF22pSpQFv41GEAGAI,3798
+atex/connection/ssh.py,sha256=vrrSfVdQoz5kWiZbiPuM8KGneMl2Tlb0VeJIHTFSSYs,13626
+atex/executor/__init__.py,sha256=XCfhi7QDELjey7N1uzhMjc46Kp1Jsd5bOCf52I27SCE,85
+atex/executor/duration.py,sha256=x06sItKOZi6XA8KszQwZGpIb1Z_L-HWqIwZKo2SDo0s,1759
+atex/executor/executor.py,sha256=QYYSlEfBZIm95NhM1gwd2ROeshSAavYu2DP_4TTHlQs,14770
+atex/executor/reporter.py,sha256=nW_Uls3R4Ev80a2ZNJl3nxAYrcYhXk5Cy9nAUMlYPrc,3326
+atex/executor/scripts.py,sha256=yE4Lbfu-TPkBcB5t15-t-tF79H8pBJWbWP6MKRSvKsw,5356
+atex/executor/testcontrol.py,sha256=-rfihfE6kryIGurFrHBPSS8ANaIJkzX-zfpOO8To-9o,12204
+atex/orchestrator/__init__.py,sha256=eF-6ix5rFEu85fBFzgSdTYau7bNTkIQndAU7QqeI-FA,105
+atex/orchestrator/aggregator.py,sha256=5-8nHVeW6kwImoEYOsQqsx6UBdbKc5xuj6qlg7dtOF8,3642
+atex/orchestrator/orchestrator.py,sha256=tQu_d8_9y3rOLHskb694NJKNvxplQWAZ2R452Sy3AXw,12056
+atex/provision/__init__.py,sha256=2d_hRVPxXF5BVbQ_Gn1OR-F2xuqRn8O0yyVbvSrtTIg,4043
+atex/provision/libvirt/VM_PROVISION,sha256=7pkZ-ozgTyK4qNGC-E-HUznr4IhbosWSASbB72Gknl8,2664
+atex/provision/libvirt/__init__.py,sha256=mAkGtciZsXdR9MVVrjm3OWNXZqTs_33-J1qAszFA0k4,768
+atex/provision/libvirt/setup-libvirt.sh,sha256=CXrEFdrj8CSHXQZCd2RWuRvTmw7QYFTVhZeLuhhXooI,1855
+atex/provision/podman/README,sha256=kgP3vcTfWW9gcQzmXnyucjgWbqjNqm_ZM--pnqNTXRg,1345
+atex/provision/podman/host_container.sh,sha256=buCNz0BlsHY5I64sMSTGQHkvzEK0aeIhpGJXWCQVMXk,2283
+atex/provision/testingfarm/__init__.py,sha256=kZncgLGdRCR4FMaRQr2GTwJ8vjlA-24ri8JO2ueZJuw,113
+atex/provision/testingfarm/api.py,sha256=jiEJhYxMTzRihayceHcnDnGKNZJisYWn2o_TAdCI2Xo,19943
+atex/provision/testingfarm/testingfarm.py,sha256=wp8W3bwOmQdO-UUOdqu_JLtOZTGaNg-wERFfLySwZmI,8587
+atex/util/__init__.py,sha256=cWHFbtQ4mDlKe6lXyPDWRmWJOTcHDGfVuW_-GYa8hB0,1473
+atex/util/dedent.py,sha256=SEuJMtLzqz3dQ7g7qyZzEJ9VYynVlk52tQCJY-FveXo,603
+atex/util/log.py,sha256=KZkuw4jl8YTUOHZ4wNBrfDeg16VpLa82-IZYFHfqwgk,1995
+atex/util/path.py,sha256=x-kXqiWCVodfZWbEwtC5A8LFvutpDIPYv2m0boZSlXU,504
+atex/util/ssh_keygen.py,sha256=9yuSl2yBV7pG3Qfsf9tossVC00nbIUrAeLdbwTykpjk,384
+atex/util/subprocess.py,sha256=IQT9QHe2kMaaO_XPSry-DwObYstGsq6_QdwdbhYDjko,1826
+atex/util/threads.py,sha256=bezDIEIMcQinmG7f5E2K6_mHJQOlwx7W3I9CKkCYAYA,1830
+atex-0.8.dist-info/METADATA,sha256=dvXW146ZvIfyzqPqGbKmhTNScLTZM7C5K0FLrGNGIJ0,8981
+atex-0.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+atex-0.8.dist-info/entry_points.txt,sha256=pLqJdcfeyQTgup2h6dWb6SvkHhtOl-W5Eg9zV8moK0o,39
+atex-0.8.dist-info/licenses/COPYING.txt,sha256=oEuj51jdmbXcCUy7pZ-KE0BNcJTR1okudRp5zQ0yWnU,670
+atex-0.8.dist-info/RECORD,,