experimaestro 2.0.0b8__py3-none-any.whl → 2.0.0b17__py3-none-any.whl

experimaestro/webui/routes/__init__.py

@@ -0,0 +1,5 @@
+"""WebUI route modules"""
+
+from experimaestro.webui.routes import auth, proxy
+
+__all__ = ["auth", "proxy"]

experimaestro/webui/routes/auth.py

@@ -0,0 +1,53 @@
+"""Authentication routes for WebUI"""
+
+import logging
+from typing import Optional
+from fastapi import APIRouter, Request, Response, Query
+from fastapi.responses import RedirectResponse
+
+logger = logging.getLogger("xpm.webui.auth")
+
+router = APIRouter()
+
+
+@router.get("/auth")
+async def auth(
+    request: Request,
+    xpm_token: Optional[str] = Query(None, alias="xpm-token"),
+):
+    """Authenticate with token and set cookie
+
+    If valid token provided, redirects to index.html with cookie set.
+    The token is passed as ?xpm-token=... in the URL.
+    """
+    server = request.app.state.server
+
+    if xpm_token and server.token == xpm_token:
+        response = RedirectResponse(url="/index.html", status_code=302)
+        response.set_cookie(
+            key="experimaestro_token",
+            value=xpm_token,
+            httponly=True,
+            samesite="lax",
+        )
+        return response
+
+    return RedirectResponse(url="/login.html", status_code=302)
+
+
+@router.get("/stop")
+async def stop(
+    request: Request,
+    xpm_token: Optional[str] = Query(None, alias="xpm-token"),
+):
+    """Stop the server (requires authentication)"""
+    server = request.app.state.server
+
+    # Check token from query param or cookie
+    token = xpm_token or request.cookies.get("experimaestro_token")
+
+    if server.token == token:
+        server.request_quit()
+        return Response(status_code=202)
+
+    return Response(status_code=401)

experimaestro/webui/routes/proxy.py

@@ -0,0 +1,117 @@
+"""Service proxy routes for WebUI"""
+
+import logging
+
+from fastapi import APIRouter, Request, Response
+from fastapi.responses import RedirectResponse
+
+logger = logging.getLogger("xpm.webui.proxy")
+
+router = APIRouter()
+
+
+@router.api_route(
+    "/services/{service_id}/{path:path}",
+    methods=["GET", "POST", "PUT", "DELETE", "PATCH"],
+)
+async def proxy_service(request: Request, service_id: str, path: str = ""):
+    """Proxy requests to a service
+
+    Routes /services/{service_id}/{path} to the service's URL.
+    """
+    server = request.app.state.server
+
+    # Get service from scheduler (only works in active mode)
+    from experimaestro.scheduler.base import Scheduler
+
+    if not isinstance(server.state_provider, Scheduler):
+        return Response(
+            content="Service proxy only available in active mode",
+            status_code=503,
+        )
+
+    scheduler: Scheduler = server.state_provider
+
+    # Find service in experiments
+    service = None
+    for xp in scheduler.experiments.values():
+        service = xp.services.get(service_id)
+        if service:
+            break
+
+    if service is None:
+        return Response(
+            content=f"Service {service_id} not found",
+            status_code=404,
+        )
+
+    # Get service URL
+    base_url = service.get_url()
+    if not base_url:
+        return Response(
+            content=f"Service {service_id} has no URL",
+            status_code=503,
+        )
+
+    # Proxy the request using httpx
+    import httpx
+
+    # Build target URL
+    target_url = f"{base_url}/{path}"
+    if request.query_params:
+        target_url = f"{target_url}?{request.query_params}"
+
+    # Forward headers (filter sensitive ones)
+    headers = {}
+    for key, value in request.headers.items():
+        key_lower = key.lower()
+        if key_lower not in ("host", "content-length", "transfer-encoding"):
+            headers[key] = value
+
+    # Get request body for POST/PUT/PATCH
+    body = None
+    if request.method in ("POST", "PUT", "PATCH"):
+        body = await request.body()
+
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.request(
+                method=request.method,
+                url=target_url,
+                headers=headers,
+                content=body,
+                follow_redirects=False,
+            )
+
+            # Build response
+            response_headers = {}
+            for key, value in response.headers.items():
+                key_lower = key.lower()
+                if key_lower not in (
+                    "content-encoding",
+                    "transfer-encoding",
+                    "content-length",
+                ):
+                    response_headers[key] = value
+
+            return Response(
+                content=response.content,
+                status_code=response.status_code,
+                headers=response_headers,
+                media_type=response.headers.get("content-type"),
+            )
+    except httpx.RequestError as e:
+        logger.error("Proxy error for service %s: %s", service_id, e)
+        return Response(
+            content=f"Proxy error: {e}",
+            status_code=502,
+        )
+
+
+@router.get("/services/{service_id}")
+async def redirect_service(service_id: str):
+    """Redirect to service with trailing slash"""
+    return RedirectResponse(
+        url=f"/services/{service_id}/",
+        status_code=308,  # Permanent redirect, preserves method
+    )

