llama-deploy-appserver 0.2.7a1__py3-none-any.whl → 0.3.0__py3-none-any.whl

llama_deploy/appserver/routers/ui_proxy.py

@@ -0,0 +1,255 @@
+import asyncio
+import logging
+from contextlib import suppress
+from typing import List
+
+import httpx
+import websockets
+from fastapi import (
+    APIRouter,
+    FastAPI,
+    HTTPException,
+    Request,
+    WebSocket,
+)
+from fastapi.responses import StreamingResponse
+from fastapi.staticfiles import StaticFiles
+from llama_deploy.appserver.configure_logging import suppress_httpx_logs
+from llama_deploy.appserver.interrupts import (
+    OperationAborted,
+    shutdown_event,
+    wait_or_abort,
+)
+from llama_deploy.appserver.settings import ApiserverSettings
+from llama_deploy.core.deployment_config import DeploymentConfig
+
+logger = logging.getLogger(__name__)
+
+
+async def _ws_proxy(ws: WebSocket, upstream_url: str) -> None:
+    """Proxy WebSocket connection to upstream server."""
+    if shutdown_event.is_set():
+        await ws.close()
+        return
+
+    # Defer accept until after upstream connects so we can mirror the selected subprotocol
+
+    # Forward most headers except WebSocket-specific ones
+    header_prefix_blacklist = ["sec-websocket-"]
+    header_blacklist = {
+        "host",
+        "connection",
+        "upgrade",
+    }
+    hdrs = []
+    for k, v in ws.headers.items():
+        if k.lower() not in header_blacklist:
+            for prefix in header_prefix_blacklist:
+                if k.lower().startswith(prefix):
+                    break
+            else:
+                hdrs.append((k, v))
+
+    try:
+        # Parse subprotocols if present
+        subprotocols: List[str] | None = None
+        requested = ws.headers.get("sec-websocket-protocol")
+        if requested:
+            # Parse comma-separated subprotocols (as plain strings)
+            subprotocols = [p.strip() for p in requested.split(",")]
+
+        # Open upstream WebSocket connection, offering the same subprotocols
+        async with websockets.connect(
+            upstream_url,
+            additional_headers=hdrs,
+            subprotocols=subprotocols,
+            open_timeout=5,
+        ) as upstream:
+            await ws.accept(subprotocol=upstream.subprotocol)
+
+            async def client_to_upstream() -> None:
+                try:
+                    while True:
+                        msg = await wait_or_abort(ws.receive(), shutdown_event)
+                        if msg["type"] == "websocket.receive":
+                            if "text" in msg:
+                                await upstream.send(msg["text"])
+                            elif "bytes" in msg:
+                                await upstream.send(msg["bytes"])
+                        elif msg["type"] == "websocket.disconnect":
+                            break
+                except OperationAborted:
+                    pass
+                except Exception:
+                    pass
+
+            async def upstream_to_client() -> None:
+                try:
+                    while True:
+                        message = await wait_or_abort(upstream.recv(), shutdown_event)
+                        if isinstance(message, str):
+                            await ws.send_text(message)
+                        else:
+                            await ws.send_bytes(message)
+                except OperationAborted:
+                    pass
+                except Exception:
+                    pass
+
+            # Pump both directions concurrently, cancel the peer when one side closes
+            t1 = asyncio.create_task(client_to_upstream())
+            t2 = asyncio.create_task(upstream_to_client())
+            _, pending = await asyncio.wait(
+                {t1, t2}, return_when=asyncio.FIRST_COMPLETED
+            )
+            for task in pending:
+                task.cancel()
+                with suppress(asyncio.CancelledError):
+                    await task
+
+            # On shutdown, proactively close both sides to break any remaining waits
+            if shutdown_event.is_set():
+                with suppress(Exception):
+                    await ws.close()
+                with suppress(Exception):
+                    await upstream.close()
+
+    except Exception as e:
+        logger.error(f"WebSocket proxy error: {e}")
+        # Accept then close so clients (and TestClient) don't error on enter
+        with suppress(Exception):
+            await ws.accept()
+        with suppress(Exception):
+            await ws.close()
+    finally:
+        try:
+            await ws.close()
+        except Exception as e:
+            logger.debug(f"Error closing client connection: {e}")
+
+
+def create_ui_proxy_router(name: str, port: int) -> APIRouter:
+    deployment_router = APIRouter(
+        prefix=f"/deployments/{name}",
+        tags=["deployments"],
+    )
+
+    @deployment_router.websocket("/ui/{path:path}")
+    @deployment_router.websocket("/ui")
+    async def websocket_proxy(
+        websocket: WebSocket,
+        path: str | None = None,
+    ) -> None:
+        # Build the upstream WebSocket URL using FastAPI's extracted path parameter
+        slash_path = f"/{path}" if path is not None else ""
+        upstream_path = f"/deployments/{name}/ui{slash_path}"
+
+        # Convert to WebSocket URL
+        upstream_url = f"ws://localhost:{port}{upstream_path}"
+        if websocket.url.query:
+            upstream_url += f"?{websocket.url.query}"
+
+        await _ws_proxy(websocket, upstream_url)
+
+    @deployment_router.api_route(
+        "/ui/{path:path}",
+        methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD", "PATCH"],
+        include_in_schema=False,
+    )
+    @deployment_router.api_route(
+        "/ui",
+        methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD", "PATCH"],
+        include_in_schema=False,
+    )
+    async def proxy(
+        request: Request,
+        path: str | None = None,
+    ) -> StreamingResponse:
+        # Build the upstream URL using FastAPI's extracted path parameter
+        slash_path = f"/{path}" if path else ""
+        upstream_path = f"/deployments/{name}/ui{slash_path}"
+
+        upstream_url = httpx.URL(f"http://localhost:{port}{upstream_path}").copy_with(
+            params=request.query_params
+        )
+
+        # Debug logging
+        logger.debug(f"Proxying {request.method} {request.url} -> {upstream_url}")
+
+        # Strip hop-by-hop headers + host
+        hop_by_hop = {
+            "connection",
+            "keep-alive",
+            "proxy-authenticate",
+            "proxy-authorization",
+            "te",  # codespell:ignore
+            "trailers",
+            "transfer-encoding",
+            "upgrade",
+            "host",
+        }
+        headers = {
+            k: v for k, v in request.headers.items() if k.lower() not in hop_by_hop
+        }
+
+        try:
+            client = httpx.AsyncClient(timeout=None)
+
+            req = client.build_request(
+                request.method,
+                upstream_url,
+                headers=headers,
+                content=request.stream(),  # stream uploads
+            )
+            async with suppress_httpx_logs():
+                upstream = await client.send(req, stream=True)
+
+            resp_headers = {
+                k: v for k, v in upstream.headers.items() if k.lower() not in hop_by_hop
+            }
+
+            # Stream downloads and ensure cleanup in the generator's finally block
+            async def upstream_body():
+                try:
+                    async for chunk in upstream.aiter_raw():
+                        yield chunk
+                finally:
+                    try:
+                        await upstream.aclose()
+                    finally:
+                        await client.aclose()
+
+            return StreamingResponse(
+                upstream_body(),
+                status_code=upstream.status_code,
+                headers=resp_headers,
+            )
+
+        except httpx.ConnectError:
+            raise HTTPException(status_code=502, detail="Upstream server unavailable")
+        except httpx.TimeoutException:
+            raise HTTPException(status_code=504, detail="Upstream server timeout")
+        except Exception as e:
+            logger.error(f"Proxy error: {e}")
+            raise HTTPException(status_code=502, detail="Proxy error")
+
+    return deployment_router
+
+
+def mount_static_files(
+    app: FastAPI, config: DeploymentConfig, settings: ApiserverSettings
+) -> None:
+    path = settings.app_root / config.build_output_path()
+    if not path:
+        return
+
+    if not path.exists():
+        return
+
+    # Serve index.html when accessing the directory path
+    app.mount(
+        f"/deployments/{config.name}/ui",
+        StaticFiles(directory=str(path), html=True),
+        name=f"ui-static-{config.name}",
+    )
+    return None

