Skip to content

Self-improving AI Employees for everyone

refactor(Wave 13.2): extract 5 deployment WS handlers to services/deployment/

trohitgac6f98eefddd
diff --git a/server/routers/websocket.py b/server/routers/websocket.py
index 970d13e3..3c3199d2 100644
--- a/server/routers/websocket.py
+++ b/server/routers/websocket.py
@@ -901,354 +901,12 @@ async def handle_execute_workflow(data: Dict[str, Any], websocket: WebSocket) ->
}
-# Per-workflow deployment tasks for proper cancellation (Temporal/n8n pattern)
-# Maps workflow_id -> asyncio.Task for parallel workflow deployments
-_deployment_tasks: Dict[str, asyncio.Task] = {}
-
-
-@ws_handler()
-async def handle_deploy_workflow(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Deploy workflow to run continuously until cancelled.
-
- Expects:
- workflow_id: Workflow identifier (required for locking)
- nodes: List of workflow nodes with {id, type, data}
- edges: List of edges with {id, source, target}
- session_id: Optional session identifier
- delay_between_runs: Optional delay in seconds between iterations (default: 1.0)
-
- Returns:
- Deployment start confirmation (deployment runs in background)
- """
- global _deployment_tasks
- workflow_service = container.workflow_service()
- broadcaster = get_status_broadcaster()
-
- workflow_id = data.get("workflow_id")
- nodes = data.get("nodes", [])
- edges = data.get("edges", [])
- session_id = data.get("session_id", "default")
-
- # DEBUG: Log received edges to trace tool connection issues
- logger.debug(f"[Deploy] Received {len(edges)} edges for workflow {workflow_id}")
- for e in edges:
- target_handle = e.get('targetHandle')
- if target_handle and target_handle.startswith('input-') and target_handle != 'input-main':
- logger.debug(f"[Deploy] Config edge: {e.get('source')} -> {e.get('target')} (handle={target_handle})")
-
- # Check for tool connections to AI Agent
- tool_edges = [e for e in edges if e.get('targetHandle') == 'input-tools']
- if tool_edges:
- logger.debug(f"[Deploy] Tool edges found: {len(tool_edges)}")
- for te in tool_edges:
- logger.debug(f"[Deploy] Tool edge: source={te.get('source')} -> target={te.get('target')}")
- else:
- logger.debug("[Deploy] No input-tools edges found")
-
- if not nodes:
- return {"success": False, "error": "No nodes provided"}
-
- if not workflow_id:
- return {"success": False, "error": "workflow_id is required for deployment"}
-
- # Pre-deploy validation gate. Deploy never honors a force-override —
- # a broken workflow running on a schedule is far worse than a failed
- # one-shot manual run.
- from services.workflow_validator import validate_workflow
- deploy_report = await validate_workflow(
- nodes=nodes, edges=edges,
- parameters_by_id=data.get("parameters_by_id"),
- )
- if deploy_report["errors"]:
- return {
- "success": False,
- "error": "validation_failed",
- "report": deploy_report,
- }
-
- # Check if THIS specific workflow is already deployed (per-workflow isolation)
- if workflow_service.is_workflow_deployed(workflow_id):
- status = workflow_service.get_deployment_status(workflow_id)
- return {
- "success": False,
- "error": f"Workflow {workflow_id} is already deployed. Cancel it first.",
- "workflow_id": workflow_id,
- "is_running": True,
- "run_counter": status.get("run_counter", 0)
- }
-
- # Acquire workflow lock before starting deployment (per-workflow locking - n8n pattern)
- lock_acquired = await broadcaster.lock_workflow(workflow_id, reason="deployment")
- if not lock_acquired:
- lock_info = broadcaster.get_workflow_lock(workflow_id)
- return {
- "success": False,
- "error": f"Workflow {workflow_id} is already locked for {lock_info.get('reason', 'deployment')}",
- "locked_by": lock_info.get("workflow_id"),
- "locked_at": lock_info.get("locked_at")
- }
-
- # Broadcast deployment starting status using centralized method
- await broadcaster.update_workflow_status(executing=True, current_node=None, progress=0)
- await broadcaster.update_deployment_status(
- is_running=True,
- status="starting",
- active_runs=0,
- workflow_id=workflow_id
- )
-
- # Create status callback to broadcast node and deployment updates
- # Include workflow_id in all node status updates (n8n pattern for workflow isolation)
- async def status_callback(node_id: str, status: str, node_data: Optional[Dict] = None):
- if node_id == "__deployment__":
- # Deployment-level status update using centralized method
- active_runs = node_data.get("active_runs", 0) if node_data else 0
- await broadcaster.update_deployment_status(
- is_running=True,
- status=status,
- active_runs=active_runs,
- workflow_id=workflow_id,
- data=node_data
- )
- else:
- # Node-level status update with workflow_id for frontend filtering
- await broadcaster.update_node_status(node_id, status, node_data, workflow_id=workflow_id)
- if status == "executing":
- position = node_data.get("position", 0) if node_data else 0
- total = node_data.get("total", 1) if node_data else 1
- progress = int((position / total) * 100) if total > 0 else 0
- await broadcaster.update_workflow_status(executing=True, current_node=node_id, progress=progress)
-
- # Start deployment as background task (per-workflow - Temporal/n8n pattern)
- # In the event-driven pattern, deploy_workflow() returns immediately after setting up triggers.
- # The workflow stays locked until cancel_deployment is called.
- async def run_deployment():
- try:
- result = await workflow_service.deploy_workflow(
- nodes=nodes,
- edges=edges,
- session_id=session_id,
- status_callback=status_callback,
- workflow_id=workflow_id
- )
-
- # In event-driven mode, deploy_workflow returns immediately after trigger setup.
- # If it failed, unlock and report error. If successful, stay running.
- if not result.get("success"):
- # Setup failed - unlock and report error
- logger.error("Deployment setup failed", error=result.get("error"), workflow_id=workflow_id)
- await broadcaster.update_deployment_status(
- is_running=False,
- status="error",
- active_runs=0,
- workflow_id=workflow_id,
- error=result.get("error")
- )
- await broadcaster.unlock_workflow(workflow_id)
- # Clean up task reference for this workflow
- _deployment_tasks.pop(workflow_id, None)
- else:
- # Deployment successful - triggers are set up and running.
- # Workflow stays locked until cancel_deployment is called.
- await broadcaster.update_deployment_status(
- is_running=True,
- status="running",
- active_runs=0,
- workflow_id=workflow_id,
- data={
- "triggers_setup": result.get("triggers_setup", []),
- "deployment_id": result.get("deployment_id")
- }
- )
- logger.info("[Deployment] Event-driven deployment active",
- deployment_id=result.get("deployment_id"),
- workflow_id=workflow_id,
- triggers=len(result.get("triggers_setup", [])))
-
- except Exception as e:
- logger.error("Deployment task error", workflow_id=workflow_id, error=str(e))
- await broadcaster.update_deployment_status(
- is_running=False,
- status="error",
- active_runs=0,
- workflow_id=workflow_id,
- error=str(e)
- )
- await broadcaster.unlock_workflow(workflow_id)
- # Clean up task reference for this workflow
- _deployment_tasks.pop(workflow_id, None)
-
- # Store task per workflow for independent cancellation
- _deployment_tasks[workflow_id] = asyncio.create_task(run_deployment())
-
- return {
- "success": True,
- "message": "Deployment started",
- "workflow_id": workflow_id,
- "is_running": True,
- "locked": True,
- "timestamp": time.time()
- }
-
-
-@ws_handler()
-async def handle_cancel_deployment(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Cancel running deployment for a specific workflow (Temporal/n8n pattern).
-
- Expects:
- workflow_id: Workflow to cancel (required).
-
- Also cancels any active event waiters (trigger nodes) and unlocks the workflow.
-
- Returns:
- Cancellation result with iterations completed
- """
- global _deployment_tasks
-
- workflow_service = container.workflow_service()
- broadcaster = get_status_broadcaster()
-
- workflow_id = data.get("workflow_id")
-
- if not workflow_id:
- return {"success": False, "error": "workflow_id is required for cancellation"}
-
- result = await workflow_service.cancel_deployment(workflow_id)
-
- # Cancel event waiters for this specific workflow's nodes
- cancelled_waiters = 0
- if result.get("success"):
- cancelled_waiters = result.get("waiters_cancelled", 0)
-
- # Cancel the deployment task for THIS specific workflow only (per-workflow isolation)
- task = _deployment_tasks.pop(workflow_id, None)
- if task and not task.done():
- task.cancel()
- try:
- await task
- except asyncio.CancelledError:
- logger.info("[Deployment] Deployment task cancelled", workflow_id=workflow_id)
-
- # Unlock this specific workflow
- if workflow_id:
- await broadcaster.unlock_workflow(workflow_id)
-
- if result.get("success"):
- # Clear node statuses for all trigger nodes that were waiting
- # The result contains info about cancelled listeners (listener_{node_id})
- # Use existing clear_node_status method which broadcasts node_status_cleared
- for node_id in result.get("cancelled_listener_node_ids", []):
- await broadcaster.clear_node_status(node_id)
-
- # Broadcast deployment cancelled status using centralized method
- await broadcaster.update_workflow_status(executing=False, current_node=None, progress=0)
- await broadcaster.update_deployment_status(
- is_running=False,
- status="cancelled",
- active_runs=0,
- workflow_id=workflow_id,
- data={
- "iterations_completed": result.get("iterations_completed", 0)
- }
- )
-
- return {
- "success": result.get("success", False),
- "message": result.get("message", result.get("error")),
- "workflow_id": workflow_id,
- "was_running": result.get("was_running", False),
- "iterations_completed": result.get("iterations_completed", 0),
- "cancelled_waiters": cancelled_waiters,
- "unlocked": workflow_id is not None,
- "timestamp": time.time()
- }
-
-
-@ws_handler()
-async def handle_get_deployment_status(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Get current deployment status including workflow lock info.
-
- Expects (optional):
- workflow_id: Get status for specific workflow. If not provided, returns global status.
-
- Returns:
- Current deployment state, iteration count, and lock status
- """
- workflow_service = container.workflow_service()
- broadcaster = get_status_broadcaster()
-
- workflow_id = data.get("workflow_id")
- status = workflow_service.get_deployment_status(workflow_id)
-
- return {
- "is_running": workflow_service.is_deployment_running(workflow_id),
- "run_counter": status.get("run_counter", 0),
- "active_runs": status.get("active_runs", 0),
- "settings": workflow_service.get_deployment_settings(),
- "workflow_id": workflow_id or status.get("workflow_id"),
- "deployed_workflows": status.get("deployed_workflows", []),
- "lock": broadcaster.get_workflow_lock(),
- "timestamp": time.time()
- }
-
-
-@ws_handler()
-async def handle_get_workflow_lock(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Get current workflow lock status.
-
- Returns:
- Current lock state including locked workflow_id and reason
- """
- broadcaster = get_status_broadcaster()
-
- return {
- "lock": broadcaster.get_workflow_lock(),
- "timestamp": time.time()
- }
-
-
-@ws_handler()
-async def handle_update_deployment_settings(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Update deployment settings (can be called during active deployment).
-
- Expects any of:
- delay_between_runs: float - Seconds to wait between iterations
- stop_on_error: bool - Stop deployment when a node fails
- max_iterations: int - Max iterations (0 = unlimited)
-
- Returns:
- Updated settings and current deployment state
- """
- workflow_service = container.workflow_service()
- broadcaster = get_status_broadcaster()
-
- settings_to_update = {}
- if "delay_between_runs" in data:
- settings_to_update["delay_between_runs"] = data["delay_between_runs"]
- if "stop_on_error" in data:
- settings_to_update["stop_on_error"] = data["stop_on_error"]
- if "max_iterations" in data:
- settings_to_update["max_iterations"] = data["max_iterations"]
-
- updated_settings = await workflow_service.update_deployment_settings(settings_to_update)
-
- # Broadcast settings update
- status = workflow_service.get_deployment_status()
- await broadcaster.broadcast({
- "type": "deployment_settings_updated",
- "settings": updated_settings,
- "is_running": workflow_service.is_deployment_running(),
- "run_counter": status.get("run_counter", 0)
- })
-
- return {
- "success": True,
- "settings": updated_settings,
- "is_running": workflow_service.is_deployment_running(),
- "run_counter": status.get("run_counter", 0),
- "active_runs": status.get("active_runs", 0),
- "timestamp": time.time()
- }
+# ============================================================================
+# Deployment handlers — extracted to services/deployment/handlers.py (Wave 13.2)
+# ============================================================================
+# 5 handlers (deploy_workflow / cancel_deployment / get_deployment_status /
+# get_workflow_lock / update_deployment_settings) self-register into the
+# central ws_handler_registry via services/deployment/__init__.py.
# ============================================================================
@@ -2358,12 +2016,8 @@ MESSAGE_HANDLERS: Dict[str, MessageHandler] = {
"remove_dlq_entry": handle_remove_dlq_entry,
"purge_dlq": handle_purge_dlq,
- # Deployment operations
- "deploy_workflow": handle_deploy_workflow,
- "cancel_deployment": handle_cancel_deployment,
- "get_deployment_status": handle_get_deployment_status,
- "get_workflow_lock": handle_get_workflow_lock,
- "update_deployment_settings": handle_update_deployment_settings,
+ # Deployment operations — extracted to services/deployment/handlers.py
+ # (Wave 13.2); registered via ws_handler_registry on package import.
# AI operations
"execute_ai_node": handle_execute_ai_node,
diff --git a/server/services/deployment/__init__.py b/server/services/deployment/__init__.py
index cb255141..955a56fc 100644
--- a/server/services/deployment/__init__.py
+++ b/server/services/deployment/__init__.py
@@ -1,8 +1,19 @@
-"""Deployment module - Event-driven workflow deployment."""
+"""Deployment module - Event-driven workflow deployment.
+
+Wave 13.2: side-effect import publishes the 5 deployment WS handlers
+(deploy_workflow / cancel_deployment / get_deployment_status /
+get_workflow_lock / update_deployment_settings) into the central
+``ws_handler_registry``.
+"""
+
+from services.ws_handler_registry import register_ws_handlers as _register_ws_handlers
from .state import DeploymentState, TriggerInfo
from .triggers import TriggerManager
from .manager import DeploymentManager
+from .handlers import WS_HANDLERS as _DEPLOYMENT_WS_HANDLERS
+
+_register_ws_handlers(_DEPLOYMENT_WS_HANDLERS)
__all__ = [
"DeploymentState",
diff --git a/server/services/deployment/handlers.py b/server/services/deployment/handlers.py
new file mode 100644
index 00000000..9f722fae
--- /dev/null
+++ b/server/services/deployment/handlers.py
@@ -0,0 +1,377 @@
+"""Deployment domain WebSocket handlers.
+
+Extracted from ``routers/websocket.py`` (Wave 13.2). The 5 handlers
+below cover the deployment lifecycle:
+
+ - ``deploy_workflow`` — start a continuously-running workflow with
+ triggers + per-workflow locking.
+ - ``cancel_deployment`` — cancel a running deployment, drain its
+ listeners, unlock the workflow.
+ - ``get_deployment_status`` — snapshot of in-flight deployments.
+ - ``get_workflow_lock`` — current lock state.
+ - ``update_deployment_settings`` — mutate runtime settings without
+ re-deploying.
+
+All handlers preserve their pre-Wave-13 wire shape. The module-level
+``_deployment_tasks`` dict (workflow_id -> asyncio.Task) moves here
+too; it was process-local in ``routers/websocket.py`` and stays the
+same shape — only the import path changes.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any, Dict, Optional
+
+from fastapi import WebSocket
+
+from core.logging import get_logger
+from services.ws_handler_registry import ws_handler
+
+# ``core.container`` and ``services.status_broadcaster`` are lazy-imported
+# inside each handler body. This module is imported transitively via
+# ``services.workflow`` during ``core.container`` initialization (the
+# container wires ``WorkflowService`` which imports ``services.workflow``
+# which imports ``services.deployment``). Eager imports at module scope
+# would deadlock the partially-initialized container module.
+
+logger = get_logger(__name__)
+
+
+# Per-workflow deployment tasks for proper cancellation (Temporal/n8n pattern).
+# Maps workflow_id -> asyncio.Task for parallel workflow deployments.
+_deployment_tasks: Dict[str, asyncio.Task] = {}
+
+
+@ws_handler()
+async def handle_deploy_workflow(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Deploy workflow to run continuously until cancelled.
+
+ Expects:
+ workflow_id: Workflow identifier (required for locking)
+ nodes: List of workflow nodes with {id, type, data}
+ edges: List of edges with {id, source, target}
+ session_id: Optional session identifier
+ delay_between_runs: Optional delay in seconds between iterations (default: 1.0)
+
+ Returns:
+ Deployment start confirmation (deployment runs in background)
+ """
+ global _deployment_tasks
+ from core.container import container
+ from services.status_broadcaster import get_status_broadcaster
+
+ workflow_service = container.workflow_service()
+ broadcaster = get_status_broadcaster()
+
+ workflow_id = data.get("workflow_id")
+ nodes = data.get("nodes", [])
+ edges = data.get("edges", [])
+ session_id = data.get("session_id", "default")
+
+ logger.debug(f"[Deploy] Received {len(edges)} edges for workflow {workflow_id}")
+ for e in edges:
+ target_handle = e.get('targetHandle')
+ if target_handle and target_handle.startswith('input-') and target_handle != 'input-main':
+ logger.debug(f"[Deploy] Config edge: {e.get('source')} -> {e.get('target')} (handle={target_handle})")
+
+ tool_edges = [e for e in edges if e.get('targetHandle') == 'input-tools']
+ if tool_edges:
+ logger.debug(f"[Deploy] Tool edges found: {len(tool_edges)}")
+ for te in tool_edges:
+ logger.debug(f"[Deploy] Tool edge: source={te.get('source')} -> target={te.get('target')}")
+ else:
+ logger.debug("[Deploy] No input-tools edges found")
+
+ if not nodes:
+ return {"success": False, "error": "No nodes provided"}
+
+ if not workflow_id:
+ return {"success": False, "error": "workflow_id is required for deployment"}
+
+ # Pre-deploy validation gate. Deploy never honors a force-override —
+ # a broken workflow running on a schedule is far worse than a failed
+ # one-shot manual run.
+ from services.workflow_validator import validate_workflow
+ deploy_report = await validate_workflow(
+ nodes=nodes, edges=edges,
+ parameters_by_id=data.get("parameters_by_id"),
+ )
+ if deploy_report["errors"]:
+ return {
+ "success": False,
+ "error": "validation_failed",
+ "report": deploy_report,
+ }
+
+ if workflow_service.is_workflow_deployed(workflow_id):
+ status = workflow_service.get_deployment_status(workflow_id)
+ return {
+ "success": False,
+ "error": f"Workflow {workflow_id} is already deployed. Cancel it first.",
+ "workflow_id": workflow_id,
+ "is_running": True,
+ "run_counter": status.get("run_counter", 0),
+ }
+
+ lock_acquired = await broadcaster.lock_workflow(workflow_id, reason="deployment")
+ if not lock_acquired:
+ lock_info = broadcaster.get_workflow_lock(workflow_id)
+ return {
+ "success": False,
+ "error": f"Workflow {workflow_id} is already locked for {lock_info.get('reason', 'deployment')}",
+ "locked_by": lock_info.get("workflow_id"),
+ "locked_at": lock_info.get("locked_at"),
+ }
+
+ await broadcaster.update_workflow_status(executing=True, current_node=None, progress=0)
+ await broadcaster.update_deployment_status(
+ is_running=True,
+ status="starting",
+ active_runs=0,
+ workflow_id=workflow_id,
+ )
+
+ async def status_callback(node_id: str, status: str, node_data: Optional[Dict] = None):
+ if node_id == "__deployment__":
+ active_runs = node_data.get("active_runs", 0) if node_data else 0
+ await broadcaster.update_deployment_status(
+ is_running=True,
+ status=status,
+ active_runs=active_runs,
+ workflow_id=workflow_id,
+ data=node_data,
+ )
+ else:
+ await broadcaster.update_node_status(node_id, status, node_data, workflow_id=workflow_id)
+ if status == "executing":
+ position = node_data.get("position", 0) if node_data else 0
+ total = node_data.get("total", 1) if node_data else 1
+ progress = int((position / total) * 100) if total > 0 else 0
+ await broadcaster.update_workflow_status(executing=True, current_node=node_id, progress=progress)
+
+ async def run_deployment():
+ try:
+ result = await workflow_service.deploy_workflow(
+ nodes=nodes,
+ edges=edges,
+ session_id=session_id,
+ status_callback=status_callback,
+ workflow_id=workflow_id,
+ )
+
+ if not result.get("success"):
+ logger.error("Deployment setup failed", error=result.get("error"), workflow_id=workflow_id)
+ await broadcaster.update_deployment_status(
+ is_running=False,
+ status="error",
+ active_runs=0,
+ workflow_id=workflow_id,
+ error=result.get("error"),
+ )
+ await broadcaster.unlock_workflow(workflow_id)
+ _deployment_tasks.pop(workflow_id, None)
+ else:
+ await broadcaster.update_deployment_status(
+ is_running=True,
+ status="running",
+ active_runs=0,
+ workflow_id=workflow_id,
+ data={
+ "triggers_setup": result.get("triggers_setup", []),
+ "deployment_id": result.get("deployment_id"),
+ },
+ )
+ logger.info(
+ "[Deployment] Event-driven deployment active",
+ deployment_id=result.get("deployment_id"),
+ workflow_id=workflow_id,
+ triggers=len(result.get("triggers_setup", [])),
+ )
+
+ except Exception as e:
+ logger.error("Deployment task error", workflow_id=workflow_id, error=str(e))
+ await broadcaster.update_deployment_status(
+ is_running=False,
+ status="error",
+ active_runs=0,
+ workflow_id=workflow_id,
+ error=str(e),
+ )
+ await broadcaster.unlock_workflow(workflow_id)
+ _deployment_tasks.pop(workflow_id, None)
+
+ _deployment_tasks[workflow_id] = asyncio.create_task(run_deployment())
+
+ return {
+ "success": True,
+ "message": "Deployment started",
+ "workflow_id": workflow_id,
+ "is_running": True,
+ "locked": True,
+ "timestamp": time.time(),
+ }
+
+
+@ws_handler()
+async def handle_cancel_deployment(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Cancel running deployment for a specific workflow (Temporal/n8n pattern).
+
+ Expects:
+ workflow_id: Workflow to cancel (required).
+
+ Also cancels any active event waiters (trigger nodes) and unlocks the workflow.
+
+ Returns:
+ Cancellation result with iterations completed
+ """
+ global _deployment_tasks
+ from core.container import container
+ from services.status_broadcaster import get_status_broadcaster
+
+ workflow_service = container.workflow_service()
+ broadcaster = get_status_broadcaster()
+
+ workflow_id = data.get("workflow_id")
+
+ if not workflow_id:
+ return {"success": False, "error": "workflow_id is required for cancellation"}
+
+ result = await workflow_service.cancel_deployment(workflow_id)
+
+ cancelled_waiters = 0
+ if result.get("success"):
+ cancelled_waiters = result.get("waiters_cancelled", 0)
+
+ task = _deployment_tasks.pop(workflow_id, None)
+ if task and not task.done():
+ task.cancel()
+ try:
+ await task
+ except asyncio.CancelledError:
+ logger.info("[Deployment] Deployment task cancelled", workflow_id=workflow_id)
+
+ if workflow_id:
+ await broadcaster.unlock_workflow(workflow_id)
+
+ if result.get("success"):
+ for node_id in result.get("cancelled_listener_node_ids", []):
+ await broadcaster.clear_node_status(node_id)
+
+ await broadcaster.update_workflow_status(executing=False, current_node=None, progress=0)
+ await broadcaster.update_deployment_status(
+ is_running=False,
+ status="cancelled",
+ active_runs=0,
+ workflow_id=workflow_id,
+ data={
+ "iterations_completed": result.get("iterations_completed", 0),
+ },
+ )
+
+ return {
+ "success": result.get("success", False),
+ "message": result.get("message", result.get("error")),
+ "workflow_id": workflow_id,
+ "was_running": result.get("was_running", False),
+ "iterations_completed": result.get("iterations_completed", 0),
+ "cancelled_waiters": cancelled_waiters,
+ "unlocked": workflow_id is not None,
+ "timestamp": time.time(),
+ }
+
+
+@ws_handler()
+async def handle_get_deployment_status(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Get current deployment status including workflow lock info."""
+ from core.container import container
+ from services.status_broadcaster import get_status_broadcaster
+
+ workflow_service = container.workflow_service()
+ broadcaster = get_status_broadcaster()
+
+ workflow_id = data.get("workflow_id")
+ status = workflow_service.get_deployment_status(workflow_id)
+
+ return {
+ "is_running": workflow_service.is_deployment_running(workflow_id),
+ "run_counter": status.get("run_counter", 0),
+ "active_runs": status.get("active_runs", 0),
+ "settings": workflow_service.get_deployment_settings(),
+ "workflow_id": workflow_id or status.get("workflow_id"),
+ "deployed_workflows": status.get("deployed_workflows", []),
+ "lock": broadcaster.get_workflow_lock(),
+ "timestamp": time.time(),
+ }
+
+
+@ws_handler()
+async def handle_get_workflow_lock(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Get current workflow lock status."""
+ from services.status_broadcaster import get_status_broadcaster
+
+ broadcaster = get_status_broadcaster()
+
+ return {
+ "lock": broadcaster.get_workflow_lock(),
+ "timestamp": time.time(),
+ }
+
+
+@ws_handler()
+async def handle_update_deployment_settings(
+ data: Dict[str, Any], websocket: WebSocket,
+) -> Dict[str, Any]:
+ """Update deployment settings (can be called during active deployment)."""
+ from core.container import container
+ from services.status_broadcaster import get_status_broadcaster
+
+ workflow_service = container.workflow_service()
+ broadcaster = get_status_broadcaster()
+
+ settings_to_update = {}
+ if "delay_between_runs" in data:
+ settings_to_update["delay_between_runs"] = data["delay_between_runs"]
+ if "stop_on_error" in data:
+ settings_to_update["stop_on_error"] = data["stop_on_error"]
+ if "max_iterations" in data:
+ settings_to_update["max_iterations"] = data["max_iterations"]
+
+ updated_settings = await workflow_service.update_deployment_settings(settings_to_update)
+
+ status = workflow_service.get_deployment_status()
+ await broadcaster.broadcast({
+ "type": "deployment_settings_updated",
+ "settings": updated_settings,
+ "is_running": workflow_service.is_deployment_running(),
+ "run_counter": status.get("run_counter", 0),
+ })
+
+ return {
+ "success": True,
+ "settings": updated_settings,
+ "is_running": workflow_service.is_deployment_running(),
+ "run_counter": status.get("run_counter", 0),
+ "active_runs": status.get("active_runs", 0),
+ "timestamp": time.time(),
+ }
+
+
+WS_HANDLERS: Dict[str, Any] = {
+ "deploy_workflow": handle_deploy_workflow,
+ "cancel_deployment": handle_cancel_deployment,
+ "get_deployment_status": handle_get_deployment_status,
+ "get_workflow_lock": handle_get_workflow_lock,
+ "update_deployment_settings": handle_update_deployment_settings,
+}
+
+
+__all__ = [
+ "WS_HANDLERS",
+ "handle_cancel_deployment",
+ "handle_deploy_workflow",
+ "handle_get_deployment_status",
+ "handle_get_workflow_lock",
+ "handle_update_deployment_settings",
+]