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

atex/util/named_mapping.py

@@ -0,0 +1,158 @@
+"""
+Provides a namedtuple-inspired frozen mapping-backed data structure.
+
+    class MyMap(NamedMapping):
+        pass
+
+    m = MyMap(a=123, b=456)
+
+    m["a"]      # 123
+    m.a         # 123
+    m["a"] = 9  # KeyError (is read-only)
+    m.a = 9     # AttributeError (is read-only)
+
+Like namedtuple, you can specify required keys that always need to be given
+to the constructor:
+
+    class MyMap(NamedMapping, required=("key1", "key2")):
+        pass
+
+    m = MyMap(a=123, b=456, key1=999)  # KeyError (key2 not specified)
+
+Similarly, you can specify defaults (for required or non-required keys),
+as a dict, that are used if omitted from the constructor:
+
+    class MyMap(NamedMapping, defaults={"key": 678}):
+        pass
+
+    m = MyMap()  # will have m.key == 678
+
+A class instance can unpack via ** with the entirety of its mapping contents:
+
+    m = MyMap(key2=456)
+    both = {'key1': 123, **m}  # contains both keys
+
+You can also chain (append to) required / default values through inheritance:
+
+    class MyMap(NamedMapping, required=("key1",), defaults={"key2": 234}):
+        pass
+
+    class AnotherMap(MyMap, required=("key3",))
+        pass
+
+    m = AnotherMap()      # KeyError (key1 and key3 are required)
+
+    isinstance(m, MyMap)  # would be True
+
+When instantiating, it is also possible to copy just the required keys from
+another dict-like object (does not have to be a parent of the class):
+
+    class SmallMap(NamedMapping, required=("key1", "key2")):
+        pass
+
+    class BigMap(SmallMap, required=("key3", "key4")):
+        pass
+
+    b = BigMap(key1=123, key2=456, key3=789, key4=0)
+
+    s = SmallMap._from(b)             # will copy just key1 and key2
+    s = SmallMap._from(b, extra=555)  # can pass extra **kwargs to __init__
+    s = SmallMap(**b)                 # will copy all keys
+
+Note that this is a fairly basic implementation without __hash__, etc.
+"""
+
+import abc
+import collections
+
+
+class _NamedMappingMeta(abc.ABCMeta):
+    def __new__(
+        metacls, name, bases, namespace, *, required=None, default=None, **kwargs,  # noqa: N804
+    ):
+        new_required = []
+        for base in bases:
+            new_required.extend(getattr(base, "_required", ()))
+        if required:
+            new_required.extend(required)
+        namespace["_required"] = tuple(set(new_required))
+
+        new_default = {}
+        for base in bases:
+            new_default.update(getattr(base, "_default", {}))
+        if default:
+            new_default.update(default)
+        namespace["_default"] = new_default
+
+        return super().__new__(metacls, name, bases, namespace, **kwargs)
+
+
+class NamedMapping(collections.abc.Mapping, metaclass=_NamedMappingMeta):
+    __slots__ = ("_data",)
+
+    def __init__(self, **keys):
+        data = {}
+        if hasattr(self, "_default"):
+            data.update(self._default)
+        data.update(keys)
+        if hasattr(self, "_required"):
+            for key in self._required:
+                if key not in data:
+                    raise KeyError(f"'{self.__class__.__name__}' requires key '{key}'")
+        object.__setattr__(self, "_data", data)
+
+    @classmethod
+    def _from(cls, foreign, **keys):
+        """
+        (keys is like for __init__)
+        """
+        foreign_data = {}
+        if hasattr(cls, "_required"):
+            for key in cls._required:
+                if key in foreign:
+                    foreign_data[key] = foreign[key]
+        foreign_data.update(keys)
+        return cls(**foreign_data)
+
+    def __getattr__(self, item):
+        if item in ("_data", "_required", "_default"):
+            return super().__getattr__(item)
+        try:
+            return self._data[item]
+        except KeyError:
+            raise AttributeError(
+                f"'{self.__class__.__name__}' object has no attribute '{item}'",
+                name=item,
+            ) from None
+
+    def __setattr__(self, name, value):
+        raise AttributeError(
+            f"'{self}' is read-only, cannot set '{name}'",
+            name=name,
+            obj=value,
+        )
+
+    def __getitem__(self, key):
+        return self._data[key]
+
+    def __setitem__(self, key, value):
+        raise ValueError(f"'{self}' is read-only, cannot set '{key}'")
+
+    def __delitem__(self, key):
+        raise ValueError(f"'{self}' is read-only, cannot delete '{key}'")
+
+    def __contains__(self, key):
+        return key in self._data
+
+    def __iter__(self):
+        return iter(self._data)
+
+    def __len__(self):
+        return len(self._data)
+
+    def __repr__(self):
+        return (
+            f"{self.__class__.__name__}("
+            + ", ".join((f"{k}={repr(v)}" for k,v in self._data.items()))
+            + ")"
+        )

