blueque 1.0.0__py3-none-any.whl

blueque/__init__.py

@@ -0,0 +1 @@
+from blueque.client import Client  # noqa: F401

blueque/client.py

@@ -0,0 +1,32 @@
+from blueque.listener import Listener
+from blueque.processor import Processor
+from blueque.queue import Queue
+from blueque.redis_queue import RedisQueue
+from blueque.redis_task import RedisTask
+from blueque.task import Task
+
+import redis
+
+
+class Client(object):
+    def __init__(self, url, **kwargs):
+        super(Client, self).__init__()
+
+        self._redis = redis.StrictRedis.from_url(url, decode_responses=True, **kwargs)
+
+    def get_queue(self, name):
+        redis_queue = RedisQueue(name, self._redis)
+        return Queue(name, redis_queue)
+
+    def get_task(self, task_id):
+        redis_task = RedisTask(task_id, self._redis)
+        return Task(task_id, redis_task)
+
+    def get_listener(self, queue_name):
+        redis_queue = RedisQueue(queue_name, self._redis)
+        return Listener(redis_queue, self.get_task)
+
+    def get_processor(self, task):
+        redis_queue = RedisQueue(task.queue, self._redis)
+
+        return Processor(task, redis_queue)

blueque/forking_runner.py

@@ -0,0 +1,80 @@
+from blueque.process_helpers import process_running
+
+import logging
+import os
+import random
+import sys
+import time
+
+
+class ForkingRunner(object):
+    def __init__(self, client, queue, task_callback):
+        super(ForkingRunner, self).__init__()
+
+        self._client = client
+        self._queue = queue
+        self._task_callback = task_callback
+
+    def fork_task(self, task):
+        pid = os.fork()
+
+        if pid > 0:
+            return pid
+
+        logging.info("Process forked to run task %s" % (task.id))
+
+        # Reseed the random number generator, since we inherited it
+        # from our parent after the fork
+        random.seed()
+
+        os.setsid()
+
+        logging.info("Getting Processor to run task %s" % (task.id))
+        processor = self._client.get_processor(task)
+
+        logging.info("Starting to run task %s" % (task.id))
+        processor.start(os.getpid())
+
+        try:
+            result = self._task_callback(task)
+
+            processor.complete(result)
+        except Exception as e:
+            processor.fail(str(e))
+        finally:
+            # _exit won't flush, so we need to, in case there are
+            # error messages we want to see.
+            logging.shutdown()
+            sys.stdout.flush()
+            sys.stderr.flush()
+
+            os._exit(0)
+
+    def _run_task(self, task):
+        pid = self.fork_task(task)
+
+        logging.info("Forked task %s to pid %i" % (task.id, pid))
+
+        _, status = os.waitpid(pid, 0)
+
+        logging.info(
+            "Forked task %s exited with status %i" % (task.id, os.WEXITSTATUS(status)))
+
+    def run(self):
+        listener = self._client.get_listener(self._queue)
+
+        task = listener.claim_orphan()
+
+        while task is not None:
+            if task.status == "reserved":
+                self._run_task(task)
+            elif task.status == "started":
+                while process_running(task.pid):
+                    time.sleep(0.1)
+
+            task = listener.claim_orphan()
+
+        while True:
+            task = listener.listen()
+
+            self._run_task(task)

blueque/listener.py

@@ -0,0 +1,55 @@
+from blueque.process_helpers import process_running
+
+import os
+import socket
+import time
+
+
+class Listener(object):
+    def __init__(self, queue, task_factory):
+        super(Listener, self).__init__()
+
+        self._hostname = socket.getfqdn()
+        self._pid = os.getpid()
+        self._name = "_".join((self._hostname, str(self._pid)))
+        self._queue = queue
+        self._queue.add_listener(self._name)
+        self._task_factory = task_factory
+
+    def _parse_name(self, name):
+        host, pid = name.rsplit('_', 1)
+
+        return host, int(pid)
+
+    def listen(self):
+        while True:
+            task_id = self._queue.dequeue(self._name)
+            if task_id is not None:
+                return self._task_factory(task_id)
+            else:
+                time.sleep(1)
+
+    def claim_orphan(self):
+        for listener in self._queue.get_listeners():
+            host, pid = self._parse_name(listener)
+
+            if host != self._hostname:
+                continue
+
+            if pid == self._pid:
+                continue
+
+            if process_running(pid):
+                continue
+
+            if self._queue.remove_listener(listener) == 0:
+                # already claimed
+                continue
+
+            task_id = self._queue.reclaim_task(listener, self._name)
+            if task_id is None:
+                continue
+
+            return self._task_factory(task_id)
+
+        return None

