File size: 12,144 Bytes
2d8ecc2 8628c98 2d8ecc2 8628c98 c89d877 93ccb02 8628c98 93ccb02 8628c98 284800d 8628c98 284800d 8628c98 284800d 8628c98 284800d 8628c98 284800d 8628c98 6272e6f c89d877 8628c98 c89d877 284800d d893281 8628c98 284800d 8628c98 985f8d7 8628c98 284800d 2d8ecc2 8628c98 2d8ecc2 8628c98 284800d 8628c98 2d8ecc2 3da49c0 355ed30 8628c98 355ed30 284800d 8628c98 355ed30 8628c98 2d8ecc2 8628c98 6272e6f 8628c98 6272e6f 8628c98 333b254 8628c98 284800d 8628c98 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 | """
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)
|