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

atex/{provision → provisioner}/testingfarm/api.py

@@ -16,12 +16,9 @@ import urllib3
 
 DEFAULT_API_URL = "https://api.testing-farm.io/v0.1"
 
-# how many seconds to sleep for during API polling
-API_QUERY_DELAY = 30
-
 DEFAULT_RESERVE_TEST = {
     "url": "https://github.com/RHSecurityCompliance/atex-reserve",
-    "ref": "v0.9",
+    "ref": "0.11",
     "path": ".",
     "name": "/plans/reserve",
 }
@@ -37,10 +34,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},
@@ -88,12 +85,13 @@ 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, **kwargs):
+    def _query(self, method, path, *args, headers=None, auth=True, **kwargs):
         url = f"{self.api_url}{path}"
-        if headers is not None:
-            headers["Authorization"] = f"Bearer {self.api_token}"
-        else:
-            headers = {"Authorization": f"Bearer {self.api_token}"}
+        if self.api_token and auth:
+            if headers is not None:
+                headers["Authorization"] = f"Bearer {self.api_token}"
+            else:
+                headers = {"Authorization": f"Bearer {self.api_token}"}
 
         reply = _http.request(method, url, *args, headers=headers, preload_content=False, **kwargs)
 
@@ -180,7 +178,7 @@ class TestingFarmAPI:
             fields["token_id"] = self.whoami()["token"]["id"]
             fields["user_id"] = self.whoami()["user"]["id"]
 
-        return self._query("GET", "/requests", fields=fields)
+        return self._query("GET", "/requests", fields=fields, auth=mine)
 
     def get_request(self, request_id):
         """
@@ -210,19 +208,22 @@ class Request:
     request.
     """
 
-    # TODO: maintain internal time.monotonic() clock and call .update() from
-    #       functions like .alive() if last update is > API_QUERY_DELAY
+    # actually query the TestingFarm API at most every X seconds,
+    # re-using cached state between updates
+    api_query_limit = 30
 
     def __init__(self, id=None, api=None, initial_data=None):
         """
         'id' is a Testing Farm request UUID
+
         'api' is a TestingFarmAPI instance - if unspecified, a sensible default
-        'initial_data' (dict) can be used to pre-fill an initial Request state
-        will be used.
+
+        'initial_data' (dict) can be used to pre-fill an initial Request state.
         """
         self.id = id
         self.api = api or TestingFarmAPI()
         self.data = initial_data or {}
+        self.next_query = 0
 
     def submit(self, spec):
         """
@@ -234,16 +235,12 @@ class Request:
         self.data = self.api.submit_request(spec)
         self.id = self.data["id"]
 
-    def update(self):
-        """
-        Query Testing Farm API to get a more up-to-date version of the request
-        metadata. Do not call too frequently.
-        This function is also used internally by others, you do not need to
-        always call it manually.
-        """
-        self.data = self.api.get_request(self.id)
-        # TODO: refresh internal time.monotonic() timer
-        return self.data
+    def _refresh(self):
+        if not self.id:
+            return
+        if time.monotonic() > self.next_query:
+            self.data = self.api.get_request(self.id)
+            self.next_query = time.monotonic() + self.api_query_limit
 
     def cancel(self):
         if not self.id:
@@ -254,35 +251,44 @@ class Request:
         return data
 
     def alive(self):
-        if "state" not in self.data:
-            self.update()
+        if not self.id:
+            return False
+        self._refresh()
         return self.data["state"] not in END_STATES
 
     def assert_alive(self):
         if not self.alive():
             state = self.data["state"]
-            raise GoneAwayError(f"request {self.data['id']} not alive anymore, entered: {state}")
+            raise GoneAwayError(f"request {self.id} not alive anymore, entered: {state}")
 
     def wait_for_state(self, state):
-        if "state" not in self.data:
-            self.update()
-        self.assert_alive()
-        while self.data["state"] != state:
-            time.sleep(API_QUERY_DELAY)
-            self.update()
-            self.assert_alive()
+        """
+        'state' is a str or a tuple of states to wait for.
+        """
+        watched = (state,) if isinstance(state, str) else state
+        while True:
+            self._refresh()
+            if self.data["state"] in watched:
+                break
+            # if the request ended in one of END_STATES and the above condition
+            # did not catch it, the wait will never end
+            if self.data["state"] in END_STATES:
+                raise GoneAwayError(f"request {self.id} ended with {self.data['state']}")
 
     def __repr__(self):
         return f"Request(id={self.id})"
 
     def __str__(self):
+        self._refresh()
         # python has no better dict-pretty-printing logic
         return json.dumps(self.data, sort_keys=True, indent=4)
 
     def __contains__(self, item):
+        self._refresh()
         return item in self.data
 
     def __getitem__(self, key):
+        self._refresh()
         return self.data[key]
 
 
@@ -292,6 +298,10 @@ class PipelineLogStreamer:
     to "stream" its contents over time (over many requests), never having to
     re-read old pipeline.log content.
     """