atex/util/threads.py

@@ -1,48 +1,85 @@
-import collections
 import queue
 import threading
 
+from .named_mapping import NamedMapping
+
 # TODO: documentation; this is like concurrent.futures, but with daemon=True support
 
 
 class ThreadQueue:
-    ThreadReturn = collections.namedtuple("ThreadReturn", ("thread", "returned", "exception"))
+    class ThreadReturn(NamedMapping, required=("thread", "returned", "exception")):
+        pass
+
     Empty = queue.Empty
 
     def __init__(self, daemon=False):
+        self.lock = threading.RLock()
         self.queue = queue.SimpleQueue()
         self.daemon = daemon
         self.threads = set()
 
-    def _wrapper(self, func, *args, **kwargs):
+    def _wrapper(self, func, func_args, func_kwargs, **user_kwargs):
         current_thread = threading.current_thread()
         try:
-            ret = func(*args, **kwargs)
-            result = self.ThreadReturn(current_thread, ret, None)
+            ret = func(*func_args, **func_kwargs)
+            result = self.ThreadReturn(
+                thread=current_thread,
+                returned=ret,
+                exception=None,
+                **user_kwargs,
+            )
         except Exception as e:
-            result = self.ThreadReturn(current_thread, None, e)
+            result = self.ThreadReturn(
+                thread=current_thread,
+                returned=None,
+                exception=e,
+                **user_kwargs,
+            )
         self.queue.put(result)
 
-    def start_thread(self, target, name=None, args=None, kwargs=None):
-        args = args or ()
-        kwargs = kwargs or {}
+    def start_thread(self, target, target_args=None, target_kwargs=None, **user_kwargs):
+        """
+        Start a new thread and call 'target' as a callable inside it, passing it
+        'target_args' as arguments and 'target_kwargs' as keyword arguments.
+
+        Any additional 'user_kwargs' specified are NOT passed to the callable,
+        but instead become part of the ThreadReturn namespace returned by the
+        .get_raw() method.
+        """
         t = threading.Thread(
             target=self._wrapper,
-            name=name,
-            args=(target, *args),
-            kwargs=kwargs,
+            args=(target, target_args or (), target_kwargs or {}),
+            kwargs=user_kwargs,
             daemon=self.daemon,
         )
+        with self.lock:
+            self.threads.add(t)
         t.start()
-        self.threads.add(t)
+
+    def get_raw(self, block=True, timeout=None):
+        """
+        Wait for and return the next available ThreadReturn instance on the
+        queue, as enqueued by a finished callable started by the .start_thread()
+        method.
+        """
+        with self.lock:
+            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)
+        with self.lock:
+            self.threads.remove(treturn.thread)
+        return treturn
 
     # 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)
+        """
+        Wait for and return the next available return value of a callable
+        enqueued via the .start_thread() method.
+
+        If the callable raised an exception, the exception is re-raised here.
+        """
+        treturn = self.get_raw(block, timeout)
         if treturn.exception is not None:
             raise treturn.exception
         else:
