dbos 0.23.0a11__tar.gz → 0.23.0a13__tar.gz

{dbos-0.23.0a11 → dbos-0.23.0a13}/PKG-INFO

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

{dbos-0.23.0a11 → dbos-0.23.0a13}/dbos/_conductor/conductor.py

@@ -8,7 +8,7 @@ from websockets.sync.client import connect
 from websockets.sync.connection import Connection
 
 from dbos._utils import GlobalParams
-from dbos._workflow_commands import list_queued_workflows, list_workflows
+from dbos._workflow_commands import get_workflow, list_queued_workflows, list_workflows
 
 from . import protocol as p
 
@@ -175,6 +175,25 @@ class ConductorWebsocket(threading.Thread):
                                 )
                             )
                             websocket.send(list_queued_workflows_response.to_json())
+                        elif type == p.MessageType.GET_WORKFLOW:
+                            get_workflow_message = p.GetWorkflowRequest.from_json(
+                                message
+                            )
+                            info = get_workflow(
+                                self.dbos._sys_db,
+                                get_workflow_message.workflow_id,
+                                getRequest=False,
+                            )
+                            get_workflow_response = p.GetWorkflowResponse(
+                                type=p.MessageType.GET_WORKFLOW,
+                                request_id=base_message.request_id,
+                                output=(
+                                    p.WorkflowsOutput.from_workflow_information(info)
+                                    if info is not None
+                                    else None
+                                ),
+                            )
+                            websocket.send(get_workflow_response.to_json())
                         else:
                             self.dbos.logger.warning(f"Unexpected message type: {type}")
             except ConnectionClosedOK:

{dbos-0.23.0a11 → dbos-0.23.0a13}/dbos/_conductor/protocol.py

@@ -14,6 +14,7 @@ class MessageType(str, Enum):
     LIST_QUEUED_WORKFLOWS = "list_queued_workflows"
     RESUME = "resume"
     RESTART = "restart"
+    GET_WORKFLOW = "get_workflow"
 
 
 T = TypeVar("T", bound="BaseMessage")
@@ -184,3 +185,13 @@ class ListQueuedWorkflowsRequest(BaseMessage):
 @dataclass
 class ListQueuedWorkflowsResponse(BaseMessage):
     output: List[WorkflowsOutput]
+
+
+@dataclass
+class GetWorkflowRequest(BaseMessage):
+    workflow_id: str
+
+
+@dataclass
+class GetWorkflowResponse(BaseMessage):
+    output: Optional[WorkflowsOutput]

{dbos-0.23.0a11 → dbos-0.23.0a13}/dbos/_recovery.py

@@ -14,6 +14,16 @@ if TYPE_CHECKING:
     from ._dbos import DBOS, WorkflowHandle
 
 
+def _recover_workflow(
+    dbos: "DBOS", workflow: GetPendingWorkflowsOutput
+) -> "WorkflowHandle[Any]":
+    if workflow.queue_name and workflow.queue_name != "_dbos_internal_queue":
+        cleared = dbos._sys_db.clear_queue_assignment(workflow.workflow_uuid)
+        if cleared:
+            return dbos.retrieve_workflow(workflow.workflow_uuid)
+    return execute_workflow_by_id(dbos, workflow.workflow_uuid)
+
+
 def startup_recovery_thread(
     dbos: "DBOS", pending_workflows: List[GetPendingWorkflowsOutput]
 ) -> None:
