dbos 0.14.0a2__tar.gz → 0.14.0a6__tar.gz

{dbos-0.14.0a2 → dbos-0.14.0a6}/PKG-INFO

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

{dbos-0.14.0a2 → dbos-0.14.0a6}/dbos/_dbos.py

@@ -238,13 +238,14 @@ class DBOS:
         return _dbos_global_instance
 
     @classmethod
-    def destroy(cls) -> None:
+    def destroy(cls, *, destroy_registry: bool = True) -> None:
         global _dbos_global_instance
-        global _dbos_global_registry
         if _dbos_global_instance is not None:
             _dbos_global_instance._destroy()
         _dbos_global_instance = None
-        _dbos_global_registry = None
+        if destroy_registry:
+            global _dbos_global_registry
+            _dbos_global_registry = None
 
     def __init__(
         self,
@@ -619,16 +620,24 @@ class DBOS:
         It is important to use `DBOS.sleep` (as opposed to any other sleep) within workflows,
         as the `DBOS.sleep`s are durable and completed sleeps will be skipped during recovery.
         """
-
-        attributes: TracedAttributes = {
-            "name": "sleep",
-        }
         if seconds <= 0:
             return
-        with EnterDBOSStep(attributes) as ctx:
-            _get_dbos_instance()._sys_db.sleep(
-                ctx.workflow_id, ctx.curr_step_function_id, seconds
-            )
+        cur_ctx = get_local_dbos_context()
+        if cur_ctx is not None:
+            # Must call it within a workflow
+            assert (
+                cur_ctx.is_workflow()
+            ), "sleep() must be called from within a workflow"
+            attributes: TracedAttributes = {
+                "name": "sleep",
+            }
+            with EnterDBOSStep(attributes) as ctx:
+                _get_dbos_instance()._sys_db.sleep(
+                    ctx.workflow_id, ctx.curr_step_function_id, seconds
+                )
+        else:
+            # Cannot call it from outside of a workflow
+            raise DBOSException("sleep() must be called from within a workflow")
 
     @classmethod
     def set_event(cls, key: str, value: Any) -> None:

{dbos-0.14.0a2 → dbos-0.14.0a6}/dbos/_sys_db.py

@@ -299,6 +299,12 @@ class SystemDatabase:
                 recovery_attempts: int = row[0]
                 if recovery_attempts > max_recovery_attempts:
                     with self.engine.begin() as c:
+                        c.execute(
+                            sa.delete(SystemSchema.workflow_queue).where(
+                                SystemSchema.workflow_queue.c.workflow_uuid
+                                == status["workflow_uuid"]
+                            )
+                        )
                         c.execute(
                             sa.update(SystemSchema.workflow_status)
                             .where(
@@ -311,6 +317,7 @@ class SystemDatabase:
                             )
                             .values(
                                 status=WorkflowStatusString.RETRIES_EXCEEDED.value,
+                                queue_name=None,
                             )
                         )
                     raise DBOSDeadLetterQueueError(

{dbos-0.14.0a2 → dbos-0.14.0a6}/dbos/cli.py

@@ -1,6 +1,5 @@
 import os
 import platform
-import re
 import shutil
 import signal
 import subprocess
@@ -9,12 +8,15 @@ import typing
 from os import path
 from typing import Any
 
+import sqlalchemy as sa
 import tomlkit
 import typer
 from rich import print
 from rich.prompt import Prompt
 from typing_extensions import Annotated
 
+from dbos._schemas.system_database import SystemSchema
+
 from . import load_config
 from ._app_db import ApplicationDatabase
 from ._dbos_config import _is_valid_app_name
@@ -27,7 +29,9 @@ def _on_windows() -> bool:
     return platform.system() == "Windows"
 
 
-@app.command()
+@app.command(
+    help="Start your DBOS application using the start commands in 'dbos-config.yaml'"
+)
 def start() -> None:
     config = load_config()
     start_commands = config["runtimeConfig"]["start"]
@@ -166,7 +170,7 @@ def _get_project_name() -> typing.Union[str, None]:
     return name
 
 
-@app.command()
+@app.command(help="Initialize a new DBOS application from a template")
 def init(
     project_name: Annotated[
         typing.Optional[str], typer.Argument(help="Specify application name")
@@ -214,7 +218,9 @@ def init(
         print(f"[red]{e}[/red]")
 
 
-@app.command()
+@app.command(
+    help="Run your database schema migrations using the migration commands in 'dbos-config.yaml'"
+)
 def migrate() -> None:
     config = load_config()
     if not config["database"]["password"]:
@@ -264,5 +270,68 @@ def migrate() -> None:
     typer.echo(f"Completed schema migration for database {app_db_name}")
 
 
+@app.command(help="Reset the DBOS system database")
+def reset(
+    yes: bool = typer.Option(False, "-y", "--yes", help="Skip confirmation prompt")
+) -> None:
+    if not yes:
+        confirm = typer.confirm(
+            "This command resets your DBOS system database, deleting metadata about past workflows and steps. Are you sure you want to proceed?"
+        )
+        if not confirm:
+            typer.echo("Operation cancelled.")
+            raise typer.Exit()
+    config = load_config()
+    sysdb_name = (
+        config["database"]["sys_db_name"]
+        if "sys_db_name" in config["database"] and config["database"]["sys_db_name"]
+        else config["database"]["app_db_name"] + SystemSchema.sysdb_suffix
+    )
+    postgres_db_url = sa.URL.create(
+        "postgresql+psycopg",
+        username=config["database"]["username"],
+        password=config["database"]["password"],
+        host=config["database"]["hostname"],
+        port=config["database"]["port"],
+        database="postgres",
+    )
+    try:
+        # Connect to postgres default database
+        engine = sa.create_engine(postgres_db_url)
+
+        with engine.connect() as conn:
+            # Set autocommit required for database dropping
+            conn.execution_options(isolation_level="AUTOCOMMIT")
+
+            # Terminate existing connections
+            conn.execute(
+                sa.text(
+                    """
+                SELECT pg_terminate_backend(pg_stat_activity.pid)
+                FROM pg_stat_activity
+                WHERE pg_stat_activity.datname = :db_name
+                AND pid <> pg_backend_pid()
+            """
+                ),
+                {"db_name": sysdb_name},
+            )
+
+            # Drop the database
+            conn.execute(sa.text(f"DROP DATABASE IF EXISTS {sysdb_name}"))
+
+    except sa.exc.SQLAlchemyError as e:
+        typer.echo(f"Error dropping database: {str(e)}")
+        return
+
+    sys_db = None
+    try:
+        sys_db = SystemDatabase(config)
+    except Exception as e:
+        typer.echo(f"DBOS system schema migration failed: {e}")
+    finally:
+        if sys_db:
+            sys_db.destroy()
+
+
 if __name__ == "__main__":
     app()

{dbos-0.14.0a2 → dbos-0.14.0a6}/pyproject.toml

@@ -22,7 +22,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "0.14.0a2"
+version = "0.14.0a6"
 
 [project.license]
 text = "MIT"

{dbos-0.14.0a2 → dbos-0.14.0a6}/tests/test_failures.py

@@ -8,8 +8,8 @@ from psycopg.errors import SerializationFailure
 from sqlalchemy.exc import OperationalError
 
 # Public API
-from dbos import DBOS, GetWorkflowsInput, SetWorkflowID
-from dbos._error import DBOSDeadLetterQueueError, DBOSErrorCode, DBOSException
+from dbos import DBOS, GetWorkflowsInput, Queue, SetWorkflowID
+from dbos._error import DBOSDeadLetterQueueError
 from dbos._sys_db import WorkflowStatusString
 
 
@@ -150,3 +150,44 @@ def test_dead_letter_queue(dbos: DBOS) -> None:
     assert handle.get_result() == None
     dbos._sys_db.wait_for_buffer_flush()
     assert handle.get_status().status == WorkflowStatusString.SUCCESS.value
+
+
+def test_enqueued_dead_letter_queue(dbos: DBOS) -> None:
+    function_started_event = threading.Event()
+    event = threading.Event()
+    max_concurrency = 1
+    max_recovery_attempts = 10
+    recovery_count = 0
+
+    @DBOS.workflow(max_recovery_attempts=max_recovery_attempts)
+    def dead_letter_workflow() -> None:
+        function_started_event.set()
+        nonlocal recovery_count
+        recovery_count += 1
+        event.wait()
+
+    @DBOS.workflow()
+    def regular_workflow() -> None:
+        return
+
+    queue = Queue("test_queue", concurrency=max_concurrency)
+    handle = queue.enqueue(dead_letter_workflow)
+    function_started_event.wait()
+
+    for i in range(max_recovery_attempts):
+        DBOS.recover_pending_workflows()
+        assert recovery_count == i + 2
+
+    regular_handle = queue.enqueue(regular_workflow)
+
+    with pytest.raises(Exception) as exc_info:
+        DBOS.recover_pending_workflows()
+    assert exc_info.errisinstance(DBOSDeadLetterQueueError)
+    assert handle.get_status().status == WorkflowStatusString.RETRIES_EXCEEDED.value
+
+    assert regular_handle.get_result() == None
+
+    event.set()
+    assert handle.get_result() == None
+    dbos._sys_db.wait_for_buffer_flush()
+    assert handle.get_status().status == WorkflowStatusString.SUCCESS.value