llama_deploy/appserver/settings.py

@@ -1,9 +1,43 @@
+import os
 from pathlib import Path
+from typing import Literal
 
+from llama_deploy.core.config import DEFAULT_DEPLOYMENT_FILE_PATH
+from llama_deploy.core.deployment_config import resolve_config_parent
 from pydantic import Field
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
+class BootstrapSettings(BaseSettings):
+    """
+    Settings configurable via env vars for controlling how an application is
+    created from a git repository.
+    """
+
+    model_config = SettingsConfigDict(env_prefix="LLAMA_DEPLOY_")
+    repo_url: str | None = Field(
+        default=None, description="The URL of the git repository to clone"
+    )
+    auth_token: str | None = Field(
+        default=None, description="The token to use to clone the git repository"
+    )
+    git_ref: str | None = Field(
+        default=None, description="The git reference to checkout"
+    )
+    git_sha: str | None = Field(default=None, description="The git SHA to checkout")
+    deployment_file_path: str = Field(
+        default=".",
+        description="The path to the deployment file, relative to the root of the repository",
+    )
+    deployment_name: str | None = Field(
+        default=None, description="The name of the deployment"
+    )
+    bootstrap_sdists: str | None = Field(
+        default=None,
+        description="A directory containing tar.gz sdists to install instead of installing the appserver",
+    )
+
+
 class ApiserverSettings(BaseSettings):
     model_config = SettingsConfigDict(env_prefix="LLAMA_DEPLOY_APISERVER_")
 