blueque/process_helpers.py

@@ -0,0 +1,9 @@
+import os
+
+
+def process_running(pid):
+    try:
+        os.kill(pid, 0)
+        return True
+    except OSError:
+        return False

blueque/processor.py

@@ -0,0 +1,18 @@
+class Processor(object):
+    def __init__(self, task, redis_queue):
+        super(Processor, self).__init__()
+
+        self._listener_id = task.node
+        self._task_id = task.id
+        self._pid = task.pid
+        self._redis_queue = redis_queue
+
+    def start(self, pid):
+        self._pid = pid
+        self._redis_queue.start(self._task_id, self._listener_id, self._pid)
+
+    def complete(self, result):
+        self._redis_queue.complete(self._task_id, self._listener_id, self._pid, result)
+
+    def fail(self, error):
+        self._redis_queue.fail(self._task_id, self._listener_id, self._pid, error)

blueque/queue.py

@@ -0,0 +1,21 @@
+class Queue(object):
+    def __init__(self, name, redis_queue):
+        super(Queue, self).__init__()
+
+        self._name = name
+        self._redis_queue = redis_queue
+
+    def enqueue(self, parameters):
+        return self._redis_queue.enqueue(parameters)
+
+    def schedule(self, parameters, eta):
+        return self._redis_queue.schedule(parameters, eta)
+
+    def enqueue_due_tasks(self):
+        self._redis_queue.enqueue_due_tasks()
+
+    def delete_task(self, task):
+        if task.queue != self._name:
+            raise ValueError("Task %s is not in queue %s" % (task.id, self._name))
+
+        self._redis_queue.delete_task(task.id, task.status)

blueque/redis_queue.py