@@ -23,14 +33,7 @@ def startup_recovery_thread(
     while not stop_event.is_set() and len(pending_workflows) > 0:
         try:
             for pending_workflow in list(pending_workflows):
-                if (
-                    pending_workflow.queue_name
-                    and pending_workflow.queue_name != "_dbos_internal_queue"
-                ):
-                    cleared = dbos._sys_db.clear_queue_assignment(pending_workflow.workflow_uuid)
-                    if cleared:
-                        continue
-                execute_workflow_by_id(dbos, pending_workflow.workflow_uuid)
+                _recover_workflow(dbos, pending_workflow)
                 pending_workflows.remove(pending_workflow)
         except DBOSWorkflowFunctionNotFoundError:
             time.sleep(1)
@@ -51,26 +54,14 @@ def recover_pending_workflows(
             executor_id, GlobalParams.app_version
         )
         for pending_workflow in pending_workflows:
-            if (
-                pending_workflow.queue_name
-                and pending_workflow.queue_name != "_dbos_internal_queue"
-            ):
-                try:
-                    cleared = dbos._sys_db.clear_queue_assignment(pending_workflow.workflow_uuid)
-                    if cleared:
-                        workflow_handles.append(
-                            dbos.retrieve_workflow(pending_workflow.workflow_uuid)
-                        )
-                    else:
-                        workflow_handles.append(
-                            execute_workflow_by_id(dbos, pending_workflow.workflow_uuid)
-                        )
-                except Exception as e:
-                    dbos.logger.error(e)
-            else:
-                workflow_handles.append(
-                    execute_workflow_by_id(dbos, pending_workflow.workflow_uuid)
+            try:
+                handle = _recover_workflow(dbos, pending_workflow)
+                workflow_handles.append(handle)
+            except Exception as e:
+                dbos.logger.error(
+                    f"Exception encountered when recovering workflows: {traceback.format_exc()}"
                 )
+                raise e
         dbos.logger.info(
             f"Recovering {len(pending_workflows)} workflows for executor {executor_id} from version {GlobalParams.app_version}"
         )

{dbos-0.23.0a11 → dbos-0.23.0a13}/dbos/_sys_db.py

@@ -1462,7 +1462,6 @@ class SystemDatabase:
                     .values(completed_at_epoch_ms=int(time.time() * 1000))
                 )
 
-
     def clear_queue_assignment(self, workflow_id: str) -> bool:
         if self._debug_mode:
             raise Exception("called clear_queue_assignment in debug mode")
@@ -1483,7 +1482,9 @@ class SystemDatabase:
                 res = conn.execute(
                     sa.update(SystemSchema.workflow_status)
                     .where(SystemSchema.workflow_status.c.workflow_uuid == workflow_id)
-                    .values(executor_id=None, status=WorkflowStatusString.ENQUEUED.value)
+                    .values(
+                        executor_id=None, status=WorkflowStatusString.ENQUEUED.value
+                    )
                 )
                 if res.rowcount == 0:
                     # This should never happen
@@ -1492,6 +1493,7 @@ class SystemDatabase:
                     )
                 return True
 
+
 def reset_system_database(config: ConfigFile) -> None:
     sysdb_name = (
         config["database"]["sys_db_name"]

{dbos-0.23.0a11 → dbos-0.23.0a13}/pyproject.toml

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

{dbos-0.23.0a11 → dbos-0.23.0a13}/tests/test_queue.py

@@ -902,10 +902,11 @@ def test_resuming_queued_workflows(dbos: DBOS) -> None:
 
 # Test a race condition between removing a task from the queue and flushing the status buffer
 def test_resuming_already_completed_queue_workflow(dbos: DBOS) -> None:
-    dbos._sys_db._run_background_processes = False # Disable buffer flush
+    dbos._sys_db._run_background_processes = False  # Disable buffer flush
 
     start_event = threading.Event()
     counter = 0
+
     @DBOS.workflow()
     def test_step() -> None:
         start_event.set()
@@ -917,19 +918,27 @@ def test_resuming_already_completed_queue_workflow(dbos: DBOS) -> None:
     start_event.wait()
     start_event.clear()
     time.sleep(_buffer_flush_interval_secs)
-    assert handle.get_status().status == WorkflowStatusString.PENDING.value # Not flushed
-    assert counter == 1 # But, really, it's completed
-    dbos._sys_db._workflow_status_buffer = {} # Clear buffer (simulates a process restart)
+    assert (
+        handle.get_status().status == WorkflowStatusString.PENDING.value
+    )  # Not flushed
+    assert counter == 1  # But, really, it's completed
+    dbos._sys_db._workflow_status_buffer = (
+        {}
+    )  # Clear buffer (simulates a process restart)
 
     # Recovery picks up on the workflow and recovers it
     recovered_ids = DBOS.recover_pending_workflows()
     assert len(recovered_ids) == 1
     assert recovered_ids[0].get_workflow_id() == handle.get_workflow_id()
     start_event.wait()
-    assert counter == 2 # The workflow ran again
-    time.sleep(_buffer_flush_interval_secs) # This is actually to wait that _get_wf_invoke_func buffers the status
-    dbos._sys_db._flush_workflow_status_buffer() # Manually flush
-    assert handle.get_status().status == WorkflowStatusString.SUCCESS.value # Is recovered
+    assert counter == 2  # The workflow ran again
+    time.sleep(
+        _buffer_flush_interval_secs
+    )  # This is actually to wait that _get_wf_invoke_func buffers the status
+    dbos._sys_db._flush_workflow_status_buffer()  # Manually flush
+    assert (
+        handle.get_status().status == WorkflowStatusString.SUCCESS.value
+    )  # Is recovered
     assert handle.get_status().executor_id == "local"
     assert handle.get_status().recovery_attempts == 2