dbos 0.28.0a4__tar.gz → 0.28.0a7__tar.gz

{dbos-0.28.0a4 → dbos-0.28.0a7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbos
-Version: 0.28.0a4
+Version: 0.28.0a7
 Summary: Ultra-lightweight durable execution in Python
 Author-Email: "DBOS, Inc." <contact@dbos.dev>
 License: MIT
@@ -22,7 +22,7 @@ Requires-Dist: docker>=7.1.0
 Requires-Dist: cryptography>=43.0.3
 Requires-Dist: rich>=13.9.4
 Requires-Dist: pyjwt>=2.10.1
-Requires-Dist: websockets>=15.0
+Requires-Dist: websockets>=14.0
 Description-Content-Type: text/markdown
 
 

{dbos-0.28.0a4 → dbos-0.28.0a7}/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.28.0a4 → dbos-0.28.0a7}/dbos/_client.py

@@ -70,7 +70,7 @@ class WorkflowHandleClientPolling(Generic[R]):
         return res
 
     def get_status(self) -> WorkflowStatus:
-        status = get_workflow(self._sys_db, self.workflow_id, False)
+        status = get_workflow(self._sys_db, self.workflow_id)
         if status is None:
             raise DBOSNonExistentWorkflowError(self.workflow_id)
         return status
@@ -92,9 +92,7 @@ class WorkflowHandleClientAsyncPolling(Generic[R]):
         return res
 
     async def get_status(self) -> WorkflowStatus:
-        status = await asyncio.to_thread(
-            get_workflow, self._sys_db, self.workflow_id, False
-        )
+        status = await asyncio.to_thread(get_workflow, self._sys_db, self.workflow_id)
         if status is None:
             raise DBOSNonExistentWorkflowError(self.workflow_id)
         return status
@@ -141,7 +139,6 @@ class DBOSClient:
             "authenticated_user": None,
             "assumed_role": None,
             "authenticated_roles": None,
-            "request": None,
             "output": None,
             "error": None,
             "created_at": None,
@@ -181,13 +178,13 @@ class DBOSClient:
         return WorkflowHandleClientAsyncPolling[R](workflow_id, self._sys_db)
 
     def retrieve_workflow(self, workflow_id: str) -> WorkflowHandle[R]:
-        status = get_workflow(self._sys_db, workflow_id, False)
+        status = get_workflow(self._sys_db, workflow_id)
         if status is None:
             raise DBOSNonExistentWorkflowError(workflow_id)
         return WorkflowHandleClientPolling[R](workflow_id, self._sys_db)
 
     async def retrieve_workflow_async(self, workflow_id: str) -> WorkflowHandleAsync[R]:
-        status = asyncio.to_thread(get_workflow, self._sys_db, workflow_id, False)
+        status = asyncio.to_thread(get_workflow, self._sys_db, workflow_id)
         if status is None:
             raise DBOSNonExistentWorkflowError(workflow_id)
         return WorkflowHandleClientAsyncPolling[R](workflow_id, self._sys_db)
@@ -210,7 +207,6 @@ class DBOSClient:
             "authenticated_user": None,
             "assumed_role": None,
             "authenticated_roles": None,
-            "request": None,
             "output": None,
             "error": None,
             "created_at": None,

{dbos-0.28.0a4 → dbos-0.28.0a7}/dbos/_conductor/conductor.py

@@ -2,6 +2,7 @@ import socket
 import threading
 import time
 import traceback
+from importlib.metadata import version
 from typing import TYPE_CHECKING, Optional
 
 from websockets import ConnectionClosed, ConnectionClosedOK, InvalidStatus
@@ -21,6 +22,9 @@ from . import protocol as p
 if TYPE_CHECKING:
     from dbos import DBOS
 
+ws_version = version("websockets")
+use_keepalive = ws_version < "15.0"
+
 
 class ConductorWebsocket(threading.Thread):
 
@@ -35,14 +39,64 @@ class ConductorWebsocket(threading.Thread):
         self.url = (
             conductor_url.rstrip("/") + f"/websocket/{self.app_name}/{conductor_key}"
         )
