tasktiger 0.26.0__tar.gz → 0.26.2__tar.gz

{tasktiger-0.26.0/tasktiger.egg-info → tasktiger-0.26.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktiger
-Version: 0.26.0
+Version: 0.26.2
 Summary: Python task queue
 Home-page: http://github.com/closeio/tasktiger
 License: MIT

{tasktiger-0.26.0 → tasktiger-0.26.2}/tasktiger/__init__.py

@@ -12,7 +12,7 @@ from .task import Task
 from .tasktiger import TaskTiger, run_worker
 from .worker import Worker
 
-__version__ = "0.26.0"
+__version__ = "0.26.2"
 __all__ = [
     "TaskTiger",
     "Worker",

{tasktiger-0.26.0 → tasktiger-0.26.2}/tasktiger/task.py

@@ -513,15 +513,19 @@ class Task:
             tiger: TaskTiger instance.
             queue: Name of the queue.
             state: State of the task (QUEUED, ACTIVE, SCHEDULED, ERROR).
+            skip: Number of latest tasks to pass over.
             limit: Maximum number of tasks to return.
             load_executions: Maximum number of executions to load for each task
                 (starting from the latest).
-            include_not_found: Whether to include tasks that cannot be loaded.
+            include_not_found: Whether to include tasks that have no payload.
 
         Returns:
             Tuple with the following information:
-            * total items in the queue
-            * tasks from the given queue in the given state, latest first.
+            * total items in the queue, including tasks without a payload
+            * the latest `limit` tasks after the latest `skip` tasks, in
+              ascending order of score. If tasks without a payload are left
+              out, this list can be shorter than `limit` before the end of the
+              queue.
         """
 
         key = tiger._key(state, queue)
@@ -549,8 +553,9 @@ class Task:
                     range(len(items)), results[0], results[1:], tss
                 ):
                     if serialized_data is None:
-                        if include_not_found:
-                            data = {"id": items[idx][0]}
+                        if not include_not_found:
+                            continue
+                        data = {"id": items[idx][0]}
                     else:
                         data = json.loads(serialized_data)
 
@@ -572,8 +577,9 @@ class Task:
                 )
                 for idx, serialized_data, ts in zip(range(len(items)), result, tss):
                     if serialized_data is None:
-                        if include_not_found:
-                            data = {"id": items[idx][0]}
+                        if not include_not_found:
+                            continue
+                        data = {"id": items[idx][0]}
                     else:
                         data = json.loads(serialized_data)
 

{tasktiger-0.26.0 → tasktiger-0.26.2}/tasktiger/worker.py

@@ -4,7 +4,6 @@ import json
 import os
 import random
 import signal
-import sys
 import time
 import uuid
 from collections import OrderedDict
@@ -832,10 +831,13 @@ class Worker:
                     runner = runner_class(self.tiger)
                     runner.on_permanent_error(task, execution)
 
-            # Exit the process with an error code if a task timed out to
-            # prevent any inconsistent state in case the runner requires it.
+            # Force the process to exit after a task times out. A normal interpreter
+            # shutdown can wait indefinitely for threads started by the task.
             if self.executor.exit_worker_on_job_timeout and has_job_timeout:
-                sys.exit("exiting worker due to job timeout error")
+                try:
+                    os.write(2, b"exiting worker due to job timeout error\n")
+                finally:
+                    os._exit(1)
 
     def _worker_run(self) -> None:
         """

{tasktiger-0.26.0 → tasktiger-0.26.2/tasktiger.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasktiger
-Version: 0.26.0
+Version: 0.26.2
 Summary: Python task queue
 Home-page: http://github.com/closeio/tasktiger
 License: MIT

{tasktiger-0.26.0 → tasktiger-0.26.2}/tests/tasks.py

@@ -1,4 +1,5 @@
 import json
+import threading
 import time
 from math import ceil
 
@@ -54,6 +55,15 @@ def long_task_killed():
     time.sleep(DELAY * 2)
 
 
+@tiger.task(hard_timeout=DELAY)
+def long_task_with_blocked_thread():
+    blocker = threading.Event()
+    # A non-daemon thread makes normal interpreter shutdown wait indefinitely.
+    thread = threading.Thread(target=blocker.wait, daemon=False)
+    thread.start()
+    time.sleep(DELAY * 2)
+
+
 @tiger.task(hard_timeout=DELAY * 2)
 def long_task_ok():
     # Signal task has started

{tasktiger-0.26.0 → tasktiger-0.26.2}/tests/test_base.py

@@ -1072,6 +1072,35 @@ class TestTasks(BaseTestCase):
         assert n == 1
         assert len(tasks[0].executions) == 2
 
+    @pytest.mark.parametrize("load_executions", [0, 1])
+    @pytest.mark.parametrize("missing_index", [0, 1, 2])
+    def test_tasks_from_queue_task_not_found(self, load_executions, missing_index):
+        tasks = [Task(self.tiger, simple_task) for _ in range(3)]
+        # Distinct scheduled times give a fixed order in the zset.
+        for minutes, task in enumerate(tasks, start=1):
+            task.delay(when=datetime.timedelta(minutes=minutes))
+        missing_task = tasks[missing_index]
+        self.conn.delete(self.tiger._key("task", missing_task.id))
+
+        n, found = Task.tasks_from_queue(
+            self.tiger, "default", "scheduled", load_executions=load_executions
+        )
+        assert n == 3
+        assert [task.id for task in found] == [
+            task.id for task in tasks if task is not missing_task
+        ]
+
+        n, found = Task.tasks_from_queue(
+            self.tiger,
+            "default",
+            "scheduled",
+            load_executions=load_executions,
+            include_not_found=True,
+        )
+        assert n == 3
+        assert [task.id for task in found] == [task.id for task in tasks]
+        assert found[missing_index].data == {"id": missing_task.id}
+
     def test_eager(self):
         self.tiger.config["ALWAYS_EAGER"] = True
 

{tasktiger-0.26.0 → tasktiger-0.26.2}/tests/test_workers.py

@@ -4,7 +4,6 @@ import datetime
 import time
 from multiprocessing import Process
 
-import pytest
 from freezefrog import FreezeTime
 
 from tasktiger import Task, Worker
@@ -15,8 +14,8 @@ from tasktiger.worker import LOCK_REDIS_KEY
 from .config import DELAY
 from .tasks import (
     exception_task,
-    long_task_killed,
     long_task_ok,
+    long_task_with_blocked_thread,
     simple_task,
     sleep_task,
     system_exit_task,
@@ -182,11 +181,19 @@ class TestSyncExecutorWorker:
         ensure_queues(error={"default": 1})
 
     def test_handles_timeout(self, tiger, ensure_queues):
-        Task(tiger, long_task_killed).delay()
-        worker = Worker(tiger, executor_class=SyncExecutor)
-        # Worker should exit to avoid any inconsistencies.
-        with pytest.raises(SystemExit):
-            worker.run(once=True, force_once=True)
+        Task(tiger, long_task_with_blocked_thread).delay()
+        worker = Process(
+            target=external_worker,
+            kwargs={"worker_kwargs": {"executor_class": SyncExecutor}},
+        )
+        worker.start()
+        worker.join(timeout=DELAY * 5)
+        try:
+            assert worker.exitcode == 1
+        finally:
+            if worker.is_alive():
+                worker.kill()
+                worker.join()
         ensure_queues(error={"default": 1})
 
     def test_heartbeat(self, tiger):