dbos 0.27.0a11__tar.gz → 0.27.2__tar.gz

{dbos-0.27.0a11 → dbos-0.27.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbos
-Version: 0.27.0a11
+Version: 0.27.2
 Summary: Ultra-lightweight durable execution in Python
 Author-Email: "DBOS, Inc." <contact@dbos.dev>
 License: MIT

{dbos-0.27.0a11 → dbos-0.27.2}/dbos/_admin_server.py

@@ -66,11 +66,11 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
         elif self.path == _deactivate_path:
             if not AdminRequestHandler.is_deactivated:
                 dbos_logger.info(
-                    f"Deactivating DBOS executor {GlobalParams.executor_id} with version {GlobalParams.app_version}. This executor will complete existing workflows but will not start new workflows."
+                    f"Deactivating DBOS executor {GlobalParams.executor_id} with version {GlobalParams.app_version}. This executor will complete existing workflows but will not create new workflows."
                 )
                 AdminRequestHandler.is_deactivated = True
-            # Stop all scheduled workflows, queues, and kafka loops
-            for event in self.dbos.stop_events:
+            # Stop all event receivers (scheduler and Kafka threads)
+            for event in self.dbos.poller_stop_events:
                 event.set()
             self.send_response(200)
             self._end_headers()

{dbos-0.27.0a11 → dbos-0.27.2}/dbos/_core.py

@@ -296,7 +296,7 @@ def _init_workflow(
 
     if workflow_deadline_epoch_ms is not None:
         evt = threading.Event()
-        dbos.stop_events.append(evt)
+        dbos.background_thread_stop_events.append(evt)
 
         def timeout_func() -> None:
             try:

{dbos-0.27.0a11 → dbos-0.27.2}/dbos/_dbos.py

@@ -197,7 +197,7 @@ class DBOSRegistry:
         self, evt: threading.Event, func: Callable[..., Any], *args: Any, **kwargs: Any
     ) -> None:
         if self.dbos and self.dbos._launched:
-            self.dbos.stop_events.append(evt)
+            self.dbos.poller_stop_events.append(evt)
             self.dbos._executor.submit(func, *args, **kwargs)
         else:
             self.pollers.append((evt, func, args, kwargs))
@@ -330,7 +330,10 @@ class DBOS:
         self._registry: DBOSRegistry = _get_or_create_dbos_registry()
         self._registry.dbos = self
         self._admin_server_field: Optional[AdminServer] = None
-        self.stop_events: List[threading.Event] = []
+        # Stop internal background threads (queue thread, timeout threads, etc.)
+        self.background_thread_stop_events: List[threading.Event] = []
+        # Stop pollers (event receivers) that can create new workflows (scheduler, Kafka)
+        self.poller_stop_events: List[threading.Event] = []
         self.fastapi: Optional["FastAPI"] = fastapi
         self.flask: Optional["Flask"] = flask
         self._executor_field: Optional[ThreadPoolExecutor] = None
@@ -502,7 +505,7 @@ class DBOS:
 
             # Start the queue thread
             evt = threading.Event()
-            self.stop_events.append(evt)
+            self.background_thread_stop_events.append(evt)
             bg_queue_thread = threading.Thread(
                 target=queue_thread, args=(evt, self), daemon=True
             )
@@ -515,7 +518,7 @@ class DBOS:
                     dbos_domain = os.environ.get("DBOS_DOMAIN", "cloud.dbos.dev")
                     self.conductor_url = f"wss://{dbos_domain}/conductor/v1alpha1"
                 evt = threading.Event()
-                self.stop_events.append(evt)
+                self.background_thread_stop_events.append(evt)
                 self.conductor_websocket = ConductorWebsocket(
                     self,
                     conductor_url=self.conductor_url,
@@ -527,7 +530,7 @@ class DBOS:
 
             # Grab any pollers that were deferred and start them
             for evt, func, args, kwargs in self._registry.pollers:
-                self.stop_events.append(evt)
+                self.poller_stop_events.append(evt)
                 poller_thread = threading.Thread(
                     target=func, args=args, kwargs=kwargs, daemon=True
                 )
@@ -583,7 +586,9 @@ class DBOS:
 
     def _destroy(self) -> None:
         self._initialized = False
-        for event in self.stop_events:
+        for event in self.poller_stop_events:
+            event.set()
+        for event in self.background_thread_stop_events:
             event.set()
         self._background_event_loop.stop()
         if self._sys_db_field is not None:

{dbos-0.27.0a11 → dbos-0.27.2}/dbos/_recovery.py

@@ -29,7 +29,7 @@ def startup_recovery_thread(
 ) -> None:
     """Attempt to recover local pending workflows on startup using a background thread."""
     stop_event = threading.Event()
-    dbos.stop_events.append(stop_event)
+    dbos.background_thread_stop_events.append(stop_event)
     while not stop_event.is_set() and len(pending_workflows) > 0:
         try:
             for pending_workflow in list(pending_workflows):

{dbos-0.27.0a11 → dbos-0.27.2}/dbos/_sys_db.py

@@ -1739,15 +1739,30 @@ class SystemDatabase:
                 available_tasks = max(0, queue.concurrency - total_running_tasks)
                 max_tasks = min(max_tasks, available_tasks)
 
-            # Lookup unstarted/uncompleted tasks (not running)
+            # Retrieve the first max_tasks workflows in the queue.
+            # Only retrieve workflows of the appropriate version (or without version set)
             query = (
                 sa.select(
                     SystemSchema.workflow_queue.c.workflow_uuid,
                 )
+                .select_from(
+                    SystemSchema.workflow_queue.join(
+                        SystemSchema.workflow_status,
+                        SystemSchema.workflow_queue.c.workflow_uuid
+                        == SystemSchema.workflow_status.c.workflow_uuid,
+                    )
+                )
                 .where(SystemSchema.workflow_queue.c.queue_name == queue.name)
                 .where(SystemSchema.workflow_queue.c.started_at_epoch_ms == None)
                 .where(SystemSchema.workflow_queue.c.completed_at_epoch_ms == None)
                 .order_by(SystemSchema.workflow_queue.c.created_at_epoch_ms.asc())
+                .where(
+                    sa.or_(
+                        SystemSchema.workflow_status.c.application_version
+                        == app_version,
+                        SystemSchema.workflow_status.c.application_version.is_(None),
+                    )
+                )
                 .with_for_update(nowait=True)  # Error out early
             )
             # Apply limit only if max_tasks is finite
@@ -1779,15 +1794,6 @@ class SystemDatabase:
                         SystemSchema.workflow_status.c.status
                         == WorkflowStatusString.ENQUEUED.value
                     )
-                    .where(
-                        sa.or_(
-                            SystemSchema.workflow_status.c.application_version
-                            == app_version,
-                            SystemSchema.workflow_status.c.application_version.is_(
-                                None
-                            ),
-                        )
-                    )
                     .values(
                         status=WorkflowStatusString.PENDING.value,
                         application_version=app_version,

{dbos-0.27.0a11 → dbos-0.27.2}/pyproject.toml

@@ -28,7 +28,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "0.27.0a11"
+version = "0.27.2"
 
 [project.license]
 text = "MIT"

{dbos-0.27.0a11 → dbos-0.27.2}/tests/test_admin_server.py

@@ -3,6 +3,7 @@ import socket
 import threading
 import time
 import uuid
+from datetime import datetime
 
 import pytest
 import requests
@@ -65,8 +66,59 @@ def test_admin_endpoints(dbos: DBOS) -> None:
     response = requests.get("http://localhost:3001/deactivate", timeout=5)
     assert response.status_code == 200
 
-    for event in dbos.stop_events:
-        assert event.is_set(), "Event is not set!"
+    for event in dbos.poller_stop_events:
+        assert event.is_set()
+
+
+def test_deactivate(dbos: DBOS, config: ConfigFile) -> None:
+    wf_counter: int = 0
+
+    queue = Queue("example-queue")
+
+    @DBOS.scheduled("* * * * * *")
+    @DBOS.workflow()
+    def test_workflow(scheduled: datetime, actual: datetime) -> None:
+        nonlocal wf_counter
+        wf_counter += 1
+
+    @DBOS.workflow()
+    def regular_workflow() -> int:
+        return 5
+
+    # Let the scheduled workflow run
+    time.sleep(2)
+    val = wf_counter
+    assert val > 0
+    # Deactivate--scheduled workflow should stop
+    response = requests.get("http://localhost:3001/deactivate", timeout=5)
+    assert response.status_code == 200
+    for event in dbos.poller_stop_events:
+        assert event.is_set()
+    # Verify the scheduled workflow does not run anymore
+    time.sleep(3)
+    assert wf_counter <= val + 1
+    # Enqueue a workflow, verify it still runs
+    assert queue.enqueue(regular_workflow).get_result() == 5
+
+    # Test deferred event receivers
+    DBOS.destroy(destroy_registry=True)
+    dbos = DBOS(config=config)
+
+    @DBOS.scheduled("* * * * * *")
+    @DBOS.workflow()
+    def deferred_workflow(scheduled: datetime, actual: datetime) -> None:
+        nonlocal wf_counter
+        wf_counter += 1
+
+    DBOS.launch()
+    assert len(dbos.poller_stop_events) > 0
+    for event in dbos.poller_stop_events:
+        assert not event.is_set()
+    # Deactivate--scheduled workflow should stop
+    response = requests.get("http://localhost:3001/deactivate", timeout=5)
+    assert response.status_code == 200
+    for event in dbos.poller_stop_events:
+        assert event.is_set()
 
 
 def test_admin_recovery(config: ConfigFile) -> None:

{dbos-0.27.0a11 → dbos-0.27.2}/tests/test_queue.py

@@ -14,6 +14,7 @@ import sqlalchemy as sa
 from dbos import (
     DBOS,
     ConfigFile,
+    DBOSClient,
     DBOSConfiguredInstance,
     Queue,
     SetEnqueueOptions,
@@ -1210,3 +1211,29 @@ async def test_queue_deduplication_async(dbos: DBOS) -> None:
         with SetWorkflowID(wfid2):
             handle2 = await queue.enqueue_async(test_workflow, "def")
     assert (await handle2.get_result()) == "def-c-p"
+
+def test_worker_concurrency_across_versions(dbos: DBOS, client: DBOSClient) -> None:
+    queue = Queue("test_worker_concurrency_across_versions", worker_concurrency=1)
+
+    @DBOS.workflow()
+    def test_workflow() -> str:
+        return DBOS.workflow_id
+
+    # First enqueue a workflow on the other version, then on the current version
+    other_version = "other_version"
+    other_version_handle: WorkflowHandle[None] = client.enqueue(
+        {
+            "queue_name": "test_worker_concurrency_across_versions",
+            "workflow_name": test_workflow.__qualname__,
+            "app_version": other_version,
+        }
+    )
+    handle = queue.enqueue(test_workflow)
+
+    # Verify the workflow on the current version completes, but the other version is still ENQUEUED
+    assert handle.get_result()
+    assert other_version_handle.get_status().status == "ENQUEUED"
+
+    # Change the version, verify the other version complets
+    GlobalParams.app_version = other_version
+    assert other_version_handle.get_result()

{dbos-0.27.0a11 → dbos-0.27.2}/tests/test_scheduler.py

@@ -202,7 +202,8 @@ def test_scheduler_oaoo(dbos: DBOS) -> None:
                 time.sleep(1)
 
     # Stop the scheduled workflow
-    dbos.stop_events[0].set()
+    for evt in dbos.poller_stop_events:
+        evt.set()
 
     dbos._sys_db.update_workflow_status(
         {