+        # TODO: once we can upgrade to websockets>=15.0, we can always use the built-in keepalive
+        self.ping_interval = 20  # Time between pings in seconds
+        self.ping_timeout = 15  # Time to wait for a pong response in seconds
+        self.keepalive_thread: Optional[threading.Thread] = None
+        self.pong_event: Optional[threading.Event] = None
+        self.last_ping_time = -1.0
+
+        self.dbos.logger.debug(
+            f"Connecting to conductor at {self.url} using websockets version {ws_version}"
+        )
+
+    def keepalive(self) -> None:
+        self.dbos.logger.debug("Starting keepalive thread")
+        while not self.evt.is_set():
+            if self.websocket is None or self.websocket.close_code is not None:
+                time.sleep(1)
+                continue
+            try:
+                self.last_ping_time = time.time()
+                self.pong_event = self.websocket.ping()
+                self.dbos.logger.debug("> Sent ping to conductor")
+                pong_result = self.pong_event.wait(self.ping_timeout)
+                elapsed_time = time.time() - self.last_ping_time
+                if not pong_result:
+                    self.dbos.logger.warning(
+                        f"Failed to receive pong from conductor after {elapsed_time:.2f} seconds. Reconnecting."
+                    )
+                    self.websocket.close()
+                    continue
+                # Wait for the next ping interval
+                self.dbos.logger.debug(
+                    f"< Received pong from conductor after {elapsed_time:.2f} seconds"
+                )
+                wait_time = self.ping_interval - elapsed_time
+                self.evt.wait(max(0, wait_time))
+            except ConnectionClosed:
+                # The main loop will try to reconnect
+                self.dbos.logger.debug("Connection to conductor closed.")
+            except Exception as e:
+                self.dbos.logger.warning(f"Failed to send ping to conductor: {e}.")
+                self.websocket.close()
 
     def run(self) -> None:
         while not self.evt.is_set():
             try:
                 with connect(
-                    self.url, open_timeout=5, logger=self.dbos.logger
+                    self.url,
+                    open_timeout=5,
+                    close_timeout=5,
+                    logger=self.dbos.logger,
                 ) as websocket:
                     self.websocket = websocket
+                    if use_keepalive and self.keepalive_thread is None:
+                        self.keepalive_thread = threading.Thread(
+                            target=self.keepalive,
+                            daemon=True,
+                        )
+                        self.keepalive_thread.start()
                     while not self.evt.is_set():
                         message = websocket.recv()
                         if not isinstance(message, str):
@@ -143,7 +197,6 @@ class ConductorWebsocket(threading.Thread):
                                     start_time=body["start_time"],
                                     end_time=body["end_time"],
                                     status=body["status"],
-                                    request=False,
                                     app_version=body["application_version"],
                                     name=body["workflow_name"],
                                     limit=body["limit"],
@@ -176,7 +229,6 @@ class ConductorWebsocket(threading.Thread):
                                     start_time=q_body["start_time"],
                                     end_time=q_body["end_time"],
                                     status=q_body["status"],
-                                    request=False,
                                     name=q_body["workflow_name"],
                                     limit=q_body["limit"],
                                     offset=q_body["offset"],
@@ -206,9 +258,7 @@ class ConductorWebsocket(threading.Thread):
                             info = None
                             try:
                                 info = get_workflow(
-                                    self.dbos._sys_db,
-                                    get_workflow_message.workflow_id,
-                                    get_request=False,
+                                    self.dbos._sys_db, get_workflow_message.workflow_id
                                 )
                             except Exception as e:
                                 error_message = f"Exception encountered when getting workflow {get_workflow_message.workflow_id}: {traceback.format_exc()}"
@@ -287,8 +337,15 @@ class ConductorWebsocket(threading.Thread):
                             # Still need to send a response to the conductor
                             websocket.send(unknown_message.to_json())
             except ConnectionClosedOK:
-                self.dbos.logger.info("Conductor connection terminated")
-                break
+                if self.evt.is_set():
+                    self.dbos.logger.info("Conductor connection terminated")
+                    break
+                # Otherwise, we are trying to reconnect
+                self.dbos.logger.warning(
+                    "Connection to conductor lost. Reconnecting..."
+                )
+                time.sleep(1)
+                continue
             except ConnectionClosed as e:
                 self.dbos.logger.warning(
                     f"Connection to conductor lost. Reconnecting: {e}"
@@ -309,3 +366,9 @@ class ConductorWebsocket(threading.Thread):
                 )
                 time.sleep(1)
                 continue
+
+        # Wait for the keepalive thread to finish
+        if self.keepalive_thread is not None:
+            if self.pong_event is not None:
+                self.pong_event.set()
+            self.keepalive_thread.join()