+
+    # how frequently to check for pipeline.log updates (seconds)
+    pipeline_query_limit = 30
+
     def __init__(self, request):
         self.request = request
 
@@ -324,8 +334,7 @@ class PipelineLogStreamer:
                 return log
 
             finally:
-                time.sleep(API_QUERY_DELAY)
-                self.request.update()
+                time.sleep(self.pipeline_query_limit)
 
     def __iter__(self):
         url = self._wait_for_entry()
@@ -356,8 +365,7 @@ class PipelineLogStreamer:
                     buffer = buffer[index+1:]
 
             finally:
-                time.sleep(API_QUERY_DELAY)
-                self.request.update()
+                time.sleep(self.pipeline_query_limit)
 
 
 class Reserve:
@@ -430,7 +438,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,
@@ -532,14 +539,17 @@ class Reserve:
             with self.lock:
                 self.request = Request(api=self.api)
                 self.request.submit(spec)
-            util.debug(f"submitted request:\n{textwrap.indent(str(self.request), '    ')}")
+            util.debug(f"submitted request {self.request.id}")
+            util.extradebug(
+                f"request {self.request.id}:\n{textwrap.indent(str(self.request), '    ')}",
+            )
 
             # wait for user/host to ssh to
             ssh_user = ssh_host = None
             for line in PipelineLogStreamer(self.request):
                 # the '\033[0m' is to reset colors sometimes left in a bad
                 # state by pipeline.log
