use std::path::Path;
use crate::layer0::runtime_contract::ClmExitCode;
use super::InternalFn;
use super::runtime;
use super::orchestrator_invariants::{
prepare_context_inputs_and_check_preconditions,
parse_outputs_and_check_postconditions,
check_noether_and_emit_exec_mcard,
};
const POSTCONDITION_VIOLATION: &str = "Postcondition violation";
const POST_GATE_FAILED: &str = "Post-Gate Failed";
const EXIT_CODE: &str = "Exit code";
const INTERNAL_DISPATCH_ERROR: &str = "Internal dispatch error";
fn dispose_fiber(fiber: &crate::fiber::Fiber) -> Result<(), String> {
fiber.dispose().map_err(|errors| format!("fiber '{}' disposal failed: {}", fiber.id, errors.join("; ")))
}
fn fail_fiber(fiber: &crate::fiber::Fiber, reason: String) -> Result<(), String> {
fiber.transition_to(crate::fiber::FiberState::Failed(reason))?;
dispose_fiber(fiber)
}
fn abort(
fiber: &crate::fiber::Fiber,
savepoint: &mut Option<crate::fiber::disposable::TriDbSavepointGuard>,
reason: String,
) -> Result<(), String> {
let aborted = fail_fiber(fiber, reason);
if let Some(sp) = savepoint { let _ = sp.rollback(); }
aborted
}
pub(super) struct PipelineArgs<'a> {
pub ctx: &'a crate::fiber::Context,
pub clm_root: &'a Path,
pub clm_file: &'a str,
pub payload: Option<&'a str>,
pub post_rc: Option<i32>,
pub quiet: bool,
pub clm_data: &'a serde_yaml::Value,
pub concrete_impl: &'a serde_yaml::Value,
pub operation: &'a str,
pub is_rust: bool,
pub registered_func: Option<InternalFn>,
pub module_path_opt: Option<&'a str>,
pub process_type: &'a str,
pub runtime_str: &'a str,
pub skip_conditions: bool,
pub clm_root_str: &'a str,
pub clm_file_str: &'a str,
pub clock_nanos: fn() -> u128,
}
pub(super) fn execute_orchestrator_pipeline(
args: PipelineArgs,
emit_gateway_trace: impl Fn(&str, &str, i32),
) -> Result<i32, crate::evaluator::DispatchError> {
let mut a_mcard_opt = None;
let has_signature = if let Some(spec) = args.clm_data.get("abstract_spec") {
spec.get("signature").is_some()
} else {
args.clm_data.get("signature").is_some()
};
if has_signature {
match crate::parser::parse_a_mcard(args.clm_file_str) {
Ok(a) => a_mcard_opt = Some(a),
Err(e) if !args.quiet => {
eprintln!("[clmEval-rs] ⚠️ Warning: Failed to parse A-MCard spec for validation: {}", e);
}
_ => {}
}
}
let mut context_val = serde_json::json!({ "inputs": serde_json::Value::Null, "outputs": serde_json::Value::Null });
if let Some(ref a_mcard) = a_mcard_opt {
let concrete_args = super::get_clm_args(args.clm_file_str).unwrap_or_default();
match prepare_context_inputs_and_check_preconditions(
a_mcard, &concrete_args, args.payload, args.skip_conditions, args.clm_root_str, args.quiet,
) {
Ok(ctx) => context_val = ctx,
Err(_) => return Ok(ClmExitCode::PreconditionOrBoundaryViolation.code()),
}
}
let isolated_ctx = args.ctx.isolate(&[crate::layer0::vocabulary_env::PILLAR_CONTENT_MEMORY, crate::layer0::vocabulary_env::PILLAR_AGENT_IDENTITIES, crate::layer0::vocabulary_env::PILLAR_EXECUTION_LOG]);
let fiber_id = format!("fiber_{}_{:x}", args.clm_file.replace(['/', '.'], "_"), rand::random::<u16>());
let fiber = isolated_ctx.spawn_fiber(&fiber_id, vec![]);
fiber.transition_to(crate::fiber::FiberState::Active)?;
let sp_token = format!("sp_{}_{:x}", (args.clock_nanos)(), rand::random::<u32>());
let mut tri_sp = crate::fiber::disposable::TriDbSavepointGuard::with_pillars(args.clm_root_str, &sp_token, &[crate::layer0::vocabulary_env::PILLAR_CONTENT_MEMORY, crate::layer0::vocabulary_env::PILLAR_AGENT_IDENTITIES]).ok();
emit_gateway_trace(&format!("execute:{}", args.operation), "exec", 0);
let run_res = if args.is_rust {
match args.registered_func {
Some(f) => f(args.clm_root_str, args.clm_file_str).map_err(Into::into),
None => {
let m_path = args.module_path_opt.unwrap_or("");
if !args.quiet {
eprintln!("[clmEval-rs] ⚡ Sourcing shell test fallback for unregistered module: {}", m_path);
}
runtime::run_fallback_internal_reference(args.clm_root_str, args.clm_file_str, m_path, args.quiet)
.map_err(Into::into)
}
}
} else {
runtime::evaluate_non_rust_runtime(args.clm_root, args.clm_file, args.process_type, args.runtime_str, args.concrete_impl, args.payload, args.post_rc, args.quiet, args.clock_nanos)
};
match run_res {
Ok((exit_code, output)) => {
let nested_exec = crate::cross_cutting::context::CLMContext::get_scoped_or_env(crate::layer0::vocabulary_env::ENV_CLM_NESTED_EXEC).unwrap_or_default() == "1";
let is_user_script = !args.is_rust && !args.operation.starts_with("test_");
if !output.is_empty() && (!args.quiet || nested_exec || is_user_script) {
print!("{}", output);
}
if exit_code == 0 {
if let Some(ref a_mcard) = a_mcard_opt {
if parse_outputs_and_check_postconditions(
a_mcard, &output, &mut context_val, args.skip_conditions, args.clm_root_str, args.quiet,
).is_err() {
abort(&fiber, &mut tri_sp, POSTCONDITION_VIOLATION.to_string())?;
return Ok(ClmExitCode::PostconditionOrCycleViolation.code());
}
}
check_noether_and_emit_exec_mcard(args.operation, &output, args.clm_data, args.clm_root_str, args.quiet);
}
if !args.skip_conditions {
emit_gateway_trace("validate_postcondition", "post", exit_code);
match crate::evaluator::compose::compose_conditions_dispatch(args.clm_root, args.clm_file, "post", exit_code, args.quiet) {
Ok(0) => {}
Ok(rc) => {
eprintln!("CRITICAL: Post-Gate Failed.");
abort(&fiber, &mut tri_sp, POST_GATE_FAILED.to_string())?;
return Ok(rc);
}
Err(e @ crate::evaluator::DispatchError::SovereignSubprocessForbidden(_)) => {
abort(&fiber, &mut tri_sp, format!("{POST_GATE_FAILED}: {e}")).map_err(|refused| crate::evaluator::DispatchError::Other(format!("{e}; {refused}")))?;
return Err(e);
}
Err(e) => {
eprintln!("CRITICAL: Post-Gate Failed: {}", e);
abort(&fiber, &mut tri_sp, format!("{POST_GATE_FAILED}: {e}"))?;
return Ok(ClmExitCode::PostconditionOrCycleViolation.code());
}
}
}
if let Some(ref mut sp) = tri_sp {
if exit_code == 0 { let _ = sp.commit(); } else { let _ = sp.rollback(); }
}
if exit_code == 0 {
dispose_fiber(&fiber)?;
} else {
fail_fiber(&fiber, format!("{EXIT_CODE} {exit_code}"))?;
}
emit_gateway_trace("vcard_seal", "seal", exit_code);
Ok(exit_code)
}
Err(e @ crate::evaluator::DispatchError::SovereignSubprocessForbidden(_)) => {
abort(&fiber, &mut tri_sp, format!("{INTERNAL_DISPATCH_ERROR}: {e}")).map_err(|refused| crate::evaluator::DispatchError::Other(format!("{e}; {refused}")))?;
Err(e)
}
Err(e) => {
eprintln!("[clmEval-rs] ❌ {INTERNAL_DISPATCH_ERROR}: {}", e);
abort(&fiber, &mut tri_sp, format!("{INTERNAL_DISPATCH_ERROR}: {e}"))?;
Ok(ClmExitCode::GeneralError.code())
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::fiber::{Fiber, FiberState};
#[test]
fn fail_fiber_records_the_reason_then_disposes() {
let fiber = Fiber::new("pipeline", vec![]);
assert_eq!(fail_fiber(&fiber, format!("{EXIT_CODE} 3")), Ok(()));
assert_eq!(fiber.get_state(), FiberState::Disposed);
}
#[test]
fn a_fiber_that_refuses_the_abort_fails_the_pipeline() {
let fiber = Fiber::new("pipeline", vec![]);
fiber.dispose().unwrap();
let refused = abort(&fiber, &mut None, POST_GATE_FAILED.to_string()).unwrap_err();
assert!(refused.starts_with("illegal fiber transition disposed -> failed"), "{refused}");
let refused = fail_fiber(&fiber, POSTCONDITION_VIOLATION.to_string()).unwrap_err();
assert!(refused.starts_with("illegal fiber transition disposed -> failed"), "{refused}");
}
#[test]
fn a_failing_disposer_fails_the_pipeline() {
let disposed = Fiber::new("pipeline", vec![]);
disposed.register_disposable(|| Err("handle leaked".to_string()));
assert_eq!(dispose_fiber(&disposed), Err("fiber 'pipeline' disposal failed: handle leaked".to_string()));
let aborted = Fiber::new("pipeline", vec![]);
aborted.register_disposable(|| Err("handle leaked".to_string()));
let reason = format!("{INTERNAL_DISPATCH_ERROR}: boom");
assert_eq!(abort(&aborted, &mut None, reason), Err("fiber 'pipeline' disposal failed: handle leaked".to_string()));
}
}