def __init__(self, queue: Any, prefetch: int, timeout: int) -> None:
self.logger = get_logger(__name__, type(self))
self.queue = queue
self.prefetch = min(prefetch, MAX_PREFETCH)
self.timeout = timeout # UNUSED
self.messages: deque = deque()
self.message_refc = 0
def __init__(self, *, backend: EventBackend, abortable: bool = True):
self.logger = get_logger(__name__, type(self))
self.abortable = abortable
self.backend = backend
self.wait_timeout = 1000
self.abort_ttl = 90000
self.abortables: Dict[str, int] = {}
# This lock avoid race between the monitor and a task cleaning up.
self.lock = threading.Lock()
def __init__(self, *, namespace="dramatiq-results", encoder=None, client=None, url=None, **parameters):
super().__init__(namespace=namespace, encoder=encoder)
self.logger = get_logger(__name__, type(self))
if url:
parameters["connection_pool"] = redis.ConnectionPool.from_url(url)
# TODO: Replace usages of StrictRedis (redis-py 2.x) with Redis in Dramatiq 2.0.
self.client = client or redis.StrictRedis(**parameters)
class Abortable(Middleware):
"""Middleware that interrupts actors whose job has been signaled for
termination.
Currently, this is only available on CPython.
This middleware also adds an ``abortable`` option that can be set on
dramatiq ``actor`` and ``send_with_options``. Value priority is respectively
``send_with_options``, ``actor`` and this ``Abortable``.
Note: This works by setting an async exception in the worker thread
that runs the actor. This means that the exception will only get
called the next time that thread acquires the GIL. Concretely,
this means that this middleware can't cancel system calls.
:param backend: Event backend used to signal termination from a broker to
the workers. See :class:`RedisBackend`.
:type backend: :class:`EventBackend`
:param abortable: Set the default value for every actor ``abortable``
option.
"""
def __init__(
self,
*,
backend: EventBackend,
abortable: bool = True,
abort_ttl: int = 90_000,
):
self.logger = get_logger(__name__, type(self))
self.abortable = abortable
self.backend = backend
self.wait_timeout = 1000
self.abort_ttl = abort_ttl
self.manager: Any = None
if is_gevent_active():
self.manager = _GeventAbortManager(self.logger)
else:
self.manager = _CtypesAbortManager(self.logger)
# This lock avoid race between the monitor and a task cleaning up.
self.lock = threading.Lock()
def __init__(self, logger: Optional[Logger] = None):
self.logger = logger or get_logger(__name__, type(self))
self.abortables: Dict[str, Tuple[int, Greenlet]] = {}