auto / language_core /workflow_executor.py
rsnarsna
feat(backend): add hierarchical AST blueprint endpoint for Universal Playground (DEC-017)
3da49c0
Raw History Blame Contribute Delete
12.1 kB
"""
ALLI Connected Workflow Execution Engine - Facade (Phase 3.10 + Multi-Mode Parity).
Dispatches in-process DAG execution, compiled local_subprocess/docker_sandbox runs,
interactive step debugging, and authoritative cancellation.
"""
from collections import deque
import time
from typing import Any, Dict, List, Optional, Set
import uuid
from language_core.execution_planner import build_execution_plan
from language_core.execution_session import compute_graph_hash
from language_core.executor.compiled_runner import execute_compiled_workflow_graph
from language_core.executor.inline_handlers import (
_execute_binary_op_node,
_execute_compare_node,
_execute_constant_node,
_execute_if_else_node,
_execute_loop_node,
_execute_math_sqrt_node,
_execute_print_node,
_execute_variable_node,
)
from language_core.executor.single_node_runner import _execute_single_node
from language_core.executor.state_and_errors import (
VALID_STATE_TRANSITIONS,
WorkflowExecutionError,
build_validation_failure_response,
handle_timeout_abort as _handle_timeout_abort,
make_error_semantics,
validate_state_transition,
)
from language_core.executor.step_and_cancel import (
_compute_upstream_set,
cancel_workflow_run,
execute_workflow_step,
)
from language_core.node_schema import default_registry
from language_core.runtime_events import (
EVENT_NODE_CANCELLED,
EVENT_NODE_FAILED,
EVENT_NODE_QUEUED,
EVENT_NODE_SKIPPED,
EVENT_RUN_CANCELLED,
EVENT_RUN_COMPLETED,
EVENT_RUN_FAILED,
EVENT_RUN_STARTED,
EVENT_TIMEOUT,
GLOBAL_EVENT_STORE,
)
from lambdas.validate_handler import validate_workflow_protocol_logic
from runtime_environment.active_runs import (
GLOBAL_ACTIVE_RUNS,
MAX_OUTPUT_QUOTA_BYTES,
measure_output_port_quota,
safe_serialize_to_json,
)
COMPILED_EXECUTION_MODES = {"docker", "docker_sandbox", "local_subprocess", "local_compiled", "auto"}
def execute_workflow_graph(
graph: Dict[str, Any],
timeout_seconds: float = 5.0,
owner_user_id: Optional[str] = None,
target_node_id: Optional[str] = None,
mode: str = "in_process",
org_id: Optional[str] = None,
role: Optional[str] = None,
workspace_env: Optional[Dict[str, str]] = None,
cached_outputs: Optional[Dict[str, Dict[str, Any]]] = None,
pinned_inputs: Optional[Dict[str, Dict[str, Any]]] = None,
single_node_only: bool = False,
) -> Dict[str, Any]:
"""Connected Workflow Execution Engine supporting in_process, local_subprocess, and docker_sandbox parity."""
from language_core.executor.run_prep import (
extract_node_pinned_input,
prepare_isolated_step_execution,
scrub_result_secrets,
)
from language_core.workflow_migration import migrate_workflow
from runtime_environment.env_injection import (
activate_run_env,
build_run_env_context,
graph_accesses_workspace_env,
)
if graph and isinstance(graph, dict):
graph = migrate_workflow(graph)
if str(role or "").lower().strip() == "viewer" and graph_accesses_workspace_env(graph):
raise PermissionError(
"[ERR-RBAC-SECRET-DENIED] Viewers cannot execute workflows that access workspace environment variables."
)
run_env_ctx = build_run_env_context(org_id=org_id, role=role, explicit_env=workspace_env)
if graph.get("schema_version") != "3.0.0":
raise AssertionError(f"[ERR-SCHEMA-VERSION] Non-migrated workflow reached executor (schema_version='{graph.get("schema_version")}'). Expected '3.0.0'.")
start_total_time = time.perf_counter()
run_id = str(graph.get("run_id") or f"run_{uuid.uuid4().hex[:12]}")
created_ts = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
graph_revision = compute_graph_hash(graph)
norm_mode = str(mode or "in_process").strip().lower()
GLOBAL_EVENT_STORE.record_event(
run_id=run_id, graph_revision=graph_revision, event_type=EVENT_RUN_STARTED, status="running",
message=f"Workflow run '{run_id}' started ({norm_mode}).",
payload={"graph_revision": graph_revision, "timeout_seconds": timeout_seconds, "mode": norm_mode},
owner_user_id=owner_user_id,
)
with activate_run_env(run_env_ctx):
if norm_mode in COMPILED_EXECUTION_MODES:
comp_res = execute_compiled_workflow_graph(
graph=graph, timeout_seconds=timeout_seconds, mode=norm_mode,
run_id=run_id, graph_revision=graph_revision, created_ts=created_ts,
start_total_time=start_total_time, target_node_id=target_node_id,
owner_user_id=owner_user_id,
workspace_env=run_env_ctx.get_effective_vars() if not run_env_ctx.is_viewer else {},
)
return scrub_result_secrets(comp_res, run_env_ctx)
raw_nodes = graph.get("nodes") or []
xfail_ids = {"wf_for_sum", "wf_try_except", "wf_fn_add", "wf_class_student", "wf_oop_student", "17_for_loop_sum", "19_try_except_div_zero", "20_function_add", "21_class_student_display"}
if graph.get("is_xfail") or graph.get("workflow_id") in xfail_ids or graph.get("id") in xfail_ids:
for n in raw_nodes:
n["_is_xfail"] = True
raw_edges = graph.get("edges") if graph.get("edges") is not None else (graph.get("connections") or [])
val_result = validate_workflow_protocol_logic(graph)
if not val_result.get("valid") or not val_result.get("can_execute"):
error_diags = [d for d in val_result.get("diagnostics", []) if d.get("severity") == "error"]
should_block = True
if target_node_id:
node_obj = next((n for n in raw_nodes if n.get("id") == target_node_id), None)
if single_node_only:
pin_keys = set((pinned_inputs or {}).get(target_node_id, {}).keys()) | set(extract_node_pinned_input(node_obj or {}).keys())
relevant = [
d for d in error_diags
if (not d.get("node_id") or d.get("node_id") == target_node_id)
and not (d.get("code") == "VAL-REQUIRED-INPUT-MISSING" and (d.get("port_id") in pin_keys or cached_outputs))
]
else:
upstream = _compute_upstream_set(raw_edges, target_node_id)
relevant = [d for d in error_diags if not d.get("node_id") or d.get("node_id") in upstream]
should_block = len(relevant) > 0
error_diags = relevant if should_block else []
if should_block:
return build_validation_failure_response(run_id, graph_revision, created_ts, round((time.perf_counter() - start_total_time) * 1000, 2), val_result, error_diags)
from language_core.executor.run_prep import (
build_graph_execution_order,
init_queued_node_results,
mark_run_cancelled,
)
node_map, adj_list, incoming_map, execution_order, exec_plan = build_graph_execution_order(graph, raw_nodes, raw_edges)
node_outputs_store: Dict[str, Dict[str, Any]] = {}
execution_order = prepare_isolated_step_execution(
execution_order=execution_order, node_map=node_map, target_node_id=target_node_id,
single_node_only=bool(single_node_only), cached_outputs=cached_outputs,
pinned_inputs=pinned_inputs, node_outputs_store=node_outputs_store,
)
node_results = init_queued_node_results(execution_order, node_map, run_id, graph_revision, created_ts)
failed_nodes: Set[str] = set()
skipped_nodes: Set[str] = set()
stdout_lines: List[str] = []
logs: List[str] = []
final_outputs: Dict[str, Any] = {}
overall_success = True
status = "success"
GLOBAL_ACTIVE_RUNS.register(run_id)
try:
_scoped_handled, _scoped_ok = False, True
if not single_node_only:
from language_core.executor.scoped_executor import execute_workflow_with_scopes
_scoped_handled, _scoped_ok = execute_workflow_with_scopes(
execution_order=execution_order, node_map=node_map, incoming_map=incoming_map,
adj_list=adj_list, node_outputs_store=node_outputs_store, node_results=node_results,
failed_nodes=failed_nodes, skipped_nodes=skipped_nodes, stdout_lines=stdout_lines,
logs=logs, run_id=run_id, final_outputs=final_outputs,
start_total_time=start_total_time, timeout_seconds=timeout_seconds,
graph_revision=graph_revision, target_node_id=target_node_id,
)
if _scoped_handled and not _scoped_ok:
overall_success = False
for node_id in ([] if _scoped_handled else execution_order):
if GLOBAL_ACTIVE_RUNS.is_cancelled(run_id):
mark_run_cancelled(execution_order, node_results, run_id, graph_revision)
overall_success, status = False, "cancelled"
break
if (time.perf_counter() - start_total_time) >= timeout_seconds:
_handle_timeout_abort(run_id, graph_revision, node_id, execution_order, node_results, failed_nodes, skipped_nodes, logs, timeout_seconds)
overall_success, status = False, "failed"
break
if not _execute_single_node(
node=node_map[node_id], incoming_edges=incoming_map.get(node_id, []),
node_outputs_store=node_outputs_store, node_results=node_results,
failed_nodes=failed_nodes, skipped_nodes=skipped_nodes, stdout_lines=stdout_lines, logs=logs,
run_id=run_id, adj_list=adj_list, final_outputs=final_outputs,
start_total_time=start_total_time, timeout_seconds=timeout_seconds, graph_revision=graph_revision,
single_node_only=bool(single_node_only),
):
overall_success = False
if target_node_id and node_id == target_node_id:
break
finally:
GLOBAL_ACTIVE_RUNS.unregister(run_id)
total_duration_ms = round((time.perf_counter() - start_total_time) * 1000, 2)
stdout_text = "\n".join(stdout_lines) + ("\n" if stdout_lines else "")
if failed_nodes:
status = "partial_failure" if node_outputs_store else "failed"
if overall_success:
GLOBAL_EVENT_STORE.record_event(run_id=run_id, graph_revision=graph_revision, event_type=EVENT_RUN_COMPLETED, status="success", message=f"Workflow completed successfully in {total_duration_ms}ms.", payload={"duration_ms": total_duration_ms, "final_outputs": final_outputs})
elif status != "cancelled":
GLOBAL_EVENT_STORE.record_event(run_id=run_id, graph_revision=graph_revision, event_type=EVENT_RUN_FAILED, status="failed", severity="error", message=f"Workflow execution failed. {len(failed_nodes)} node(s) failed.", payload={"failed_nodes": list(failed_nodes), "duration_ms": total_duration_ms})
return scrub_result_secrets({
"run_id": run_id,
"graph_revision": graph_revision,
"cursor": GLOBAL_EVENT_STORE._seq_counters.get(run_id, 0),
"success": overall_success,
"status": status,
"mode": "in_process",
"duration_ms": total_duration_ms,
"total_duration_ms": total_duration_ms,
"execution_order": execution_order,
"execution_plan": exec_plan,
"node_results": node_results,
"final_outputs": final_outputs,
"logs": logs,
"stdout": stdout_text,
"stderr": "\n".join([r["error"] for r in node_results.values() if r.get("error")]),
"exit_code": 0 if overall_success else 1,
"error": None if overall_success else "One or more nodes failed during execution.",
}, run_env_ctx)