dbos 0.13.0a1__tar.gz → 0.14.0__tar.gz

{dbos-0.13.0a1 → dbos-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbos
-Version: 0.13.0a1
+Version: 0.14.0
 Summary: Ultra-lightweight durable execution in Python
 Author-Email: "DBOS, Inc." <contact@dbos.dev>
 License: MIT
@@ -18,6 +18,7 @@ Requires-Dist: python-dateutil>=2.9.0.post0
 Requires-Dist: fastapi[standard]>=0.115.2
 Requires-Dist: tomlkit>=0.13.2
 Requires-Dist: psycopg[binary]>=3.1
+Requires-Dist: fastapi-cli==0.0.5
 Description-Content-Type: text/markdown
 
 

{dbos-0.13.0a1 → dbos-0.14.0}/dbos/_admin_sever.py

@@ -53,7 +53,6 @@ class AdminRequestHandler(BaseHTTPRequestHandler):
             self._end_headers()
             self.wfile.write("healthy".encode("utf-8"))
         elif self.path == _deactivate_path:
-            dbos_logger.info("Deactivating DBOS")
             # Stop all scheduled workflows, queues, and kafka loops
             for event in self.dbos.stop_events:
                 event.set()

{dbos-0.13.0a1 → dbos-0.14.0}/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.13.0a1 → dbos-0.14.0}/dbos/_dbos_config.py

@@ -169,7 +169,7 @@ def load_config(config_file_path: str = "dbos-config.yaml") -> ConfigFile:
 
     if not _is_valid_app_name(data["name"]):
         raise DBOSInitializationError(
-            f'Invalid app name {data["name"]}.  App names must be between 3 and 30 characters and contain only alphanumeric characters, dashes, and underscores.'
+            f'Invalid app name {data["name"]}.  App names must be between 3 and 30 characters long and contain only lowercase letters, numbers, dashes, and underscores.'
         )
 
     if "app_db_name" not in data["database"]:
@@ -198,4 +198,4 @@ def _app_name_to_db_name(app_name: str) -> str:
 def _set_env_vars(config: ConfigFile) -> None:
     for env, value in config.get("env", {}).items():
         if value is not None:
-            os.environ[env] = value
+            os.environ[env] = str(value)

{dbos-0.13.0a1 → dbos-0.14.0}/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.13.0a1 → dbos-0.14.0}/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")
@@ -187,7 +191,9 @@ def init(
             )
 
         if not _is_valid_app_name(project_name):
-            raise Exception(f"{project_name} is an invalid DBOS app name")
+            raise Exception(
+                f"{project_name} is an invalid DBOS app name. App names must be between 3 and 30 characters long and contain only lowercase letters, numbers, dashes, and underscores."
+            )
 
         templates_dir = _get_templates_directory()
         templates = [x.name for x in os.scandir(templates_dir) if x.is_dir()]
@@ -212,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"]:
@@ -262,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.13.0a1 → dbos-0.14.0}/pyproject.toml

@@ -19,10 +19,11 @@ dependencies = [
     "fastapi[standard]>=0.115.2",
     "tomlkit>=0.13.2",
     "psycopg[binary]>=3.1",
+    "fastapi-cli==0.0.5",
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "0.13.0a1"
+version = "0.14.0"
 
 [project.license]
 text = "MIT"

{dbos-0.13.0a1 → dbos-0.14.0}/tests/test_config.py

@@ -44,6 +44,7 @@ def test_valid_config(mocker):
             foo: ${BARBAR}
             bazbaz: BAZBAZ
             bob: ${BOBBOB}
+            test_number: 123
     """
     os.environ["BARBAR"] = "FOOFOO"
     mocker.patch(
@@ -61,10 +62,12 @@ def test_valid_config(mocker):
     assert configFile["database"]["connectionTimeoutMillis"] == 3000
     assert configFile["env"]["foo"] == "FOOFOO"
     assert configFile["env"]["bob"] is None  # Unset environment variable
+    assert configFile["env"]["test_number"] == 123
 
     _set_env_vars(configFile)
     assert os.environ["bazbaz"] == "BAZBAZ"
     assert os.environ["foo"] == "FOOFOO"
+    assert os.environ["test_number"] == "123"
     assert "bob" not in os.environ
 
 

{dbos-0.13.0a1 → dbos-0.14.0}/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