-                util.debug(f"pipeline: {line}\033[0m")
+                util.extradebug(f"{line}\033[0m")
                 # find hidden login details
                 m = re.search(
                     # host address can be an IP address or a hostname
@@ -559,14 +569,12 @@ class Reserve:
             # (it will be failing to login for a while, until the reserve test
             #  installs our ssh pubkey into authorized_keys)
             ssh_attempt_cmd = (
-                "ssh", "-q", "-i", ssh_key, f"-oConnectionAttempts={API_QUERY_DELAY}",
+                "ssh", "-q", "-i", ssh_key.absolute(), "-oConnectionAttempts=60",
                "-oStrictHostKeyChecking=no", "-oUserKnownHostsFile=/dev/null",
                 f"{ssh_user}@{ssh_host}", "exit 123",
             )
             while True:
-                # wait for API_QUERY_DELAY between ssh retries, seems like GEFN sleep time
-                time.sleep(API_QUERY_DELAY)
-                self.request.update()
+                time.sleep(1)
                 self.request.assert_alive()
 
                 proc = util.subprocess_run(

atex/{provision → 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
@@ -8,22 +9,22 @@ from .. import Provisioner, Remote
 from . import api
 
 
-class TestingFarmRemote(Remote, connection.ssh.ManagedSSHConn):
+class TestingFarmRemote(Remote, connection.ssh.ManagedSSHConnection):
     """
     Built on the official Remote API, pulling in the Connection API
-    as implemented by ManagedSSHConn.
+    as implemented by ManagedSSHConnection.
     """
 
     def __init__(self, request_id, ssh_options, *, release_hook):
         """
         'request_id' is a string with Testing Farm request UUID (for printouts).
 
-        'ssh_options' are a dict, passed to ManagedSSHConn __init__().
+        'ssh_options' are a dict, passed to ManagedSSHConnection __init__().
 
         'release_hook' is a callable called on .release() in addition
         to disconnecting the connection.
         """
-        # NOTE: self.lock inherited from ManagedSSHConn
+        # NOTE: self.lock inherited from ManagedSSHConnection
         super().__init__(options=ssh_options)
         self.request_id = request_id
         self.release_hook = release_hook
@@ -35,8 +36,8 @@ class TestingFarmRemote(Remote, connection.ssh.ManagedSSHConn):
                 return
             else:
                 self.release_called = True
-        self.release_hook(self)
         self.disconnect()
+        self.release_hook(self)
 
     # not /technically/ a valid repr(), but meh
     def __repr__(self):
@@ -49,25 +50,25 @@ class TestingFarmRemote(Remote, connection.ssh.ManagedSSHConn):
 
 
 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, max_retries=10, **reserve_kwargs):
+    # 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):
         """
         '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.
-
         'max_retries' is a maximum number of provisioning (Testing Farm) errors
         that will be reprovisioned before giving up.
         """
         self.lock = threading.RLock()
         self.compose = compose
         self.arch = arch
-        self.max_systems = max_systems
         self.reserve_kwargs = reserve_kwargs
         self.retries = max_retries
 
@@ -100,7 +101,7 @@ class TestingFarmProvisioner(Provisioner):
             "Hostname": machine.host,
             "User": machine.user,
             "Port": machine.port,
-            "IdentityFile": machine.ssh_key,
+            "IdentityFile": machine.ssh_key.absolute(),
             "ConnectionAttempts": "1000",
             "Compression": "yes",
         }
@@ -134,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,
@@ -157,45 +159,40 @@ class TestingFarmProvisioner(Provisioner):
         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
-            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 get_remote(self, block=True):
-        # fill .release()d remotes back up with reservations
+    def provision(self, count=1):
         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
+            reservations = len(self.remotes) + len(self.reserving)
+            # clamp count to absolute_max_remotes
+            if count + reservations > self.absolute_max_remotes:
+                count = self.absolute_max_remotes - reservations
+            # spread out the request submissions
+            for i in range(count):
+                delay = (api.Request.api_query_limit / count) * i
                 self._schedule_one_reservation(delay)
 
+    def get_remote(self, block=True):
         while True:
             # otherwise wait on a queue of Remotes being provisioned
             try:
@@ -204,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
@@ -218,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

@@ -1,76 +1,71 @@
-import inspect
+import os
 import logging
-from pathlib import Path
+import inspect
 
 _logger = logging.getLogger("atex")
 
+# which functions to skip when determining the logger function caller;
+# typically, these are wrappers and we want to see their caller in the trace
+# instead of them
+#
+# ( file basename , qualname )
+# where qualname is '<module>' or 'funcname' or 'Classname.funcname'
+skip_levels = {
+    ("subprocess.py", "subprocess_run"),
+    ("subprocess.py", "subprocess_output"),
+    ("subprocess.py", "subprocess_Popen"),
+    ("subprocess.py", "subprocess_stream"),
+    ("subprocess.py", "subprocess_log"),
 
-def in_debug_mode():
-    """
-    Return True if the root logger is using the DEBUG (or more verbose) level.
-    """
-    # TODO: use _logger.isEnabledFor() ?
-    root_level = logging.getLogger().level
-    return root_level > 0 and root_level <= logging.DEBUG
+    ("podman.py", "PodmanConnection.cmd"),
+    ("podman.py", "PodmanConnection.rsync"),
 
+    ("ssh.py", "StatelessSSHConnection.cmd"),
+    ("ssh.py", "StatelessSSHConnection.rsync"),
+    ("ssh.py", "ManagedSSHConnection.forward"),
+    ("ssh.py", "ManagedSSHConnection.cmd"),
+    ("ssh.py", "ManagedSSHConnection.rsync"),
+}
 
-def _format_msg(msg, *, skip_frames=0):
-    stack = inspect.stack()
-    if len(stack)-1 <= skip_frames:
-        raise SyntaxError("skip_frames exceeds call stack (frame count)")
-    stack = stack[skip_frames+1:]
 
-    # bottom of the stack, or runpy executed module
-    for frame_info in stack:
-        if frame_info.function == "<module>":
+def _log_msg(logger_func, *args, stacklevel=1, **kwargs):
+    # inspect.stack() is MUCH slower
+    caller = inspect.currentframe().f_back.f_back
+    extra_levels = 2  # skip this func and the debug/info/warning parent
+    while caller.f_back:
+        code = caller.f_code
+        # pathlib is much slower
+        basename = os.path.basename(code.co_filename)  # noqa: PTH119
+        qualname = code.co_qualname
+        if (basename, qualname) in skip_levels:
+            extra_levels += 1
+            caller = caller.f_back
+        else:
             break
-    module = frame_info
-
-    # last (topmost) function that isn't us
-    parent = stack[0]
-    function = parent.function
-
-    # if the function has 'self' and it looks like a class instance,
-    # prepend it to the function name
-    argvals = inspect.getargvalues(parent.frame)
-    if argvals.args:
-        if argvals.args[0] == "self":
-            self = argvals.locals["self"]
-            if hasattr(self, "__class__") and inspect.isclass(self.__class__):
-                function = f"{self.__class__.__name__}.{function}"
-        elif argvals.args[0] == "cls":
-            cls = argvals.locals["cls"]
-            if inspect.isclass(cls):
-                function = f"{cls.__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__"]
-        # 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}"
-    else:
-        return f"{Path(parent.filename).name}:{parent.lineno}: {msg}"
-
-
-def debug(msg, *, skip_frames=0):
-    if in_debug_mode():
-        _logger.debug(_format_msg(msg, skip_frames=skip_frames+1))
-    else:
-        _logger.debug(msg)
-
-
-def info(msg, *, skip_frames=0):
-    if in_debug_mode():
-        _logger.info(_format_msg(msg, skip_frames=skip_frames+1))
-    else:
-        _logger.info(msg)
-
-
-def warning(msg, *, skip_frames=0):
-    if in_debug_mode():
-        _logger.warning(_format_msg(msg, skip_frames=skip_frames+1))
-    else:
-        _logger.warning(msg)
+    return logger_func(*args, stacklevel=stacklevel+extra_levels, **kwargs)
+
+
+def warning(*args, **kwargs):
+    return _log_msg(_logger.warning, *args, **kwargs)
+
+
+def info(*args, **kwargs):
+    return _log_msg(_logger.info, *args, **kwargs)
+
+
+def debug(*args, **kwargs):
+    return _log_msg(_logger.debug, *args, **kwargs)
+
+
+# add a log level more verbose than logging.DEBUG, for verbose command
+# outputs, big JSON / XML printouts, and other outputs unsuitable for
+# large parallel runs; to be used in targeted debugging
+#
+# logging.DEBUG is 10, and programs tend to add TRACE as 5, so be somewhere
+# in between
+EXTRADEBUG = 8
+logging.addLevelName(EXTRADEBUG, "EXTRADEBUG")
+
+
+def extradebug(*args, **kwargs):
+    return _log_msg(_logger.log, EXTRADEBUG, *args, **kwargs)