@@ -15,69 +49,85 @@ class ApiserverSettings(BaseSettings):
         default=4501,
         description="The TCP port where to bind the API Server",
     )
-    rc_path: Path = Field(
-        default=Path("./.llama_deploy_rc"),
-        description="Path to the folder containing the deployment configs that will be loaded at startup",
-    )
-    deployments_path: Path | None = Field(
-        default=None,
-        description="Path to the folder where deployments will create their root path, defaults to a temp dir",
-    )
-    deployment_file_path: str | None = Field(
-        default=None,
-        description="Optional path, relative to the rc_path, where the deployment file is located. If not provided, will glob all .yml/.yaml files in the rc_path",
-    )
-    use_tls: bool = Field(
-        default=False,
-        description="Use TLS (HTTPS) to communicate with the API Server",
-    )
 
-    # Metrics collection settings
-    prometheus_enabled: bool = Field(
-        default=True,
-        description="Whether to enable the Prometheus metrics exporter along with the API Server",
+    app_root: Path = Field(
+        default=Path("."),
+        description="The root of the application",
     )
-    prometheus_port: int = Field(
-        default=9000,
-        description="The port where to serve Prometheus metrics",
+
+    deployment_file_path: Path = Field(
+        default=Path(DEFAULT_DEPLOYMENT_FILE_PATH),
+        description="path, relative to the repository root, where the pyproject.toml file is located",
     )
 
-    # Tracing settings
-    tracing_enabled: bool = Field(
+    proxy_ui: bool = Field(
         default=False,
-        description="Enable OpenTelemetry tracing. Defaults to False.",
+        description="If true, proxy a development UI server instead of serving built assets",
     )
-    tracing_service_name: str = Field(
-        default="llama-deploy-appserver",
-        description="Service name for tracing. Defaults to 'llama-deploy-appserver'.",
+    proxy_ui_port: int = Field(
+        default=4502,
+        description="The TCP port where to bind the UI proxy server",
     )
-    tracing_exporter: str = Field(
-        default="console",
-        description="Trace exporter type: 'console', 'jaeger', 'otlp'. Defaults to 'console'.",
+
+    reload: bool = Field(
+        default=False,
+        description="If true, reload the workflow modules, for use in a dev server environment",
     )
-    tracing_endpoint: str | None = Field(
+
+    persistence: Literal["memory", "local", "cloud"] | None = Field(
         default=None,
-        description="Trace exporter endpoint. Required for 'jaeger' and 'otlp' exporters.",
-    )
-    tracing_sample_rate: float = Field(
-        default=1.0,
-        description="Trace sampling rate (0.0 to 1.0). Defaults to 1.0 (100% sampling).",
+        description="The persistence mode to use for the workflow server",
     )
-    tracing_insecure: bool = Field(
-        default=True,
-        description="Use insecure connection for OTLP exporter. Defaults to True.",
+    local_persistence_path: str | None = Field(
+        default=None,
+        description="The path to the sqlite database to use for the workflow server",
     )
-    tracing_timeout: int = Field(
-        default=30,
-        description="Timeout in seconds for trace export. Defaults to 30.",
+    cloud_persistence_name: str | None = Field(
+        default=None,
+        description="Agent Data deployment name to use for workflow persistence. May optionally include a `:` delimited collection name, e.g. 'my_agent:my_collection'. Leave none to use the current deployment name. Recommended to override with _public if running locally, and specify a collection name",
     )
 
     @property
-    def url(self) -> str:
-        protocol = "https://" if self.use_tls else "http://"
-        if self.port == 80:
-            return f"{protocol}{self.host}"
-        return f"{protocol}{self.host}:{self.port}"
+    def resolved_config_parent(self) -> Path:
+        return resolve_config_parent(self.app_root, self.deployment_file_path)
 
 
 settings = ApiserverSettings()
+
+
+def configure_settings(
+    proxy_ui: bool | None = None,
+    deployment_file_path: Path | None = None,
+    app_root: Path | None = None,
+    reload: bool | None = None,
+    persistence: Literal["memory", "local", "cloud"] | None = None,
+    local_persistence_path: str | None = None,
+    cloud_persistence_name: str | None = None,
+) -> None:
+    if proxy_ui is not None:
+        settings.proxy_ui = proxy_ui
+        os.environ["LLAMA_DEPLOY_APISERVER_PROXY_UI"] = "true" if proxy_ui else "false"
+    if deployment_file_path is not None:
+        settings.deployment_file_path = deployment_file_path
+        os.environ["LLAMA_DEPLOY_APISERVER_DEPLOYMENT_FILE_PATH"] = str(
+            deployment_file_path
+        )
+    if app_root is not None:
+        settings.app_root = app_root
+        os.environ["LLAMA_DEPLOY_APISERVER_APP_ROOT"] = str(app_root)
+    if reload is not None:
+        settings.reload = reload
+        os.environ["LLAMA_DEPLOY_APISERVER_RELOAD"] = "true" if reload else "false"
+    if persistence is not None:
+        settings.persistence = persistence
+        os.environ["LLAMA_DEPLOY_APISERVER_PERSISTENCE"] = persistence
+    if local_persistence_path is not None:
+        settings.local_persistence_path = local_persistence_path
+        os.environ["LLAMA_DEPLOY_APISERVER_LOCAL_PERSISTENCE_PATH"] = (
+            local_persistence_path
+        )
+    if cloud_persistence_name is not None:
+        settings.cloud_persistence_name = cloud_persistence_name
+        os.environ["LLAMA_DEPLOY_APISERVER_CLOUD_PERSISTENCE_NAME"] = (
+            cloud_persistence_name
+        )

llama_deploy/appserver/types.py

@@ -91,9 +91,6 @@ class StatusEnum(Enum):
 
 class Status(BaseModel):
     status: StatusEnum
-    status_message: str
-    max_deployments: int | None = None
-    deployments: list[str] | None = None
 
 
 class DeploymentDefinition(BaseModel):