@@ -0,0 +1,224 @@
+from blueque.redis_task import RedisTask
+
+import logging
+import time
+import uuid
+
+
+class RedisQueue(object):
+    def __init__(self, name, redis_client):
+        super(RedisQueue, self).__init__()
+
+        self._name = name
+        self._pending_name = self._key("pending_tasks", self._name)
+        self._scheduled_key = self._key("scheduled_tasks", self._name)
+
+        self._queues_key = self._key("queues")
+        self._started_key = self._key("started_tasks", self._name)
+        self._listeners_key = self._key("listeners", self._name)
+
+        self._complete_key = self._key("complete_tasks", self._name)
+        self._failed_key = self._key("failed_tasks", self._name)
+
+        self._redis = redis_client
+
+    def _running_job(self, node_id, pid, task_id):
+        return " ".join((node_id, str(pid), task_id))
+
+    def _key(self, *args):
+        return '_'.join(("blueque",) + args)
+
+    def _reserved_key(self, node_id):
+        return self._key("reserved_tasks", self._name, node_id)
+
+    def _generate_task_id(self):
+        return str(uuid.uuid4())
+
+    def _log(self, message):
+        logging.info("Blueque queue %s: %s" % (self._name, message))
+
+    def _debug(self, message):
+        logging.debug("Blueque queue %s: %s" % (self._name, message))
+
+    def add_listener(self, node_id):
+        self._log("adding listener %s" % (node_id))
+        with self._redis.pipeline() as pipeline:
+            pipeline.sadd(self._listeners_key, node_id)
+            pipeline.zincrby(self._queues_key, 1, self._name)
+            pipeline.execute()
+
+    def remove_listener(self, node_id):
+        self._log("removing listener %s" % (node_id))
+
+        removed = self._redis.srem(self._listeners_key, node_id)
+
+        if removed > 0:
+            self._log("removed listener")
+            self._redis.zincrby(self._queues_key, -1, self._name)
+
+        return removed
+
+    def get_listeners(self):
+        return self._redis.smembers(self._listeners_key)
+
+    def _generate_task(self, pipeline, status, parameters, **kwargs):
+        task_id = self._generate_task_id()
+
+        self._log("adding %s task %s, parameters: %s" % (status, task_id, parameters))
+
+        now = time.time()
+
+        task_data = {
+            "status": status,
+            "queue": self._name,
+            "parameters": parameters,
+            "created": now,
+            "updated": now
+        }
+
+        task_data.update(kwargs)
+
+        pipeline.hset(RedisTask.task_key(task_id), mapping=task_data)
+
+        pipeline.zincrby(self._key("queues"), 0, self._name)
+
+        return task_id
+
+    def schedule(self, parameters, eta):
+        if eta < time.time():
+            return self.enqueue(parameters)
+
+        with self._redis.pipeline() as pipeline:
+            task_id = self._generate_task(pipeline, "scheduled", parameters, eta=eta)
+
+            pipeline.zadd(self._scheduled_key, {task_id: eta})
+
+            pipeline.execute()
+
+        return task_id
+
+    def enqueue(self, parameters):
+        with self._redis.pipeline() as pipeline:
+            task_id = self._generate_task(pipeline, "pending", parameters)
+
+            pipeline.lpush(self._pending_name, task_id)
+
+            pipeline.execute()
+
+        return task_id
+
+    def enqueue_due_tasks(self):
+        def enqueue_transaction(pipeline):
+            now = time.time()
+            due_tasks = pipeline.zrangebyscore(self._scheduled_key, 0, now)
+
+            if len(due_tasks) == 0:
+                self._debug("no due tasks")
+                return
+
+            self._log("enqueuing due tasks: %s" % (due_tasks))
+
+            pipeline.multi()
+
+            pipeline.zremrangebyscore(self._scheduled_key, 0, now)
+
+            for task in due_tasks:
+                pipeline.lpush(self._pending_name, task)
+                pipeline.hset(
+                    RedisTask.task_key(task), mapping={"status": "pending", "updated": now})
+
+        self._redis.transaction(enqueue_transaction, self._scheduled_key)
+
+    def dequeue(self, node_id):
+        self._debug("reserving task on %s" % (node_id))
+
+        task_id = self._redis.rpoplpush(
+            self._pending_name, self._reserved_key(node_id))
+
+        if task_id is None:
+            return None
+
+        self._log("got task %s" % (task_id))
+
+        self._redis.hset(
+            RedisTask.task_key(task_id),
+            mapping={
+                "status": "reserved",
+                "node": node_id,
+                "updated": time.time()
+            })
+
+        return task_id
+
+    def start(self, task_id, node_id, pid):
+        self._log("starting task %s on %s, pid %i" % (task_id, node_id, pid))
+        with self._redis.pipeline() as pipeline:
+            pipeline.sadd(self._started_key, self._running_job(node_id, pid, task_id))
+            pipeline.hset(
+                RedisTask.task_key(task_id),
+                mapping={"status": "started", "pid": pid, "updated": time.time()})
+
+            pipeline.execute()
+
+    def reclaim_task(self, old_node, new_node):
+        task_id = self._redis.lindex(self._reserved_key(old_node), 0)
+
+        if task_id is not None:
+            self._redis.hset(RedisTask.task_key(task_id), "reclaimed_node", new_node)
+
+        return task_id
+
+    def complete(self, task_id, node_id, pid, result):
+        self._log(
+            "completing task %s on %s, pid: %i, result: %s" % (task_id, node_id, pid, result))
+
+        with self._redis.pipeline() as pipeline:
+            pipeline.lrem(self._reserved_key(node_id), 1, task_id)
+            pipeline.srem(self._started_key, self._running_job(node_id, pid, task_id))
+
+            pipeline.hset(
+                RedisTask.task_key(task_id),
+                mapping={
+                    "status": "complete",
+                    "result": result,
+                    "updated": time.time()
+                })
+
+            pipeline.lpush(self._complete_key, task_id)
+
+            pipeline.execute()
+
+    def fail(self, task_id, node_id, pid, error):
+        self._log("failed task %s on %s, pid: %i, error: %s" % (task_id, node_id, pid, error))
+
+        with self._redis.pipeline() as pipeline:
+            pipeline.lrem(self._reserved_key(node_id), 1, task_id)
+            pipeline.srem(self._started_key, self._running_job(node_id, pid, task_id))
+
+            pipeline.hset(
+                RedisTask.task_key(task_id),
+                mapping={
+                    "status": "failed",
+                    "error": error,
+                    "updated": time.time()
+                })
+
+            pipeline.lpush(self._failed_key, task_id)
+
+            pipeline.execute()
+
+    def delete_task(self, task_id, task_status):
+        if task_status == "complete":
+            finished_queue = self._complete_key
+        elif task_status == "failed":
+            finished_queue = self._failed_key
+        else:
+            raise ValueError("Cannot delete task with status %s" % (task_status))
+
+        self._log("deleting task %s with status %s" % (task_id, task_status))
+
+        with self._redis.pipeline() as pipeline:
+            pipeline.delete(RedisTask.task_key(task_id))
+            pipeline.lrem(finished_queue, 1, task_id)
+
+            pipeline.execute()