atex/util/subprocess.py

@@ -1,52 +1,86 @@
 import subprocess
 
-from .log import debug
+from .log import extradebug
 
 
-def subprocess_run(cmd, *, skip_frames=0, **kwargs):
+def subprocess_run(cmd, **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: {cmd}", skip_frames=skip_frames+1)
+    extradebug(f"running: '{cmd}' with {kwargs=}")
     return subprocess.run(cmd, **kwargs)
 
 
-def subprocess_output(cmd, *, skip_frames=0, check=True, text=True, **kwargs):
+def subprocess_output(cmd, *, 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)
+    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
 
 
-def subprocess_Popen(cmd, *, skip_frames=0, **kwargs):  # noqa: N802
+def subprocess_Popen(cmd, **kwargs):  # noqa: N802
     """
     A simple wrapper for the real subprocess.Popen() that logs the command used.
     """
-    debug(f"running: {cmd}", skip_frames=skip_frames+1)
+    extradebug(f"running: '{cmd}' with {kwargs=}")
     return subprocess.Popen(cmd, **kwargs)
 
 
-def subprocess_stream(cmd, *, check=False, skip_frames=0, **kwargs):
+def subprocess_stream(cmd, *, stream="stdout", check=False, input=None, **kwargs):
     """
     Run 'cmd' via subprocess.Popen() and return an iterator over any lines
     the command outputs on stdout, in text mode.
 
+    The 'stream' is a subprocess.Popen attribute (either 'stdout' or 'stderr')
+    to read from.
+    To capture both stdout and stderr as yielded lines, use 'stream="stdout"'
+    and pass an additional 'stderr=subprocess.STDOUT'.
+
     With 'check' set to True, raise a CalledProcessError if the 'cmd' failed.
 
-    To capture both stdout and stderr as yielded lines, use subprocess.STDOUT.
+    Similarly, 'input' simulates the 'input' arg of subprocess.run().
+    Note that the input is written to stdin of the process *before* any outputs
+    are streamed, so it should be sufficiently small and/or not cause a deadlock
+    with the process waiting for outputs to be read before consuming more input.
+    Use 'stdin=subprocess.PIPE' and write to it manually if you need more.
     """
-    debug(f"running: {cmd}", skip_frames=skip_frames+1)
-    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, text=True, **kwargs)
+    all_kwargs = {
+        "text": True,
+        stream: subprocess.PIPE,
+    }
+    if input is not None:
+        all_kwargs["stdin"] = subprocess.PIPE
+    all_kwargs |= kwargs
+
+    extradebug(f"running: '{cmd}' with {all_kwargs=}")
+    proc = subprocess.Popen(cmd, **all_kwargs)
 
     def generate_lines():
-        for line in proc.stdout:
+        if input is not None:
+            proc.stdin.write(input)
+            proc.stdin.close()
+        line_stream = getattr(proc, stream)
+        for line in line_stream:
             yield line.rstrip("\n")
         code = proc.wait()
         if code > 0 and check:
             raise subprocess.CalledProcessError(cmd=cmd, returncode=code)
 
     return (proc, generate_lines())
+
+
+def subprocess_log(cmd, **kwargs):
+    """
+    A wrapper to stream every (text) line output from the process to the
+    logging module.
+
+    Uses subprocess_stream() to gather the lines.
+    """
+    extradebug(f"running: '{cmd}' with {kwargs=}")
+    _, lines = subprocess_stream(cmd, **kwargs)
+    for line in lines:
+        extradebug(line)

atex/util/threads.py

@@ -97,3 +97,10 @@ class ThreadQueue:
                 except KeyError:
                     break
             thread.join()
+
+    def qsize(self):
+        """
+        Return the amount of elements .get() can retrieve before it raises
+        queue.Empty.
+        """
+        return self.queue.qsize()