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

llama_deploy/appserver/routers/ui_proxy.py

@@ -0,0 +1,213 @@
+import asyncio
+import logging
+from typing import List, Optional
+
+from fastapi.staticfiles import StaticFiles
+from fastapi import FastAPI
+import httpx
+from llama_deploy.appserver.deployment_config_parser import DeploymentConfig
+from llama_deploy.appserver.settings import ApiserverSettings
+import websockets
+from fastapi import (
+    APIRouter,
+    HTTPException,
+    Request,
+    WebSocket,
+)
+from fastapi.responses import StreamingResponse
+from starlette.background import BackgroundTask
+
+logger = logging.getLogger(__name__)
+
+
+async def _ws_proxy(ws: WebSocket, upstream_url: str) -> None:
+    """Proxy WebSocket connection to upstream server."""
+    await ws.accept()
+
+    # Forward most headers except WebSocket-specific ones
+    header_blacklist = {
+        "host",
+        "connection",
+        "upgrade",
+        "sec-websocket-key",
+        "sec-websocket-version",
+        "sec-websocket-extensions",
+    }
+    hdrs = [(k, v) for k, v in ws.headers.items() if k.lower() not in header_blacklist]
+
+    try:
+        # Parse subprotocols if present
+        subprotocols: Optional[List[websockets.Subprotocol]] = None
+        if "sec-websocket-protocol" in ws.headers:
+            # Parse comma-separated subprotocols
+            subprotocols = [
+                websockets.Subprotocol(p.strip())
+                for p in ws.headers["sec-websocket-protocol"].split(",")
+            ]
+
+        # Open upstream WebSocket connection
+        async with websockets.connect(
+            upstream_url,
+            additional_headers=hdrs,
+            subprotocols=subprotocols,
+            open_timeout=None,
+            ping_interval=None,
+        ) as upstream:
+
+            async def client_to_upstream() -> None:
+                try:
+                    while True:
+                        msg = await ws.receive()
+                        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 Exception as e:
+                    logger.debug(f"Client to upstream connection ended: {e}")
+
+            async def upstream_to_client() -> None:
+                try:
+                    async for message in upstream:
+                        if isinstance(message, str):
+                            await ws.send_text(message)
+                        else:
+                            await ws.send_bytes(message)
+                except Exception as e:
+                    logger.debug(f"Upstream to client connection ended: {e}")
+
+            # Pump both directions concurrently
+            await asyncio.gather(
+                client_to_upstream(), upstream_to_client(), return_exceptions=True
+            )
+
+    except Exception as e:
+        logger.error(f"WebSocket proxy error: {e}")
+    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 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}"
+
+        logger.debug(f"Proxying WebSocket {websocket.url} -> {upstream_url}")
+
+        await _ws_proxy(websocket, upstream_url)
+
+    @deployment_router.api_route(
+        "/ui/{path:path}",
+        methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD", "PATCH"],
+    )
+    @deployment_router.api_route(
+        "/ui",
+        methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD", "PATCH"],
+    )
+    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
+            )
+            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
+            }
+
+            # Close client when upstream response is done
+            async def cleanup() -> None:
+                await upstream.aclose()
+                await client.aclose()
+
+            return StreamingResponse(
+                upstream.aiter_raw(),  # stream downloads
+                status_code=upstream.status_code,
+                headers=resp_headers,
+                background=BackgroundTask(cleanup),  # tidy up when finished
+            )
+
+        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:
+    if not config.ui or not config.ui.source:
+        return
+
+    ui_path = settings.config_parent / config.ui.source.location / "dist"
+    if not ui_path.exists():
+        return
+
+    # Serve index.html when accessing the directory path
+    app.mount(
+        f"/deployments/{config.name}/ui",
+        StaticFiles(directory=str(ui_path), html=True),
+        name=f"ui-static-{config.name}",
+    )
+    return None

llama_deploy/appserver/settings.py

@@ -1,7 +1,35 @@
+import os
 from pathlib import Path
 
 from pydantic import Field
 from pydantic_settings import BaseSettings, SettingsConfigDict
+from llama_deploy.core.config import DEFAULT_DEPLOYMENT_FILE_PATH
+
+
+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="llama_deploy.yaml",
+        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"
+    )
 
 
 class ApiserverSettings(BaseSettings):
@@ -15,69 +43,43 @@ 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 deployment file is located. If not provided, will look for ./llama_deploy.yaml",
     )
 
-    # Tracing settings
-    tracing_enabled: bool = Field(
+    proxy_ui: bool = Field(
         default=False,
-        description="Enable OpenTelemetry tracing. Defaults to False.",
-    )
-    tracing_service_name: str = Field(
-        default="llama-deploy-appserver",
-        description="Service name for tracing. Defaults to 'llama-deploy-appserver'.",
-    )
-    tracing_exporter: str = Field(
-        default="console",
-        description="Trace exporter type: 'console', 'jaeger', 'otlp'. Defaults to 'console'.",
-    )
-    tracing_endpoint: str | 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).",
-    )
-    tracing_insecure: bool = Field(
-        default=True,
-        description="Use insecure connection for OTLP exporter. Defaults to True.",
-    )
-    tracing_timeout: int = Field(
-        default=30,
-        description="Timeout in seconds for trace export. Defaults to 30.",
+        description="If true, proxy a development UI server instead of serving built assets",
     )
 
     @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 config_parent(self) -> Path:
+        return (self.app_root / self.deployment_file_path).parent
 
 
 settings = ApiserverSettings()
+
+
+def configure_settings(
+    proxy_ui: bool | None = None,
+    deployment_file_path: Path | None = None,
+    app_root: Path | 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)

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):