blueque/redis_task.py

@@ -0,0 +1,32 @@
+from collections import defaultdict
+
+
+class RedisTask(object):
+    _field_types = defaultdict(lambda: str, {
+        "pid": int,
+        "created": float,
+        "updated": float
+    })
+
+    def __init__(self, id, redis):
+        super(RedisTask, self).__init__()
+
+        self._id = id
+        self._redis = redis
+        self._task_key = self.task_key(self._id)
+
+    @staticmethod
+    def task_key(task_id):
+        return RedisTask._key("task", task_id)
+
+    @staticmethod
+    def _key(*args):
+        return '_'.join(("blueque",) + args)
+
+    def get_task_data(self):
+        task_data = {}
+
+        for field, value in self._redis.hgetall(self._task_key).items():
+            task_data[field] = self._field_types[field](value)
+
+        return task_data

blueque/task.py

@@ -0,0 +1,46 @@
+class Task(object):
+    def __init__(self, id, redis_task):
+        super(Task, self).__init__()
+
+        self._id = id
+        self._attributes = redis_task.get_task_data()
+
+    @property
+    def id(self):
+        return self._id
+
+    @property
+    def status(self):
+        return self._attributes.get("status")
+
+    @property
+    def queue(self):
+        return self._attributes.get("queue")
+
+    @property
+    def parameters(self):
+        return self._attributes.get("parameters")
+
+    @property
+    def result(self):
+        return self._attributes.get("result")
+
+    @property
+    def error(self):
+        return self._attributes.get("error")
+
+    @property
+    def node(self):
+        return self._attributes.get("node")
+
+    @property
+    def pid(self):
+        return self._attributes.get("pid")
+
+    @property
+    def created(self):
+        return self._attributes.get("created")
+
+    @property
+    def updated(self):
+        return self._attributes.get("updated")

blueque-1.0.0.dist-info/LICENSE

@@ -0,0 +1,11 @@
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

blueque-1.0.0.dist-info/METADATA

