workercommon 0.4.1__py3-none-any.whl

workercommon/worker.py

@@ -0,0 +1,347 @@
+#!/usr/bin/env python3
+import sys
+
+if sys.version_info < (3, 8):
+    raise RuntimeError("At least Python 3.8 is required")
+
+from pathlib import Path
+from .database import Connection, Cursor
+from . import rabbitmqueue
+import json, re, pika.connection, pika.channel, pika.spec, logging
+from collections.abc import Mapping
+from time import sleep
+from threading import Thread, Lock
+from typing import Iterable, Optional, Any, Callable, List
+from multiprocessing import Process, Manager, Event
+from multiprocessing.managers import SyncManager
+from concurrent.futures import ThreadPoolExecutor
+
+
+class BaseWorker(object):
+    def start(self) -> None:
+        raise NotImplementedError
+
+    def stop(self) -> None:
+        raise NotImplementedError
+
+    def join(self, timeout: Optional[float] = None) -> None:
+        raise NotImplementedError
+
+
+class ThreadWorker(BaseWorker, Thread):
+    def __init__(self):
+        BaseWorker.__init__(self)
+        Thread.__init__(self)
+
+    def start(self) -> None:
+        Thread.start(self)
+
+    def join(self, timeout: Optional[float] = None) -> None:
+        Thread.join(self, timeout)
+
+
+class ReaderWorker(ThreadWorker):
+    def __init__(
+        self,
+        database_source: Callable[[], Connection],
+        readq_parameters: rabbitmqueue.Parameters,
+        any_exchange: bool = False,
+        **readq_arguments: Any,
+    ):
+        super().__init__()
+        self.lock = Lock()
+        self.readq_parameters = readq_parameters
+        self.readq_arguments = readq_arguments
+        self.readq: Optional[rabbitmqueue.ReceiveSendQueue] = None
+
+        self.database_source: Optional[Callable[[], Connection]] = database_source
+        self.database: Optional[Connection] = None
+        self.restart = True
+        self.outbox: List[rabbitmqueue.ToSend] = []
+        self.any_exchange = any_exchange
+
+        self.callback_pool_lock = Lock()
+        self.callback_pool: Optional[ThreadPoolExecutor] = None
+
+    def get_readq(self) -> rabbitmqueue.ReceiveSendQueue:
+        if self.readq is None:
+            raise RuntimeError("Read rabbitmqueue is not available")
+        return self.readq
+
+    def on_start(self) -> None:
+        pass
+
+    def on_stop(self) -> None:
+        pass
+
+    def run(self) -> None:
+        try:
+            with self.callback_pool_lock:
+                self.callback_pool = ThreadPoolExecutor(
+                    max_workers=1, thread_name_prefix="reader-callback"
+                )
+
+            self.on_start()
+
+            while self.restart:
+                with self.lock:
+                    self.restart = False
+                    self.readq = rabbitmqueue.ReceiveSendQueue(
+                        self.readq_parameters,
+                        self.callback,
+                        self.maybe_restart,
+                        **self.readq_arguments,
+                    )
+                if self.outbox:
+                    with self.lock:
+                        if self.readq is not None:
+                            self.readq.add_to_outbox(self.outbox)
+                            self.outbox.clear()
+
+                try:
+                    self.get_readq().run()
+                except BaseException:
+                    logging.exception("Lost the queue connection")
+
+                with self.lock:
+                    if self.readq is not None:
+                        self.outbox.extend(self.readq.get_outbox())
+
+                with self.lock:
+                    restart = self.restart
+
+                if restart:
+                    logging.info("Trying to start a new one")
+                    with self.lock:
+                        if self.readq is not None:
+                            try:
+                                self.readq.close()
+                            except BaseException:
+                                logging.exception("Failed to close existing readq")
+                            finally:
+                                self.readq = None
+
+                elif self.outbox:
+                    logging.info(f"Trying to send outbox: {self.outbox}")
+                    rabbitmqueue.SendQueue.quick_send(self.readq_parameters, self.outbox)
+
+        finally:
+            try:
+                self.on_stop()
+            finally:
+                self.close()
+
+    def maybe_restart(self, restart: bool, remaining: List[rabbitmqueue.ToSend]) -> None:
+        with self.lock:
+            self.restart = restart
+            self.outbox.extend(remaining)
+
+    def close(self) -> None:
+        with self.callback_pool_lock:
+            if self.callback_pool is not None:
+                self.callback_pool.shutdown()
+                self.callback_pool = None
+
+        if self.database_source is not None:
+            self.database_source = None
+
+        if self.database is not None:
+            self.database.close()
+            self.database = None
+
+    def get_cursor(self) -> Cursor:
+        if self.database is None:
+            if self.database_source is None:
+                raise RuntimeError("Database source is unavailable")
+            self.database = self.database_source()
+
+        return self.database.cursor()
+
+    def get_callback_pool(self) -> ThreadPoolExecutor:
+        with self.callback_pool_lock:
+            if self.callback_pool is None:
+                raise RuntimeError("callback_pool is not available")
+
+            return self.callback_pool
+
+    def allow_properties(self, properties: pika.spec.BasicProperties) -> bool:
+        return True
+
+    def ack(self, channel: pika.channel.Channel, delivery_tag: int) -> None:
+        logging.debug(f"ACKing {delivery_tag} in {channel}")
+        channel.basic_ack(delivery_tag)
+
+    def nack(self, channel: pika.channel.Channel, delivery_tag: int) -> None:
+        logging.debug(f"NACKing {delivery_tag} in {channel}")
+        channel.basic_nack(delivery_tag)
+
+    def callback_job(
+        self,
+        ch: pika.channel.Channel,
+        method: pika.spec.Basic.Deliver,
+        properties: pika.spec.BasicProperties,
+        body: str,
+    ) -> None:
+        "Run within a background thread"
+        try:
+            if not self.allow_properties(properties):
+                logging.debug(f"Not handling due to properties: {properties}")
+                return
+
+            root = json.loads(body)
+            filtered = self.filter_message(root)
+
+            if filtered is not None:
+                with self.get_cursor() as cursor:
+                    self.handle_message(cursor, filtered)
+
+            logging.debug(f"Successfully handled {method.delivery_tag}")
+            self.get_readq().add_callback_threadsafe(
+                lambda: self.ack(ch, method.delivery_tag)
+            )
+
+        except BaseException as e:
+            logging.exception(f"Failed to handle message: {e}")
+            try:
+                self.get_readq().add_callback_threadsafe(
+                    lambda: self.nack(ch, method.delivery_tag)
+                )
+            except BaseException:
+                logging.exception(f"Failed to NACK {method.delivery_tag} in {ch}")
+
+    def callback(
+        self,
+        ch: pika.channel.Channel,
+        method: pika.spec.Basic.Deliver,
+        properties: pika.spec.BasicProperties,
+        body: str,
+    ) -> None:
+        if self.readq_parameters.exchange:
+            if (
+                not self.any_exchange
+                and method.exchange != self.readq_parameters.exchange
+            ):
+                return
+
+        try:
+            self.get_callback_pool().submit(
+                self.callback_job, ch, method, properties, body
+            )
+
+        except BaseException as e:
+            logging.exception(f"Failed to submit message to callback pool: {e}")
+            try:
+                self.nack(ch, method.delivery_tag)
+            except BaseException:
+                logging.exception(f"Failed to NACK {method.delivery_tag} in {ch}")
+
+    def filter_message(self, message: Any) -> Optional[Any]:
+        # Return value will be passed on to handle_message(), but only if isn't None.
+        raise NotImplementedError
+
+    def handle_message(self, cursor: Cursor, message: Any) -> None:
+        raise NotImplementedError
+
+    def stop(self) -> None:
+        with self.lock:
+            if self.readq is not None:
+                self.readq.close()
+                self.outbox.extend(self.readq.get_outbox())
+                self.readq = None
+
+
+class ReaderWorkerWithRetryLimit(ReaderWorker):
+    DEATH_HEADER = "x-death"
+    COUNT = "count"
+    REASON = "reason"
+    EXPIRED = "expired"
+
+    def __init__(
+        self,
+        database_source: Callable[[], Connection],
+        readq_parameters: rabbitmqueue.Parameters,
+        retry_limit: int,
+        any_exchange: bool = False,
+        **readq_arguments: Any,
+    ):
+        if retry_limit < 1:
+            raise ValueError(f"Invalid retry limit: {retry_limit}")
+
+        super().__init__(
+            database_source,
+            readq_parameters,
+            any_exchange,
+            **readq_arguments,
+        )
+        self.retry_limit = retry_limit
+
+    def nack(self, channel: pika.channel.Channel, delivery_tag: int) -> None:
+        logging.debug(f"NACKing {delivery_tag} in {channel}")
+        channel.basic_nack(delivery_tag, requeue=False)
+
+    @classmethod
+    def _get_expiration_count(cls, death: Iterable[Mapping[str, Any]]) -> Optional[int]:
+        for entry in death:
+            if (
+                entry.get(cls.REASON) == cls.EXPIRED and
+                (count := entry.get(cls.COUNT)) is not None
+            ):
+                return count
+        return None
+
+    def allow_properties(self, properties: pika.spec.BasicProperties) -> bool:
+        if not properties.headers:
+            return True
+
+        if (death := properties.headers.get(self.DEATH_HEADER)) and isinstance(death, list):
+            if (
+                (count := self._get_expiration_count(death)) is not None and
+                count > self.retry_limit
+            ):
+                logging.warning(f"Giving up after {count} attempts")
+                return False
+
+        return True
+
+
+class BaseWorkerManager(Process):
+    def stop(self) -> None:
+        raise NotImplementedError
+
+
+class WorkerManager(BaseWorkerManager):
+    def __init__(
+        self,
+        manager: SyncManager,
+        worker_source: Callable[[BaseWorkerManager], BaseWorker],
+        daemon: bool = True,
+    ):
+        super().__init__(daemon=daemon)
+        self.manager = manager
+        self.kill_event = manager.Event()
+        self.worker_source = worker_source
+        self.worker: Optional[BaseWorker] = None
+
+    def run(self) -> None:
+        self.worker = self.worker_source(self)
+        if self.worker is None:
+            raise RuntimeError("Failed to create worker")
+
+        try:
+            self.worker.start()
+            while True:
+                try:
+                    if self.kill_event.wait():
+                        break
+                except KeyboardInterrupt:
+                    continue
+
+        finally:
+            try:
+                self.worker.stop()
+                self.worker.join()
+            finally:
+                self.worker = None
+
+    def stop(self) -> None:
+        self.kill_event.set()