@@ -50,6 +87,13 @@ class ThreadQueue:
 
     # wait for all threads to finish (ignoring queue contents)
     def join(self):
-        while self.threads:
-            t = self.threads.pop()
-            t.join()
+        """
+        Wait for all threads to finish, ignoring the state of the queue.
+        """
+        while True:
+            with self.lock:
+                try:
+                    thread = self.threads.pop()
+                except KeyError:
+                    break
+            thread.join()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atex
-Version: 0.8
+Version: 0.9
 Summary: Ad-hoc Test EXecutor
 Project-URL: Homepage, https://github.com/RHSecurityCompliance/atex
 License-Expression: GPL-3.0-or-later
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.11
 Requires-Dist: fmf>=1.6
+Requires-Dist: pyyaml
 Requires-Dist: urllib3<3,>=2
 Description-Content-Type: text/markdown
 
@@ -45,6 +46,30 @@ 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.
 
+## Testing this project
+
+There are some limited sanity tests provided via `pytest`, although:
+
+* Some require additional variables (ie. Testing Farm) and will ERROR
+  without them.
+* Some take a long time (ie. Testing Farm) due to system provisioning
+  taking a long time, so install `pytest-xdist` and run with a large `-n`.
+
+Currently, the recommended approach is to split the execution:
+
+```
+# synchronously, because podman CLI has concurrency issues
+pytest tests/provision/test_podman.py
+
+# in parallel, because provisioning takes a long time
+export TESTING_FARM_API_TOKEN=...
+export TESTING_FARM_COMPOSE=...
+pytest -n 20 tests/provision/test_podman.py
+
+# fast enough for synchronous execution
+pytest tests/fmf
+```
+
 ## Parallelism and cleanup
 
 There are effectively 3 methods of running things in parallel in Python:
@@ -149,49 +174,5 @@ TODO: codestyle from contest
   - the whole point is to make usecase-targeted easy-to-use tools that don't
     intimidate users with 1 KB long command line, and runcontest is a nice example
 