@@ -0,0 +1,422 @@
+Metadata-Version: 2.1
+Name: blueque
+Version: 1.0.0
+Summary: Simple job queueing for very long tasks
+License: Apache-2.0
+Author: uStudio Developers
+Author-email: dev@ustudio.com
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: redis (>=5.0.1,<6.0.0)
+Description-Content-Type: text/markdown
+
+# Blueque #
+
+A simple task queue system optimized for very long running
+tasks.
+
+## Terminology ##
+
+* *Queue*
+
+	A list of tasks, of a given type, to be run. Multiple *queues* may
+    be used to execute different types of tasks on different *nodes*.
+
+* *Task*
+
+	A piece of work to be done, including its parameters, current
+    status, result (if done), etc.
+
+* *Node*
+
+	A computer running tasks from the queue.
+
+* *Listener*
+
+	A process running on a node, listening for new tasks on a single
+    queue. The system does not support multiple listeners listening to
+    the *same queue* on the *same node*.
+
+* *Process*
+
+	A process, running on a *node*, created by a *listener*, executing
+    a *task*.
+
+## API ##
+
+### Client Connection ###
+
+The `Blueque.Client` object stores the connection to the Blueque
+system, and constructs the other objects necessary for interacting
+with the system
+
+```python
+client = Blueque.Client("redis://hostname:port/db")
+```
+
+### Queue ###
+
+The `Blueque.queue.Queue` object provides the interface to a named
+queue of tasks.
+
+```python
+queue = client.get_queue("some.queue")
+```
+
+#### `Queue.enqueue` ####
+
+```python
+task_id = queue.enqueue(parameters)
+```
+
+Returns the Task ID (a string) of the newly enqueued task
+
+### Task ###
+
+The task object provides a basic, read-only view of all the attributes
+of a task.
+
+```python
+task = client.get_task(task_id)
+```
+
+There is a read-only attribute for all of the task attributes stored
+in Redis (see below).
+
+### Listener ###
+
+The listener object provides the interface used to listen for new
+tasks.
+
+```python
+listener = client.get_listener("some.queue")
+```
+
+#### `Listener.listen` ####
+
+```python
+task = listener.listen(on_new_task)
+```
+
+Blocks listening for a new task to execute until one is ready, then
+returns a `Task` object describing that task.
+
+
+### Processor ###
+
+A Processor object provides the interface used to update a task while
+it is being processed.
+
+```python
+processor = client.get_processor(task)
+```
+
+#### `Processor.start` ####
+
+```python
+parameters = processor.start(pid)
+```
+
+Marks a task as being started, by the specified pid, and returns the
+parameters of that task.
+
+#### `Processor.complete` ####
+
+```python
+processor.complete("some result")
+```
+
+Marks a task as being complete, and stores the result.
+
+#### `Processor.fail` ####
+
+```python
+processor.fail("some error")
+```
+
+Marks a task as having failed, and stores the error.
+
+## Data Storage ##
+
+Currently, the backend structure is Redis. Keys are prefixed with a
+namespace, i.e. named "bluequeue_foo", so that other systems can use
+the Redis DB for other things.
+
+### Task Queue ###
+
+`blueque_pending_tasks_[queue name]`
+
+Stored in a `List`, accessed as a queue: new tasks are added via
+`LPUSH`, tasks are removed for execution via `RPOP`. There is a `List`
+for each task queue (channel). All that is stored in the `List` is a
+task ID, which will be used to retrieve the task data.
+
+### Listener Task List ###
+
+`blueque_reserved_tasks_[queue name]_[listener ID]`
+
+Stored in a `List`, this is used to keep track of which listeners are
+running which tasks. Tasks should be atomically moved from the *Task
+Queue* to the *Listener Task List* via `RPOPLPUSH`, so that they don't get
+lost.
+
+### Task Channel ###
+
+Note: this will not be implemented in the first pass.
+
+There is a Pub/Sub `Channel` for each task queue (channel). This can
+be used by the listener client to listen for new tasks if the task queue
+they were interested in was empty when they last checked for a task.
+
+Messages should *not* include the task ID of the newly created task,
+because listeners must be required to manually try to `LPOP` the task
+off the task queue, so that only one work runs each task.
+
+### Task List ###
+
+`blueque_tasks_[queue name]`
+
+There is a list of all the tasks in a queue, regardless of their
+state. This is mostly used for introspection/management purposes.
+
+### Task Data ###
+
+`blueque_task_[task id]`
+
+The actual data associated with a task will be stored as a hash, where
+the key is built from the task ID (i.e. "bluequeue_task_NNNN"). Each
+subsystem will be able to add its own fields to the hash.
+
+Current fields are
+
+* `status`
+
+	One of: `scheduled`, `pending`, `reserved`, `started`, `complete`
+    or `failed`.
+
+* `queue`
+
+	The queue that the task is in (mostly just for debugging
+    purposes).
+
+* `parameters`
+
+	String containing data to be passed to the process. Totally task
+    specific.
+
+* `result`
+
+	String containing the result of the process; totally
+    task-specific. Will not be set if the task hasn't completed yet.
+
+* `error`
+
+	String containing the error generated by the process. Set only if
+    `status` is `failed`.
+
+* `node`
+
+	The listener ID of the node running the task. Will not be set if the
+    task has not been started yet.
+
+* `pid`
+
+	The PID of the process running the task on the node. Will not be
+    set if the task has not been started yet.
+
+* `created`
+
+	A floating point value containing the Python timestampe
+    (`time.time()`) of the time when the task was first created
+    (enqueued).
+
+* `updated`
+
+	A floating point value containing the Python timestamp
+    (`time.time()`) of the last time any value in the task changed.
+
+* `eta`
+
+	The timestamp when the task is scheduled to be executed. Will not
+    be set if the task was not scheduled with an ETA.
+
+### Listeners ###
+
+`blueque_listeners_[queue name]`
+
+In order for the system to be easily introspected, the currently
+active listeners will be stored in a Redis `Set`. Listeners are stored
+by their `LISTENER ID`, which must be `[hostname]_[pid]`.
+
+Note that this means that all hosts in the system must have unique
+names.
+
+### Queues ###
+
+`blueque_queues`
+
+There is a `Sorted Set` containing the names of all the queues, where
+the score of the set is the number of nodes listening to that set.
+
+When a node comes online, it increments the score by 1; when a node
+goes offline (cleanly) it increments the score by -1. Every time a
+task is enqueued, the score should be incremented by 0, so that a
+queue with tasks, but no listeners, still shows up in the set.
+
+## Task Workflow ##
+
+Tasks are executed via this workflow. Note that any `HMSET` call which
+modifies a `blueque_task_[TASK ID]` should be assumed to also set the
+`updated` field of the task.
+
+### Submission ###
+
+Tasks should be submitted by creating a UUID, [TID], JSON encoding the
+parameters, [PARAMS], and then executing:
+
+```
+MULTI
+HMSET blueque_task_[TASK ID] status pending queue [QUEUE] parameters [PARAMS]
+ZINCRBY blueque_queues 0 [QUEUE]
+LPUSH blueque_pending_tasks_[QUEUE] [TASK ID]
+EXEC
+```
+
+### Node Task Pop ###
+
+Nodes should pop a task off the queue and then set the status of the
+task to `started`, and set the `node` field of the task.
+
+If no task is popped off the queue, the Node should wait for a new
+task notification. Ideally, this will be via Pub/Sub, but, at first,
+we can do it by polling.
+
+Tasks are popped using the following commands.
+
+```
+RPOPLPUSH blueque_pending_tasks_[QUEUE] [NODE TASKS]
+```
+
+```
+HMSET blueque_task_[TASK ID] status reserved node [NODE]
+```
+
+Note that these two commands cannot be executed atomically because the
+second depends on the first, and, even with Lua scripting, that cannot
+be done atomically and safely. Therefore, there is a chance that a
+task is popped off the pending queue, but its record is not
+updated. This can be detected if a task is in a node's queue, but has
+a status of `pending`.
+
+### Task Queue Channel Message ###
+
+Note: We will not implement this in the first pass. Listeners will just
+poll once every few seconds.
+
+If a listener receives a message via a Pub/Sub channel that a queue has
+a task in it, it should try to atomically pop a task off that channel
+(see above). If it does get a task, it should unsubscribe from the
+channel; if it does not (i.e. another listener got the task) it should
+remain subscribed.
+
+### Task Started ###
+
+When a process starts executing a task on a node, it should update the
+task to indicate that, and also add itself to a set of all active
+tasks:
+
+```
+MULTI
+SADD blueque_started_tasks_[QUEUE] "[LISTENER ID] [PID] [TASK ID]"
+HMSET blueque_task_[TASK ID] status started pid [PID]
+EXEC
+```
+
+Note that this assumes that the process is told what task to execute,
+rather than pulling it off the node's task list.
+
+### Task Completed Successfully ###
+
+If a task completes successfully, it should set the `status` field of
+the task to `succeeded` and set the `result` field to the
+JSON-serialized result of the task, as a single atomic transaction.
+
+```
+MULTI
+LREM blueque_reserved_tasks_[QUEUE]_[LISTENER ID] 1 [TASK ID]
+ZREM blueque_started_tasks_[QUEUE] "[LISTENER ID] [PID] [TASK ID]"
+HMSET blueque_task_[TASK ID] status complete result [RESULT]
+LPUSH blueque_complete_tasks_[QUEUE] [TASK ID]
+EXEC
+```
+
+### Task Failed ###
+
+If a task fails for any reason (process function raises an exception,
+or some monitoring process determines that the process fails more
+catastrophically), the process that detects the error should set the
+`status` field of the task to `failed` and the `error` field to a
+JSON-serialized description of the error (see above).
+
+```
+MULTI
+LREM blueque_reserved_tasks_[QUEUE]_[LISTENER ID] 1 [TASK ID]
+ZREM blueque_started_tasks_[QUEUE] "[LISTENER ID] [PID] [TASK ID]"
+HMSET blueque_task_[TASK ID] status failed error [ERROR]
+LPUSH blueque_failed_tasks_[QUEUE] [TASK ID]
+EXEC
+```
+
+### Delete Finished Task ###
+
+Once everybody interested in a task's result (or error) has been
+notified, the task data needs to be deleted from Redis, so that it
+does not leak data.
+
+The command to do this is slightly different, depending on whether it
+is complete or failed:
+
+```
+MULTI
+DEL blueque_task_[TASK ID]
+LREM blueque_[status]_tasks_[QUEUE] 1 [TASK ID]
+EXEC
+```
+
+### Schedule Task ###
+
+A task can be scheduled for execution at a later time by adding it to
+a sorted set, where the score is the timestamp when the task should be
+executed.
+
+```
+HMSET blueque_task_[TASK ID] status scheduled queue [QUEUE] parameters [PARAMS] eta [TIMESTAMP]
+ZINCRBY blueque_queues 0 [QUEUE]
+ZADD blueque_scheduled_tasks_[QUEUE] [TIMESTAMP] [TASK ID]
+```
+
+### Enqueue Scheduled Tasks ###
+
+A process must be running which periodically checks the scheduled task
+list for each queue and adds them to the queue to be run at the
+scheduled time.
+
+```
+WATCH blueque_scheduled_tasks_[QUEUE]
+to_run = ZRANGEBYSCORE blueque_scheduled_tasks_[QUEUE] 0 [CURRENT TIME]
+MULTI
+ZREMRANGEBYSCORE blueque_scheduled_tasks_[QUEUE] 0 [CURRENT TIME]
+LPUSH blueque_pending_tasks_[QUEUE] to_run[0] ... to_run[n]
+for task in to_run:
+    HMSET blueque_task_[TASK ID] status pending
+EXEC
+```
+
+Note that `[CURRENT TIME]` should only be read once, before executing
+the transaction, so that the same tasks which were fetched are the
+ones that are removed.
+