workercommon-0.4.1.dist-info/METADATA

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: workercommon
+Version: 0.4.1
+Summary: Support code for various projects
+Author-email: "Neil E. Hodges" <47hasbegun@gmail.com>
+License-Expression: BSD-3-Clause
+Project-URL: Repository, https://gitgud.io/takeshitakenji/workercommon
+Project-URL: Issues, https://gitgud.io/takeshitakenji/workercommon/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.TXT
+Requires-Dist: psycopg2
+Requires-Dist: pika
+Dynamic: license-file
+
+# Requirements
+
+1. Python 3.8
+2. A Unix-like OS for `fcntl` support
+3. [psycopg2](https://www.psycopg.org/)
+4. [Pika](https://pika.readthedocs.io/en/stable/)

workercommon-0.4.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+workercommon/__init__.py,sha256=fACYRNZj4tmBo_b4y3bXOxuh9Z8RAGOdyYfsB3du5SA,214
+workercommon/background.py,sha256=GnxekfqTdCwJxEYWs4CRjw8wX8wil6NMSsOBdprC9Tk,2315
+workercommon/commands.py,sha256=nh_IFldPdoJARZfuu25Ek386FjvJ29o8jFrBCk-cAxw,1221
+workercommon/config.py,sha256=IRoXNz-XxoRY4uTAM8WgXBtGu4uCwuGQ-nn4W8q_QDw,2635
+workercommon/connectionpool.py,sha256=Me9ZG7_01WsJS7y4NI8hn9hDtp7NjUCiXN8IGsDHoug,2944
+workercommon/locking.py,sha256=XzscyiQfC0H81u3PHvYI-MbtQgGeeGO4W0QHfTmOlZk,1539
+workercommon/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+workercommon/rabbitmqueue.py,sha256=QG0QhwjGkDfXLJgAka0q5I0211EvVBE6fLjjr4RKVFM,14916
+workercommon/test.py,sha256=q9xVCke9V_aw7lvcFrYpM8M--pSgVAW-WVvXmuhnrEs,6014
+workercommon/worker.py,sha256=ZW3_A_Rrp-yIuO930QbFDpW6z21Z1EH24UH-dHGDQcw,11226
+workercommon/database/__init__.py,sha256=gIRWSp1G7uViNiH0M6k4qJ0U8zgyXZAB4-0Ez5EBS1Y,305
+workercommon/database/base.py,sha256=q4Pj1IsBY9VVgTMgq7C8MPUtMhIIH9pqVNsky3GmlGQ,5237
+workercommon/database/pg.py,sha256=YxAVg_ed6a8MUSauRUfTi-k3HxeDWvF1vU7zvk1xQGY,8802
+workercommon/database/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+workercommon-0.4.1.dist-info/licenses/LICENSE.TXT,sha256=OAxGb1o7fGlNe_idAAo-h19FOhyzCyMknW9jzKBFhec,1267
+workercommon-0.4.1.dist-info/METADATA,sha256=MxFVJ0vRtx4Bdt-b0P8rMluRpPvg5JYq7s4TrElkGrY,857
+workercommon-0.4.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+workercommon-0.4.1.dist-info/top_level.txt,sha256=8Gvm4g09owW_DX-sx4TJmGsfuGj39DEr3Ovpy-jnhr0,13
+workercommon-0.4.1.dist-info/RECORD,,

workercommon-0.4.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

workercommon-0.4.1.dist-info/licenses/LICENSE.TXT

@@ -0,0 +1,9 @@
+Copyright 2020 Neil E. Hodges
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

workercommon-0.4.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+workercommon