{dbos-0.28.0a4 → dbos-0.28.0a7}/dbos/_conductor/protocol.py

@@ -149,7 +149,7 @@ class WorkflowsOutput:
         inputs_str = str(info.input) if info.input is not None else None
         outputs_str = str(info.output) if info.output is not None else None
         error_str = str(info.error) if info.error is not None else None
-        request_str = str(info.request) if info.request is not None else None
+        request_str = None
         roles_str = (
             str(info.authenticated_roles)
             if info.authenticated_roles is not None

{dbos-0.28.0a4 → dbos-0.28.0a7}/dbos/_context.py

@@ -16,7 +16,6 @@ from sqlalchemy.orm import Session
 from dbos._utils import GlobalParams
 
 from ._logger import dbos_logger
-from ._request import Request
 from ._tracer import dbos_tracer
 
 
@@ -76,8 +75,6 @@ class DBOSContext:
 
         self.logger = dbos_logger
 
-        self.request: Optional["Request"] = None
-
         self.id_assigned_for_next_workflow: str = ""
         self.is_within_set_workflow_id_block: bool = False
 
@@ -120,7 +117,6 @@ class DBOSContext:
             if self.authenticated_roles is not None
             else None
         )
-        rv.request = self.request
         rv.assumed_role = self.assumed_role
         return rv
 

{dbos-0.28.0a4 → dbos-0.28.0a7}/dbos/_core.py

@@ -266,9 +266,6 @@ def _init_workflow(
         "app_id": ctx.app_id,
         "app_version": GlobalParams.app_version,
         "executor_id": ctx.executor_id,
-        "request": (
-            _serialization.serialize(ctx.request) if ctx.request is not None else None
-        ),
         "recovery_attempts": None,
         "authenticated_user": ctx.authenticated_user,
         "authenticated_roles": (
@@ -296,7 +293,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:
@@ -443,10 +440,6 @@ def execute_workflow_by_id(dbos: "DBOS", workflow_id: str) -> "WorkflowHandle[An
         )
     with DBOSContextEnsure():
         ctx = assert_current_dbos_context()
-        request = status["request"]
-        ctx.request = (
-            _serialization.deserialize(request) if request is not None else None
-        )
         # If this function belongs to a configured class, add that class instance as its first argument
         if status["config_name"] is not None:
             config_name = status["config_name"]

{dbos-0.28.0a4 → dbos-0.28.0a7}/dbos/_dbos.py

@@ -71,14 +71,11 @@ from ._tracer import DBOSTracer, dbos_tracer
 if TYPE_CHECKING:
     from fastapi import FastAPI
     from ._kafka import _KafkaConsumerWorkflow
-    from ._request import Request
     from flask import Flask
 
 from sqlalchemy import URL
 from sqlalchemy.orm import Session
 
-from ._request import Request
-
 if sys.version_info < (3, 10):
     from typing_extensions import ParamSpec
 else:
@@ -197,7 +194,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))
@@ -247,7 +244,7 @@ class DBOS:
     2. Starting workflow functions
     3. Retrieving workflow status information
     4. Interacting with workflows via events and messages
