dbos 0.26.0a8__tar.gz → 0.26.0a9__tar.gz

{dbos-0.26.0a8 → dbos-0.26.0a9}/PKG-INFO

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

{dbos-0.26.0a8 → dbos-0.26.0a9}/dbos/_dbos_config.py

@@ -15,7 +15,6 @@ from jsonschema import ValidationError, validate
 from rich import print
 from sqlalchemy import URL, make_url
 
-from ._db_wizard import db_wizard, load_db_connection
 from ._error import DBOSInitializationError
 from ._logger import dbos_logger
 
@@ -70,7 +69,6 @@ class DatabaseConfig(TypedDict, total=False):
     sys_db_pool_size: Optional[int]
     ssl: Optional[bool]
     ssl_ca: Optional[str]
-    local_suffix: Optional[bool]
     migrate: Optional[List[str]]
     rollback: Optional[List[str]]
 
@@ -288,7 +286,6 @@ def load_config(
     config_file_path: str = DBOS_CONFIG_PATH,
     *,
     run_process_config: bool = True,
-    use_db_wizard: bool = True,
     silent: bool = False,
 ) -> ConfigFile:
     """
@@ -339,13 +336,12 @@ def load_config(
 
     data = cast(ConfigFile, data)
     if run_process_config:
-        data = process_config(data=data, use_db_wizard=use_db_wizard, silent=silent)
+        data = process_config(data=data, silent=silent)
     return data  # type: ignore
 
 
 def process_config(
     *,
-    use_db_wizard: bool = True,
     data: ConfigFile,
     silent: bool = False,
 ) -> ConfigFile:
@@ -372,22 +368,17 @@ def process_config(
     # database_url takes precedence over database config, but we need to preserve rollback and migrate if they exist
     migrate = data["database"].get("migrate", False)
     rollback = data["database"].get("rollback", False)
-    local_suffix = data["database"].get("local_suffix", False)
     if data.get("database_url"):
         dbconfig = parse_database_url_to_dbconfig(cast(str, data["database_url"]))
         if migrate:
             dbconfig["migrate"] = cast(List[str], migrate)
         if rollback:
             dbconfig["rollback"] = cast(List[str], rollback)
-        if local_suffix:
-            dbconfig["local_suffix"] = cast(bool, local_suffix)
         data["database"] = dbconfig
 
     if "app_db_name" not in data["database"] or not (data["database"]["app_db_name"]):
         data["database"]["app_db_name"] = _app_name_to_db_name(data["name"])
 
-    # Load the DB connection file. Use its values for missing connection parameters. Use defaults otherwise.
-    db_connection = load_db_connection()
     connection_passed_in = data["database"].get("hostname", None) is not None
 
     dbos_dbport: Optional[int] = None
@@ -397,49 +388,22 @@ def process_config(
             dbos_dbport = int(dbport_env)
         except ValueError:
             pass
-    dbos_dblocalsuffix: Optional[bool] = None
-    dblocalsuffix_env = os.getenv("DBOS_DBLOCALSUFFIX")
-    if dblocalsuffix_env:
-        try:
-            dbos_dblocalsuffix = dblocalsuffix_env.casefold() == "true".casefold()
-        except ValueError:
-            pass
 
     data["database"]["hostname"] = (
-        os.getenv("DBOS_DBHOST")
-        or data["database"].get("hostname")
-        or db_connection.get("hostname")
-        or "localhost"
+        os.getenv("DBOS_DBHOST") or data["database"].get("hostname") or "localhost"
     )
 
-    data["database"]["port"] = (
-        dbos_dbport or data["database"].get("port") or db_connection.get("port") or 5432
-    )
+    data["database"]["port"] = dbos_dbport or data["database"].get("port") or 5432
     data["database"]["username"] = (
-        os.getenv("DBOS_DBUSER")
-        or data["database"].get("username")
-        or db_connection.get("username")
-        or "postgres"
+        os.getenv("DBOS_DBUSER") or data["database"].get("username") or "postgres"
     )
     data["database"]["password"] = (
         os.getenv("DBOS_DBPASSWORD")
         or data["database"].get("password")
-        or db_connection.get("password")
         or os.environ.get("PGPASSWORD")
         or "dbos"
     )
 
-    local_suffix = False
-    dbcon_local_suffix = db_connection.get("local_suffix")
-    if dbcon_local_suffix is not None:
-        local_suffix = dbcon_local_suffix
-    db_local_suffix = data["database"].get("local_suffix")
-    if db_local_suffix is not None:
-        local_suffix = db_local_suffix
-    if dbos_dblocalsuffix is not None:
-        local_suffix = dbos_dblocalsuffix
-    data["database"]["local_suffix"] = local_suffix
-
     if not data["database"].get("app_db_pool_size"):
         data["database"]["app_db_pool_size"] = 20
     if not data["database"].get("sys_db_pool_size"):
@@ -454,10 +418,6 @@ def process_config(
     elif "run_admin_server" not in data["runtimeConfig"]:
         data["runtimeConfig"]["run_admin_server"] = True
 
-    # Check the connectivity to the database and make sure it's properly configured
-    # Note, never use db wizard if the DBOS is running in debug mode (i.e. DBOS_DEBUG_WORKFLOW_ID env var is set)
-    debugWorkflowId = os.getenv("DBOS_DEBUG_WORKFLOW_ID")
-
     # Pretty-print where we've loaded database connection information from, respecting the log level
     if not silent and logs["logLevel"] == "INFO" or logs["logLevel"] == "DEBUG":
         d = data["database"]
@@ -470,21 +430,11 @@ def process_config(
             print(
                 f"[bold blue]Using database connection string: {conn_string}[/bold blue]"
             )
-        elif db_connection.get("hostname"):
-            print(
-                f"[bold blue]Loading database connection string from .dbos/db_connection: {conn_string}[/bold blue]"
-            )
         else:
             print(
                 f"[bold blue]Using default database connection string: {conn_string}[/bold blue]"
             )
 
-    if use_db_wizard and debugWorkflowId is None:
-        data = db_wizard(data)
-
-    if "local_suffix" in data["database"] and data["database"]["local_suffix"]:
-        data["database"]["app_db_name"] = f"{data['database']['app_db_name']}_local"
-
     # Return data as ConfigFile type
     return data
 

dbos-0.26.0a9/dbos/_docker_pg_helper.py

@@ -0,0 +1,191 @@
+import logging
+import os
+import subprocess
+import time
+
+import docker
+import psycopg
+from docker.errors import APIError, NotFound
+
+logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+from typing import Any, Dict, Optional, Tuple
+
+
+def start_docker_pg() -> None:
+    """
+    Starts a PostgreSQL database in a Docker container.
+
+    This function checks if Docker is installed, and if so, starts a local PostgreSQL
+    database in a Docker container. It configures the database with default settings
+    and provides connection information upon successful startup.
+
+    The function uses environment variable PGPASSWORD if available, otherwise
+    defaults to 'dbos' as the database password.
+
+    Returns:
+        None
+
+    Raises:
+        Exception: If there is an error starting the Docker container or if the
+                   PostgreSQL service does not become available within the timeout period.
+    """
+
+    logging.info("Attempting to create a Docker Postgres container...")
+    has_docker = check_docker_installed()
+
+    pool_config = {
+        "host": "localhost",
+        "port": 5432,
+        "password": os.environ.get("PGPASSWORD", "dbos"),
+        "user": "postgres",
+        "database": "postgres",
+        "connect_timeout": 2,
+    }
+
+    # If Docker is installed, start a local Docker based Postgres
+    if has_docker:
+        start_docker_postgres(pool_config)
+        logging.info(
+            f"Postgres available at postgres://postgres:{pool_config['password']}@{pool_config['host']}:{pool_config['port']}"
+        )
+    else:
+        logging.warning("Docker not detected locally")
+
+
+def check_db_connectivity(config: Dict[str, Any]) -> Optional[Exception]:
+    conn = None
+    try:
+        conn = psycopg.connect(
+            host=config["host"],
+            port=config["port"],
+            user=config["user"],
+            password=config["password"],
+            dbname=config["database"],
+            connect_timeout=config.get("connect_timeout", 30),
+        )
+        cursor = conn.cursor()
+        cursor.execute("SELECT 1;")
+        cursor.close()
+        return None
+    except Exception as error:
+        return error
+    finally:
+        if conn is not None:
+            conn.close()
+
+
+def exec_sync(cmd: str) -> Tuple[str, str]:
+    result = subprocess.run(cmd, shell=True, text=True, capture_output=True, check=True)
+    return result.stdout, result.stderr
+
+
+def start_docker_postgres(pool_config: Dict[str, Any]) -> bool:
+    logging.info("Starting a Postgres Docker container...")
+    container_name = "dbos-db"
+    pg_data = "/var/lib/postgresql/data"
+
+    try:
+        client = docker.from_env()
+
+        # Check if the container already exists
+        try:
+            container = client.containers.get(container_name)
+            if container.status == "running":
+                logging.info(f"Container '{container_name}' is already running.")
+                return True
+            elif container.status == "exited":
+                container.start()
+                logging.info(
+                    f"Container '{container_name}' was stopped and has been restarted."
+                )
+                return True
+        except NotFound:
+            # Container doesn't exist, proceed with creation
+            pass
+
+        # Create and start the container
+        container = client.containers.run(
+            image="pgvector/pgvector:pg16",
+            name=container_name,
+            detach=True,
+            environment={
+                "POSTGRES_PASSWORD": pool_config["password"],
+                "PGDATA": pg_data,
+            },
+            ports={"5432/tcp": pool_config["port"]},
+            volumes={pg_data: {"bind": pg_data, "mode": "rw"}},
+            remove=True,  # Equivalent to --rm
+        )
+
+        logging.info(f"Created container: {container.id}")
+
+    except APIError as e:
+        raise Exception(f"Docker API error: {str(e)}")
+
+    # Wait for PostgreSQL to be ready
+    attempts = 30
+    while attempts > 0:
+        if attempts % 5 == 0:
+            logging.info("Waiting for Postgres Docker container to start...")
+
+        if check_db_connectivity(pool_config) is None:
+            return True
+
+        attempts -= 1
+        time.sleep(1)
+
+    raise Exception(
+        f"Failed to start Docker container: Container {container_name} did not start in time."
+    )
+
+
+def check_docker_installed() -> bool:
+    """
+    Check if Docker is installed and running using the docker library.
+
+    Returns:
+        bool: True if Docker is installed and running, False otherwise.
+    """
+    try:
+        client = docker.from_env()
+        client.ping()  # type: ignore
+        return True
+    except Exception:
+        return False
+
+
+def stop_docker_pg() -> None:
+    """
+    Stops the Docker Postgres container.
+
+    Returns:
+        bool: True if the container was successfully stopped, False if it wasn't running
+
+    Raises:
+        Exception: If there was an error stopping the container
+    """
+    logger = logging.getLogger()
+    container_name = "dbos-db"
+    try:
+        logger.info(f"Stopping Docker Postgres container {container_name}...")
+
+        client = docker.from_env()
+
+        try:
+            container = client.containers.get(container_name)
+
+            if container.status == "running":
+                container.stop()
+                logger.info(
+                    f"Successfully stopped Docker Postgres container {container_name}."
+                )
+            else:
+                logger.info(f"Container {container_name} exists but is not running.")
+
+        except docker.errors.NotFound:
+            logger.info(f"Container {container_name} does not exist.")
+
+    except Exception as error:
+        error_message = str(error)
+        logger.error(f"Failed to stop Docker Postgres container: {error_message}")
+        raise

{dbos-0.26.0a8 → dbos-0.26.0a9}/dbos/cli/cli.py

@@ -20,6 +20,7 @@ from dbos._debug import debug_workflow, parse_start_command
 from .. import load_config
 from .._app_db import ApplicationDatabase
 from .._dbos_config import _is_valid_app_name
+from .._docker_pg_helper import start_docker_pg, stop_docker_pg
 from .._sys_db import SystemDatabase, reset_system_database
 from .._workflow_commands import (
     get_workflow,
@@ -37,6 +38,21 @@ queue = typer.Typer()
 app.add_typer(workflow, name="workflow", help="Manage DBOS workflows")
 workflow.add_typer(queue, name="queue", help="Manage enqueued workflows")
 
+postgres = typer.Typer()
+app.add_typer(
+    postgres, name="postgres", help="Manage local Postgres database with Docker"
+)
+
+
+@postgres.command(name="start", help="Start a local Postgres database")
+def pg_start() -> None:
+    start_docker_pg()
+
+
+@postgres.command(name="stop", help="Stop the local Postgres database")
+def pg_stop() -> None:
+    stop_docker_pg()
+
 
 def _on_windows() -> bool:
     return platform.system() == "Windows"
@@ -246,7 +262,7 @@ def reset(
 def debug(
     workflow_id: Annotated[str, typer.Argument(help="Workflow ID to debug")],
 ) -> None:
-    config = load_config(silent=True, use_db_wizard=False)
+    config = load_config(silent=True)
     start = config["runtimeConfig"]["start"]
     if not start:
         typer.echo("No start commands found in 'dbos-config.yaml'")

{dbos-0.26.0a8 → dbos-0.26.0a9}/dbos/dbos-config.schema.json

@@ -62,10 +62,6 @@
             "type": "string",
             "description": "If using SSL/TLS to securely connect to a database, path to an SSL root certificate file"
           },
-          "local_suffix": {
-            "type": "boolean",
-            "description": "Whether to suffix app_db_name with '_local'. Set to true when doing local development using a DBOS Cloud database."
-          },
           "app_db_client": {
             "type": "string",
             "description": "Specify the database client to use to connect to the application database",

{dbos-0.26.0a8 → dbos-0.26.0a9}/pyproject.toml

@@ -28,7 +28,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "0.26.0a8"
+version = "0.26.0a9"
 
 [project.license]
 text = "MIT"
@@ -88,4 +88,5 @@ dev = [
     "pdm-backend>=2.4.2",
     "pytest-asyncio>=0.25.0",
     "pyright>=1.1.398",
+    "types-docker>=7.1.0.20241229",
 ]

{dbos-0.26.0a8 → dbos-0.26.0a9}/tests/test_config.py

@@ -327,7 +327,6 @@ def test_process_config_full():
             "sys_db_pool_size": 27,
             "ssl": True,
             "ssl_ca": "ca.pem",
-            "local_suffix": False,
             "migrate": ["alembic upgrade head"],
             "rollback": ["alembic downgrade base"],
         },
@@ -351,7 +350,7 @@ def test_process_config_full():
         },
     }
 
-    configFile = process_config(data=config, use_db_wizard=False)
+    configFile = process_config(data=config)
     assert configFile["name"] == "some-app"
     assert configFile["database"]["hostname"] == "example.com"
     assert configFile["database"]["port"] == 2345
@@ -362,7 +361,6 @@ def test_process_config_full():
     assert configFile["database"]["sys_db_name"] == "sys_db"
     assert configFile["database"]["ssl"] == True
     assert configFile["database"]["ssl_ca"] == "ca.pem"
-    assert configFile["database"]["local_suffix"] == False
     assert configFile["database"]["migrate"] == ["alembic upgrade head"]
     assert configFile["database"]["rollback"] == ["alembic downgrade base"]
     assert configFile["database"]["app_db_pool_size"] == 45
@@ -386,7 +384,7 @@ def test_process_config_with_db_url():
         "name": "some-app",
         "database_url": "postgresql://user:password@localhost:7777/dbn?connect_timeout=1&sslmode=require&sslrootcert=ca.pem",
     }
-    processed_config = process_config(data=config, use_db_wizard=False)
+    processed_config = process_config(data=config)
     assert processed_config["name"] == "some-app"
     assert processed_config["database"]["hostname"] == "localhost"
     assert processed_config["database"]["port"] == 7777
@@ -396,7 +394,6 @@ def test_process_config_with_db_url():
     assert processed_config["database"]["connectionTimeoutMillis"] == 1000
     assert processed_config["database"]["ssl"] == True
     assert processed_config["database"]["ssl_ca"] == "ca.pem"
-    assert processed_config["database"]["local_suffix"] == False
     assert processed_config["database"]["app_db_pool_size"] == 20
     assert processed_config["database"]["sys_db_pool_size"] == 20
     assert "rollback" not in processed_config["database"]
@@ -417,22 +414,20 @@ def test_process_config_with_db_url_taking_precedence_over_database():
             "sys_db_name": "sys_db",
             "ssl": True,
             "ssl_ca": "ca.pem",
-            "local_suffix": True,
             "migrate": ["alembic upgrade head"],
             "rollback": ["alembic downgrade base"],
         },
         "database_url": "postgresql://boo:whoisdiz@remotehost:7777/takesprecedence",
     }
-    processed_config = process_config(data=config, use_db_wizard=False)
+    processed_config = process_config(data=config)
     assert processed_config["name"] == "some-app"
     assert processed_config["database"]["hostname"] == "remotehost"
     assert processed_config["database"]["port"] == 7777
     assert processed_config["database"]["username"] == "boo"
     assert processed_config["database"]["password"] == "whoisdiz"
-    assert processed_config["database"]["app_db_name"] == "takesprecedence_local"
+    assert processed_config["database"]["app_db_name"] == "takesprecedence"
     assert processed_config["database"]["migrate"] == ["alembic upgrade head"]
     assert processed_config["database"]["rollback"] == ["alembic downgrade base"]
-    assert processed_config["database"]["local_suffix"] == True
     assert processed_config["database"]["app_db_pool_size"] == 20
     assert processed_config["database"]["sys_db_pool_size"] == 20
     assert processed_config["database"]["connectionTimeoutMillis"] == 10000
@@ -550,32 +545,6 @@ def test_config_bad_name():
     assert "Invalid app name" in str(exc_info.value)
 
 
-def test_load_config_load_db_connection(mocker):
-    mock_db_connection = """
-    {"hostname": "example.com", "port": 2345, "username": "example", "password": "password", "local_suffix": true}
-    """
-    mocker.patch(
-        "builtins.open",
-        side_effect=generate_mock_open([".dbos/db_connection"], [mock_db_connection]),
-    )
-
-    config = {
-        "name": "some-app",
-    }
-
-    configFile = process_config(data=config, use_db_wizard=False)
-    assert configFile["name"] == "some-app"
-    assert configFile["database"]["hostname"] == "example.com"
-    assert configFile["database"]["port"] == 2345
-    assert configFile["database"]["username"] == "example"
-    assert configFile["database"]["password"] == "password"
-    assert configFile["database"]["local_suffix"] == True
-    assert configFile["database"]["app_db_name"] == "some_app_local"
-    assert configFile["database"]["app_db_pool_size"] == 20
-    assert configFile["database"]["sys_db_pool_size"] == 20
-    assert configFile["database"]["connectionTimeoutMillis"] == 10000
-
-
 def test_config_mixed_params():
     config = {
         "name": "some-app",
@@ -587,7 +556,7 @@ def test_config_mixed_params():
         },
     }
 
-    configFile = process_config(data=config, use_db_wizard=False)
+    configFile = process_config(data=config)
     assert configFile["name"] == "some-app"
     assert configFile["database"]["hostname"] == "localhost"
     assert configFile["database"]["port"] == 1234
@@ -606,77 +575,22 @@ def test_debug_override(mocker: pytest_mock.MockFixture):
             "DBOS_DBPORT": "1234",
             "DBOS_DBUSER": "fakeuser",
             "DBOS_DBPASSWORD": "fakepassword",
-            "DBOS_DBLOCALSUFFIX": "false",
         },
     )
 
     config: Configfile = {
         "name": "some-app",
     }
-    configFile = process_config(data=config, use_db_wizard=False)
+    configFile = process_config(data=config)
     assert configFile["database"]["hostname"] == "fakehost"
     assert configFile["database"]["port"] == 1234
     assert configFile["database"]["username"] == "fakeuser"
     assert configFile["database"]["password"] == "fakepassword"
-    assert configFile["database"]["local_suffix"] == False
     assert configFile["database"]["app_db_pool_size"] == 20
     assert configFile["database"]["sys_db_pool_size"] == 20
     assert configFile["database"]["connectionTimeoutMillis"] == 10000
 
 
-def test_local_config():
-    config: ConfigFile = {
-        "name": "some-app",
-        "database": {
-            "hostname": "localhost",
-            "port": 5432,
-            "username": "postgres",
-            "password": os.environ["PGPASSWORD"],
-            "app_db_name": "some_db",
-            "connectionTimeoutMillis": 3000,
-            "local_suffix": True,
-        },
-    }
-    processed_config = process_config(data=config)
-
-    assert processed_config["name"] == "some-app"
-    assert processed_config["database"]["local_suffix"] == True
-    assert processed_config["database"]["hostname"] == "localhost"
-    assert processed_config["database"]["port"] == 5432
-    assert processed_config["database"]["username"] == "postgres"
-    assert processed_config["database"]["password"] == os.environ["PGPASSWORD"]
-    assert processed_config["database"]["app_db_name"] == "some_db_local"
-    assert processed_config["database"]["connectionTimeoutMillis"] == 3000
-    assert processed_config["database"]["app_db_pool_size"] == 20
-    assert processed_config["database"]["sys_db_pool_size"] == 20
-
-
-def test_local_config_without_name(mocker):
-    config: ConfigFile = {
-        "name": "some-app",
-        "database": {
-            "hostname": "localhost",
-            "port": 5432,
-            "username": "postgres",
-            "password": os.environ["PGPASSWORD"],
-            "connectionTimeoutMillis": 3000,
-            "local_suffix": True,
-        },
-    }
-    processed_config = process_config(data=config)
-
-    assert processed_config["name"] == "some-app"
-    assert processed_config["database"]["local_suffix"] == True
-    assert processed_config["database"]["hostname"] == "localhost"
-    assert processed_config["database"]["port"] == 5432
-    assert processed_config["database"]["username"] == "postgres"
-    assert processed_config["database"]["password"] == os.environ["PGPASSWORD"]
-    assert processed_config["database"]["app_db_name"] == "some_app_local"
-    assert processed_config["database"]["connectionTimeoutMillis"] == 3000
-    assert processed_config["database"]["app_db_pool_size"] == 20
-    assert processed_config["database"]["sys_db_pool_size"] == 20
-
-
 ####################
 # DB STRING PARSING
 ####################
@@ -1412,28 +1326,3 @@ def test_get_dbos_database_url(mocker):
         database="some_db",
     ).render_as_string(hide_password=False)
     assert get_dbos_database_url() == expected_url
-
-
-def test_get_dbos_database_url_local_suffix(mocker):
-    mock_config = """
-        name: "some-app"
-        database:
-          hostname: 'localhost'
-          port: 5432
-          username: 'postgres'
-          password: ${PGPASSWORD}
-          app_db_name: 'some_db'
-          local_suffix: true
-    """
-    mocker.patch(
-        "builtins.open", side_effect=generate_mock_open(mock_filename, mock_config)
-    )
-    expected_url = URL.create(
-        "postgresql+psycopg",
-        username="postgres",
-        password=os.environ.get("PGPASSWORD"),
-        host="localhost",
-        port=5432,
-        database="some_db_local",
-    ).render_as_string(hide_password=False)
-    assert get_dbos_database_url() == expected_url