blueque-1.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+blueque/__init__.py,sha256=ydb7zXAy_VQ5VKlqkZIU2JedKzpPddl_FCrYrwTQkd0,48
+blueque/client.py,sha256=uSMqvryOU0UvRvb3F0GmD84zMSlRkB0K0c9YF0V0-5o,970
+blueque/forking_runner.py,sha256=Y9GlQCpcXWhtKIc6w2Nbg9T2t_guTpLCbBJDE_Wu0UI,2082
+blueque/listener.py,sha256=5xKaEyemPFSvS8wk11SAyW176k69F9mFcZ4rkK8HEAE,1427
+blueque/process_helpers.py,sha256=B7bx6bUjhNPBkki6cSBRQqWRrtE_wKxqhRgOf1wQcgw,132
+blueque/processor.py,sha256=z7FBd_pWyXe3obCbfBGNfcHI7ZfH6cWJVUYKU4OZijQ,610
+blueque/queue.py,sha256=jIV5V5RkmRWjrQgNOPHLfKaWlNoJg4syWMWJIfibsVc,654
+blueque/redis_queue.py,sha256=kTD73AqgXkdVIDQ5iHl-YajG4eDyqCIenHC9qn4_nqM,7155
+blueque/redis_task.py,sha256=1U1b7JAIQCS9V6yxcoolVh-rWv8lcvdpazj7mBlKpPo,759
+blueque/task.py,sha256=iDGK5cWQ_YQYKnnwjB0masFCfXvpbFl29tvC4Ml7OYA,976
+blueque-1.0.0.dist-info/LICENSE,sha256=8q_SGAyD_CufqtdBWZ3-IJX9JVffLkeYc7-Hr2LPER0,524
+blueque-1.0.0.dist-info/METADATA,sha256=t_eOSY8aX8xQDK3N2PVeETgr3q6d_dQ6o_d0PijNgLk,11381
+blueque-1.0.0.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
+blueque-1.0.0.dist-info/RECORD,,

blueque-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.7.0
+Root-Is-Purelib: true
+Tag: py3-none-any