-    5. Accessing context, including the current user, request, SQL session, logger, and tracer
+    5. Accessing context, including the current user, SQL session, logger, and tracer
 
     """
 
@@ -330,7 +327,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 +502,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 +515,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 +527,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 +583,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:
@@ -760,7 +762,7 @@ class DBOS:
         """Return the status of a workflow execution."""
 
         def fn() -> Optional[WorkflowStatus]:
-            return get_workflow(_get_dbos_instance()._sys_db, workflow_id, True)
+            return get_workflow(_get_dbos_instance()._sys_db, workflow_id)
 
         return _get_dbos_instance()._sys_db.call_function_as_step(fn, "DBOS.getStatus")
 
@@ -1156,12 +1158,6 @@ class DBOS:
         assert span
         return span
 
-    @classproperty
-    def request(cls) -> Optional["Request"]:
-        """Return the HTTP `Request`, if any, associated with the current context."""
-        ctx = assert_current_dbos_context()
-        return ctx.request
-
     @classproperty
     def authenticated_user(cls) -> Optional[str]:
         """Return the current authenticated user, if any, associated with the current context."""

{dbos-0.28.0a4 → dbos-0.28.0a7}/dbos/_fastapi.py

@@ -7,15 +7,9 @@ from fastapi.responses import JSONResponse
 from starlette.types import ASGIApp, Receive, Scope, Send
 
 from . import DBOS
-from ._context import (
-    EnterDBOSHandler,
-    OperationType,
-    SetWorkflowID,
-    TracedAttributes,
-    assert_current_dbos_context,
-)
+from ._context import EnterDBOSHandler, OperationType, SetWorkflowID, TracedAttributes
 from ._error import DBOSException
-from ._request import Address, Request, request_id_header
+from ._utils import request_id_header
 
 
 def _get_or_generate_request_id(request: FastAPIRequest) -> str:
@@ -26,19 +20,6 @@ def _get_or_generate_request_id(request: FastAPIRequest) -> str:
         return str(uuid.uuid4())
 
 
-def _make_request(request: FastAPIRequest) -> Request:
-    return Request(
-        headers=request.headers,
-        path_params=request.path_params,
-        query_params=request.query_params,
-        url=str(request.url),
-        base_url=str(request.base_url),
-        client=Address(*request.client) if request.client is not None else None,
-        cookies=request.cookies,
-        method=request.method,
-    )
-
-
 async def _dbos_error_handler(request: FastAPIRequest, gexc: Exception) -> JSONResponse:
     exc: DBOSException = cast(DBOSException, gexc)
     status_code = 500
@@ -96,8 +77,6 @@ def setup_fastapi_middleware(app: FastAPI, dbos: DBOS) -> None:
             "operationType": OperationType.HANDLER.value,
         }
         with EnterDBOSHandler(attributes):
-            ctx = assert_current_dbos_context()
-            ctx.request = _make_request(request)
             workflow_id = request.headers.get("dbos-idempotency-key")
             if workflow_id is not None:
                 # Set the workflow ID for the handler

{dbos-0.28.0a4 → dbos-0.28.0a7}/dbos/_flask.py

@@ -2,17 +2,11 @@ import uuid
 from typing import Any
 from urllib.parse import urlparse
 
-from flask import Flask, request
+from flask import Flask
 from werkzeug.wrappers import Request as WRequest
 
-from ._context import (
-    EnterDBOSHandler,
-    OperationType,
-    SetWorkflowID,
-    TracedAttributes,
-    assert_current_dbos_context,
-)
-from ._request import Address, Request, request_id_header
+from ._context import EnterDBOSHandler, OperationType, SetWorkflowID, TracedAttributes
+from ._utils import request_id_header
 
 
 class FlaskMiddleware:
@@ -32,8 +26,6 @@ class FlaskMiddleware:
             "operationType": OperationType.HANDLER.value,
         }
         with EnterDBOSHandler(attributes):
-            ctx = assert_current_dbos_context()
-            ctx.request = _make_request(request)
             workflow_id = request.headers.get("dbos-idempotency-key")
             if workflow_id is not None:
                 # Set the workflow ID for the handler
@@ -52,31 +44,5 @@ def _get_or_generate_request_id(request: WRequest) -> str:
         return str(uuid.uuid4())
 
 
-def _make_request(request: WRequest) -> Request:
-    parsed_url = urlparse(request.url)
-    base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
-
-    client = None
-    if request.remote_addr:
-        hostname = request.remote_addr
-        port = request.environ.get("REMOTE_PORT")
-        if port:
-            client = Address(hostname=hostname, port=int(port))
-        else:
-            # If port is not available, use 0 as a placeholder
-            client = Address(hostname=hostname, port=0)
-
-    return Request(
-        headers=dict(request.headers),
-        path_params={},
-        query_params=dict(request.args),
-        url=request.url,
-        base_url=base_url,
-        client=client,
-        cookies=dict(request.cookies),
-        method=request.method,
-    )
-
-
 def setup_flask_middleware(app: Flask) -> None:
     app.wsgi_app = FlaskMiddleware(app.wsgi_app)  # type: ignore

{dbos-0.28.0a4 → dbos-0.28.0a7}/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.28.0a4 → dbos-0.28.0a7}/dbos/_schemas/system_database.py

@@ -29,7 +29,6 @@ class SystemSchema:
         Column("authenticated_user", Text, nullable=True),
         Column("assumed_role", Text, nullable=True),
         Column("authenticated_roles", Text, nullable=True),
-        Column("request", Text, nullable=True),
         Column("output", Text, nullable=True),
         Column("error", Text, nullable=True),
         Column("executor_id", Text, nullable=True),