experimaestro/webui/server.py

@@ -0,0 +1,200 @@
+"""WebUI Server implementation
+
+Aligned with TUI's ExperimaestroUI pattern, using StateProvider abstraction.
+"""
+
+import logging
+import platform
+import socket
+import threading
+import uuid
+from typing import ClassVar, Optional
+
+from experimaestro.scheduler.state_provider import StateProvider
+from experimaestro.settings import ServerSettings
+
+logger = logging.getLogger("xpm.webui")
+
+
+class WebUIServer:
+    """WebUI server for monitoring experiments
+
+    Aligned with TUI's ExperimaestroUI pattern:
+    - Uses StateProvider abstraction for data access
+    - Supports both embedded mode (live scheduler) and offline mode (database)
+    - Can wait for explicit quit from interface (like TUI)
+    """
+
+    _instance: ClassVar[Optional["WebUIServer"]] = None
+    _lock: ClassVar[threading.Lock] = threading.Lock()
+
+    @staticmethod
+    def instance(
+        settings: ServerSettings = None,
+        state_provider: StateProvider = None,
+        wait_for_quit: bool = False,
+    ) -> "WebUIServer":
+        """Get or create the global server instance
+
+        Args:
+            settings: Server settings (optional, uses defaults if not provided)
+            state_provider: StateProvider instance (required)
+            wait_for_quit: If True, server waits for explicit quit from UI
+        """
+        if WebUIServer._instance is None:
+            with WebUIServer._lock:
+                if WebUIServer._instance is None:
+                    if settings is None:
+                        from experimaestro.settings import get_settings
+
+                        settings = get_settings().server
+
+                    if state_provider is None:
+                        raise ValueError(
+                            "state_provider parameter is required. "
+                            "Pass the Scheduler instance or WorkspaceStateProvider."
+                        )
+
+                    WebUIServer._instance = WebUIServer(
+                        settings, state_provider, wait_for_quit
+                    )
+        return WebUIServer._instance
+
+    @staticmethod
+    def clear_instance():
+        """Clear the singleton instance (for testing)"""
+        with WebUIServer._lock:
+            WebUIServer._instance = None
+
+    def __init__(
+        self,
+        settings: ServerSettings,
+        state_provider: StateProvider,
+        wait_for_quit: bool = False,
+    ):
+        """Initialize the WebUI server
+
+        Args:
+            settings: Server settings
+            state_provider: StateProvider for accessing experiment/job data
+            wait_for_quit: If True, wait for explicit quit from web interface
+        """
+        # Determine host binding
+        if settings.autohost == "fqdn":
+            settings.host = socket.getfqdn()
+            logger.info("Auto host name (fqdn): %s", settings.host)
+        elif settings.autohost == "name":
+            settings.host = platform.node()
+            logger.info("Auto host name (name): %s", settings.host)
+
+        if settings.host is None or settings.host == "127.0.0.1":
+            self.binding_host = "127.0.0.1"
+        else:
+            self.binding_host = "0.0.0.0"
+
+        self.host = settings.host or "127.0.0.1"
+        self.port = settings.port
+        self.token = settings.token or uuid.uuid4().hex
+        self.state_provider = state_provider
+        self.wait_for_quit = wait_for_quit
+
+        # Check if we have an active experiment (scheduler as state provider)
+        from experimaestro.scheduler.base import Scheduler
+
+        self._has_active_experiment = isinstance(state_provider, Scheduler)
+
+        # Threading state
+        self._thread: Optional[threading.Thread] = None
+        self._running = False
+        self._cv_running = threading.Condition()
+        self._quit_event = threading.Event()
+
+        # Uvicorn server reference
+        self._uvicorn_server = None
+
+    def start(self):
+        """Start the web server in a daemon thread"""
+        logger.info("Starting the web server")
+
+        self._thread = threading.Thread(
+            target=self._run_server,
+            daemon=True,
+            name="webui-server",
+        )
+        self._thread.start()
+
+        # Wait until server is ready
+        with self._cv_running:
+            self._cv_running.wait_for(lambda: self._running)
+
+        logger.info(
+            "Web server started on http://%s:%d/auth?xpm-token=%s",
+            self.host,
+            self.port,
+            self.token,
+        )
+
+    def _run_server(self):
+        """Run the uvicorn server (called in thread)"""
+        import uvicorn
+
+        from experimaestro.webui.app import create_app
+
+        # Find available port if needed
+        if self.port is None or self.port == 0:
+            logger.info("Searching for an available port")
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.bind(("", 0))
+            self.port = sock.getsockname()[1]
+            sock.close()
+
+        # Create FastAPI app
+        app = create_app(self)
+
+        # Configure uvicorn
+        config = uvicorn.Config(
+            app,
+            host=self.binding_host,
+            port=self.port,
+            log_level="warning",
+            access_log=False,
+        )
+        self._uvicorn_server = uvicorn.Server(config)
+
+        # Signal that we're running
+        with self._cv_running:
+            self._running = True
+            self._cv_running.notify_all()
+
+        # Run server (blocks until shutdown)
+        self._uvicorn_server.run()
+        logger.info("Web server stopped")
+
+    def stop(self):
+        """Stop the server gracefully"""
+        if self._uvicorn_server:
+            self._uvicorn_server.should_exit = True
+
+    def request_quit(self):
+        """Signal quit request from web interface"""
+        logger.info("Quit requested from web interface")
+        self._quit_event.set()
+        self.stop()
+
+    def wait(self):
+        """Wait for explicit quit from web interface
+
+        Call this after experiment completion when wait_for_quit=True.
+        Blocks until user clicks Quit button in the web UI.
+        """
+        if not self.wait_for_quit:
+            return
+
+        logger.info("Waiting for quit from web interface...")
+        self._quit_event.wait()
+        logger.info("Quit signal received")
+
+    @property
+    def is_running(self) -> bool:
+        """Check if server is running"""
+        return self._running