-  - TL;DR - use a modular pythonic approach, not a modular CLI like tmt
-
-
-- Orchestrator with
-  - add_provisioner(<class>, max_workers=1)   # will instantiate <class> at most max_workers at a time
-  - algo
-    - for all provisioner classes, spawns classes*max_workers as new Threads
-    - waits for any .reserve() to return
-    - creates a new Thread for minitmt, gives it p.get_ssh() details
-      - minitmt will
-        - establish a SSHConn
-        - install test deps, copy test repo over, prepare socket dir on SUT, etc.
-        - run the test in the background as
-            f=os.open('some/test/log', os.WRONLY); subprocess.Popen(..., stdout=f, stderr=f, stdin=subprocess.DEVNULL)
-        - read/process Unix sock results in the foreground, non-blocking,
-          probably calling some Orchestrator-provided function to store results persistently
-        - regularly check Popen proc status, re-accept UNIX sock connection, etc., etc.
-      - minitmt also has some Thread-independent way to .cancel(), killing the proc, closing SSHConn, etc.
-
-  - while waiting for minitmt Threads to finish, to re-assign existing Provisioner instances
-    to new minitmt Threads, .. Orchestrator uses some logic to select, which TestRun
-    would be ideal to run next
-    - TestRun probably has some "fitness" function that returns some priority number
-      when given a Provisioner instance (?) ...
-    - something from minitmt would also have access to the Provisioner instance
-    - the idea is to allow some logic to set "hey I set up nested VM snapshot on this thing"
-      on the Provisioner instance, and if another /hardening/oscap TestRun finds
-      a Provisioner instance like that, it would return high priority
-    - ...
-    - similar to "fitness" like function, we need some "applicability" function
-      - if TestRun is mixed to RHEL-9 && x86_64, we need it to return True
-        for a Provisioner instance that provides RHEL-9 and x86_64, but False otherwise
-
-- basically Orchestrator has
-  - .add_provisioner()
-  - .run_test()  # called with an exclusively-borrowed Provisioner instance
-    - if Provisioner is_alive()==False after .run_test(), instantiate a new one from the same inst.__class__
-    - if test failed and reruns > 0, try run_test() again (or maybe re-queue the test)
-  - .output_result()  # called by run_test() to persistently log a test result
-  - .applicable()  # return True if a passed TestRun is meant for a passed Platform (Provisioner?)
-    - if no TestRun returns True, the Provisioner is .release()d because we don't need it anymore
-  - .fitness()    # return -inf / 0 / +inf with how much should a passed TestRun run on a Provisioner
-  - MAYBE combine applicable() and fitness() into one function, next_test() ?
-    - given the free Provisioner and a list of TestRuns, select which should run next on the Provisioner
-      - if none is chosen, .release() the Provisioner without replacement, continue
+  - TL;DR - use a modular pythonic approach, not a gluetool-style long CLI
 ```

atex-0.9.dist-info/RECORD

@@ -0,0 +1,43 @@
+atex/__init__.py,sha256=LdX67gprtHYeAkjLhFPKzpc7ECv2rHxUbHKDGbGXO1c,517
+atex/fmf.py,sha256=gkJXIaRO7_KvwJR-V6Tc1NVn4a9Hq7hoBLQLhxYIdbg,8834
+atex/cli/__init__.py,sha256=erHv68SsybRbdgJ60013y9jVqY1ec-cb9T9ThPCJ_HY,2408
+atex/cli/fmf.py,sha256=HfbTgFbCwK4Nuyq6vtGutcq_4-4kj-tmoqzXUn3AYtY,3573
+atex/cli/libvirt.py,sha256=vGcan9u0Nor_DaEjgOj3Yzjtlq4WNVLr5oYMb8zFb6M,3743
+atex/cli/testingfarm.py,sha256=DHMupwU3AjbkwkzvzdhlxtsuBnxVaba5i8T8g9sKRug,7569
+atex/connection/__init__.py,sha256=dj8ZBcEspom7Z_UjecfLGBRNvLZ3dyGR9q19i_B4xpY,3880
+atex/connection/podman.py,sha256=JUsi4jOkNFGsEHCqUQF003R2yRfJPsMnUSBEZM3H3Kk,1953
+atex/connection/ssh.py,sha256=c8v01mj0pf6VU8z2cLLCvPGPmGUZp8wQsTG441k3Qy4,13674
+atex/executor/__init__.py,sha256=XCfhi7QDELjey7N1uzhMjc46Kp1Jsd5bOCf52I27SCE,85
+atex/executor/duration.py,sha256=x06sItKOZi6XA8KszQwZGpIb1Z_L-HWqIwZKo2SDo0s,1759
+atex/executor/executor.py,sha256=OcKBXQ77OktmzPWAbdCb81Yj44Jr4SEkwW_CxdEhFP4,15674
+atex/executor/reporter.py,sha256=MceFmHFt0bTEClBZbRI1WnFbfMhR0e1noOzcu7gjKuQ,3403
+atex/executor/scripts.py,sha256=6xqP-m_9UCVb3z0tCWIMczimz_cTeCIJucSp0AGYsRw,5567
+atex/executor/testcontrol.py,sha256=O4V4jRx7lZv-El1i9jkPha-aWzjq_8m6loK7sNGVD14,12695
+atex/orchestrator/__init__.py,sha256=GSHtWoZjJrLiatjUHsMAkYB8VebSQD9ApQw0ymCrGTQ,212
+atex/orchestrator/aggregator.py,sha256=naypN8T42iPau_4eLeXak-INR1_vsYhP_QSp3xLM_FA,3837
+atex/orchestrator/orchestrator.py,sha256=qAwka7MqpAWA6mLgsMl1m1HpQP2mERcaAASNvJwgfTM,14570
+atex/provision/__init__.py,sha256=Pj_JnDaJA8DzKRGmLcc2JiwPsuQc2TYlE-hDR56SwTY,4083
+atex/provision/libvirt/VM_PROVISION,sha256=7pkZ-ozgTyK4qNGC-E-HUznr4IhbosWSASbB72Gknl8,2664
+atex/provision/libvirt/__init__.py,sha256=pKG5IpZSC2IHs5wL2ecQx_fd9AzAXEbZmDzA7RyZsfM,119
+atex/provision/libvirt/libvirt.py,sha256=7wux-zhQoNODJoPB4iMqPlGEJe7rEEZeLSOtMU3TB0M,18160
+atex/provision/libvirt/locking.py,sha256=e9zbtR0uzJZBAzucfhs9VQaDCx-jp0pWJi1pb7JPK4w,5630
+atex/provision/libvirt/setup-libvirt.sh,sha256=oCMy9SCnbC_QuAzO2sFwvB5ui1kMQ6uviHsgdXyoFXc,2428
+atex/provision/podman/__init__.py,sha256=V9miIDQV-CyDVcbf2-1qtDbXDhhZzJza5oXas-JxI8o,66
+atex/provision/podman/podman.py,sha256=FJK4uLDuHBj8_3Wlg4a-4JgGIRGyLX4v7UVcxEorHbA,9578
+atex/provision/testingfarm/__init__.py,sha256=kZncgLGdRCR4FMaRQr2GTwJ8vjlA-24ri8JO2ueZJuw,113
+atex/provision/testingfarm/api.py,sha256=9xeoIN28KumJyMUEUoyEUZcIxVH9G34Wecyy3bp2Cmg,21612
+atex/provision/testingfarm/testingfarm.py,sha256=-Q33FAretSGPWdmNJUywJZVfXYGtsAfLP5uqRZTGfQQ,8631
+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=70f6YiF2RwNUfE5BXZMSQonzfI_uxQoD7_S4bRD_Btw,2466
+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=IQT9QHe2kMaaO_XPSry-DwObYstGsq6_QdwdbhYDjko,1826
+atex/util/threads.py,sha256=46-5nV-qJqi1YZ4qEshmZXGUxr8j9_9xT9eEpkjRr5I,3355
+atex-0.9.dist-info/METADATA,sha256=iLGFHVxeK9KWrPaRdL4hkbNkb-OgJkeohHhxYz90tAI,6857
+atex-0.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+atex-0.9.dist-info/entry_points.txt,sha256=pLqJdcfeyQTgup2h6dWb6SvkHhtOl-W5Eg9zV8moK0o,39
+atex-0.9.dist-info/licenses/COPYING.txt,sha256=oEuj51jdmbXcCUy7pZ-KE0BNcJTR1okudRp5zQ0yWnU,670
+atex-0.9.dist-info/RECORD,,

atex/provision/podman/README

@@ -1,59 +0,0 @@
-
-making a podman image from the currently installed OS:
-
-1) dnf install into a separate installroot
-
-dnf
-    --installroot=$INSTALLROOT \
-    --setopt=install_weak_deps=False \
-    --setopt=tsflags=nodocs \
-    -y groupinstall minimal-environment
-
-as root (doesn't work well with unshare, maybe could work via bwrap (bubblewrap))
-
-maybe the unprivileged solution is pulling image from hub + installing @minimal-environment
-into it (perhaps via podman build)
-
-
-2) post process it
-
-echo -n > "$INSTALLROOT/etc/machine-id"
-echo container > "$INSTALLROOT/etc/hostname"
-
-rm -rf "$INSTALLROOT/etc/yum.repos.d"
-cp -f /etc/yum.repos.d/* "$INSTALLROOT/etc/yum.repos.d/."
-cp -f /etc/pki/rpm-gpg/* "$INSTALLROOT/etc/pki/rpm-gpg/."
-
-echo install_weak_deps=False >> "$INSTALLROOT/etc/dnf/dnf.conf"
-echo tsflags=nodocs >> "$INSTALLROOT/etc/dnf/dnf.conf"
-
-ln -sf \
-    /usr/lib/systemd/system/multi-user.target \
-    "$INSTALLROOT/etc/systemd/system/default.target"
-
-# disable auditd
-# disable other services
-# set root password
-
-dnf clean all --installroot="$INSTALLROOT"
-
-
-3) pack it
-
-tar --xattrs -C "$INSTALLROOT" -cvf tarball.tar .
-
-rm -rf "$INSTALLROOT"
-
-
-4) import it to podman
-
-podman import --change 'CMD ["/sbin/init"]' tarball.tar my-image-name
-
-
-5) run it
-
-podman {run,create} --systemd=always --cgroups=split ...
-
-
-
-------------------------------

atex/provision/podman/host_container.sh

@@ -1,74 +0,0 @@
-#!/bin/bash
-
-if [[ $# -lt 1 ]]; then
-    echo "usage: $0 <podman-image-name>" >&2
-    exit 1
-fi
-image_name="$1"
-
-set -e -x
-
-tmpdir=$(mktemp -d -p /var/tmp)
-trap "rm -rf '$tmpdir'" EXIT
-
-installroot="$tmpdir/root"
-
-dnf \
-    --installroot="$installroot" \
-    --setopt=install_weak_deps=False \
-    --setopt=tsflags=nodocs \
-    -q -y groupinstall minimal-environment
-
-echo -n > "$installroot/etc/machine-id"
-#echo container > "$installroot/etc/hostname"
-
-cp -f /etc/yum.repos.d/* "$installroot/etc/yum.repos.d/."
-cp -f /etc/pki/rpm-gpg/* "$installroot/etc/pki/rpm-gpg/."
-
-echo install_weak_deps=False >> "$installroot/etc/dnf/dnf.conf"
-echo tsflags=nodocs >> "$installroot/etc/dnf/dnf.conf"
-
-ln -sf \
-    /usr/lib/systemd/system/multi-user.target \
-    "$installroot/etc/systemd/system/default.target"
-
-systemctl --root="$installroot" disable \
-    auditd.service crond.service rhsmcertd.service sshd.service
-
-#encrypted=$(openssl passwd -6 somepass)
-#usermod --root="$installroot" --password "$encrypted" root
-
-dnf clean packages --installroot="$installroot"
-
-tar --xattrs -C "$installroot" -cf "$tmpdir/packed.tar" .
-
-rm -rf "$installroot"
-
-podman import \
-    --change 'CMD ["/sbin/init"]' \
-    "$tmpdir/packed.tar" "$image_name"
-
-# start as
-# podmn {run,create} --systemd=always --cgroups=split --device /dev/kvm ...
-#
-# podman run -t -i \
-#   --systemd=always --cgroups=split \
-#   --device /dev/kvm \
-#   --network=bridge \
-#   --cap-add NET_ADMIN --cap-add NET_RAW --cap-add SYS_MODULE \
-#   --mount type=bind,src=/lib/modules,dst=/lib/modules,ro \
-#   --mount type=bind,src=/proc/sys/net,dst=/proc/sys/net,rw \
-#   my_container
-#
-# as unprivileged user:
-# podman run -t -i \
-#   --systemd=always --cgroups=split --network=bridge --privileged \
-#   my_container
-#
-# container setup:
-# dnf -y install libvirt-daemon qemu-kvm libvirt-client libvirt-daemon-driver-qemu virt-install libvirt-daemon-driver-storage libvirt-daemon-config-network
-# echo $'user = "root"\ngroup = "root"\nremember_owner = 0' >> /etc/libvirt/qemu.conf
-# systemctl start virtqemud.socket virtstoraged.socket virtnetworkd.socket
-# virsh net-start default
-# virt-install --install fedora40 --disk /var/lib/libvirt/images/foo.qcow2,size=20 --console pty --check disk_size=off --unattended --graphics none
-

atex-0.8.dist-info/RECORD

@@ -1,37 +0,0 @@
-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,,