experimaestro/webui/state_bridge.py

@@ -0,0 +1,152 @@
+"""State Bridge - connects StateProvider events to WebSocket broadcasts
+
+Mirrors the TUI's STATE_EVENT_HANDLERS pattern for consistent event handling.
+Uses db_state_dict() serialization consistent with SSHStateProviderServer.
+"""
+
+import asyncio
+import logging
+from typing import TYPE_CHECKING
+
+from experimaestro.scheduler.state_provider import StateProvider
+from experimaestro.scheduler.state_status import (
+    EventBase,
+    ExperimentUpdatedEvent,
+    JobStateChangedEvent,
+    JobSubmittedEvent,
+    ServiceAddedEvent,
+    RunUpdatedEvent,
+)
+
+if TYPE_CHECKING:
+    from experimaestro.webui.websocket import WebSocketHandler
+
+logger = logging.getLogger("xpm.webui.state_bridge")
+
+
+class StateBridge:
+    """Bridges StateProvider events to WebSocket broadcasts
+
+    Similar to TUI's STATE_EVENT_HANDLERS pattern, converts events
+    to WebSocket messages and broadcasts to all connected clients.
+
+    Uses db_state_dict() for consistent serialization with SSHStateProviderServer.
+    """
+
+    def __init__(
+        self,
+        state_provider: StateProvider,
+        ws_handler: "WebSocketHandler",
+    ):
+        """Initialize state bridge
+
+        Args:
+            state_provider: StateProvider to listen to
+            ws_handler: WebSocket handler for broadcasting
+        """
+        self.state_provider = state_provider
+        self.ws_handler = ws_handler
+        self._loop: asyncio.AbstractEventLoop = None
+
+        # Register as listener
+        state_provider.add_listener(self._on_state_event)
+
+    def _on_state_event(self, event: EventBase):
+        """Handle state event from provider
+
+        Called from provider's thread, schedules async broadcast.
+        """
+        # Get or create event loop for async operations
+        try:
+            # Try to get running loop (if called from async context)
+            loop = asyncio.get_running_loop()
+            loop.create_task(self._handle_event_async(event))
+        except RuntimeError:
+            # No running loop - create new one or use thread-safe call
+            asyncio.run(self._handle_event_async(event))
+
+    async def _handle_event_async(self, event: EventBase):
+        """Handle state event asynchronously"""
+        handler = self._get_handler(event)
+        if handler:
+            await handler(event)
+
+    def _get_handler(self, event: EventBase):
+        """Get handler for event type"""
+        handlers = {
+            ExperimentUpdatedEvent: self._handle_experiment_updated,
+            JobStateChangedEvent: self._handle_job_state_changed,
+            JobSubmittedEvent: self._handle_job_submitted,
+            ServiceAddedEvent: self._handle_service_added,
+            RunUpdatedEvent: self._handle_run_updated,
+        }
+        return handlers.get(type(event))
+
+    async def _handle_experiment_updated(self, event: ExperimentUpdatedEvent):
+        """Handle experiment update - broadcast experiment.add"""
+        from experimaestro.webui.websocket import serialize_experiment
+
+        # Fetch experiment from state provider
+        experiment = self.state_provider.get_experiment(event.experiment_id)
+        if experiment:
+            payload = serialize_experiment(experiment)
+            await self.ws_handler.broadcast("experiment.add", payload)
+
+    async def _handle_job_state_changed(self, event: JobStateChangedEvent):
+        """Handle job state change - broadcast job.update"""
+        from experimaestro.webui.websocket import job_db_to_frontend
+
+        # Fetch job from state provider
+        # Note: get_all_jobs returns jobs across all experiments
+        jobs = self.state_provider.get_all_jobs()
+        job = next((j for j in jobs if j.identifier == event.job_id), None)
+        if job:
+            payload = job_db_to_frontend(job.db_state_dict())
+            await self.ws_handler.broadcast("job.update", payload)
+
+    async def _handle_job_submitted(self, event: JobSubmittedEvent):
+        """Handle job added to experiment - broadcast job.add"""
+        from experimaestro.webui.websocket import job_db_to_frontend
+
+        # Fetch the full job data from state provider
+        job = self.state_provider.get_job(event.job_id, event.experiment_id)
+        if job:
+            # Get base dict from db_state_dict
+            db_dict = job.db_state_dict()
+
+            # Add tags and dependencies from event
+            db_dict["tags"] = (
+                [(tag.key, tag.value) for tag in event.tags] if event.tags else []
+            )
+            db_dict["depends_on"] = event.depends_on or []
+
+            payload = job_db_to_frontend(db_dict)
+            await self.ws_handler.broadcast("job.add", payload)
+
+    async def _handle_service_added(self, event: ServiceAddedEvent):
+        """Handle service added - broadcast service.add"""
+        from experimaestro.webui.websocket import service_db_to_frontend
+
+        # Fetch service from state provider
+        services = self.state_provider.get_services(event.experiment_id, event.run_id)
+        service = next((s for s in services if s.id == event.service_id), None)
+        if service:
+            payload = service_db_to_frontend(service.db_state_dict())
+            await self.ws_handler.broadcast("service.add", payload)
+
+    async def _handle_run_updated(self, event: RunUpdatedEvent):
+        """Handle run update - triggers experiment refresh"""
+        from experimaestro.webui.websocket import serialize_experiment
+
+        # Run updates affect experiment stats, so broadcast experiment update
+        experiment = self.state_provider.get_experiment(event.experiment_id)
+        if experiment:
+            payload = serialize_experiment(experiment)
+            await self.ws_handler.broadcast("experiment.add", payload)
+
+    def close(self):
+        """Clean up - remove listener"""
+        try:
+            self.state_provider.remove_listener(self._on_state_event)
+        except ValueError:
+            pass  # Already removed