#![allow(unused_imports)]
use crate::layer0::vocabulary::{HANDLE_MCARD_RECEIPTS};
use super::*;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExecutionResult {
pub status: String,
pub operator: String,
pub outputs: HashMap<String, String>,
pub input_hashes: HashMap<String, String>,
pub output_hashes: HashMap<String, String>,
pub metrics: HashMap<String, Value>,
pub error: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Verdict {
pub invariant: String,
pub rule: String,
pub passed: bool,
pub description: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VCardReceipt {
pub uri: String,
pub hash: String,
pub payload: Value,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HoareSandwichResult {
pub status: String,
pub action_name: String,
pub outputs: HashMap<String, String>,
pub receipt: Option<VCardReceipt>,
pub precondition_verdicts: Vec<Verdict>,
pub postcondition_verdicts: Vec<Verdict>,
pub rollback_occurred: bool,
pub rollback_time_ms: f64,
pub metrics: HashMap<String, Value>,
pub error: Option<String>,
}
fn single_output(
out_spec_name: Option<&str>,
default_name: &str,
val: Result<String, String>,
) -> Result<HashMap<String, String>, String> {
val.map(|s| {
let mut m = HashMap::new();
m.insert(out_spec_name.unwrap_or(default_name).to_string(), s);
m
})
}
pub struct ActionDispatcher;
impl ActionDispatcher {
pub fn execute(
manifest: &ActionManifest,
input_bindings: &HashMap<String, String>,
) -> ExecutionResult {
Self::execute_with_clock(manifest, input_bindings, crate::layer0::gtime::monotonic_now)
}
pub fn execute_with_clock(
manifest: &ActionManifest,
input_bindings: &HashMap<String, String>,
clock: impl Fn() -> std::time::Instant,
) -> ExecutionResult {
let t_start = clock();
let operator = &manifest.operation.operator;
let params = &manifest.operation.parameters;
let mut input_hashes = HashMap::new();
let mut resolved_inputs = HashMap::new();
for inp in &manifest.inputs {
let val = input_bindings.get(&inp.name)
.or_else(|| inp.uri.as_ref().and_then(|u| input_bindings.get(u)));
if val.is_none() && inp.required {
return ExecutionResult {
status: "failed".to_string(),
operator: operator.to_string(),
outputs: HashMap::new(),
input_hashes,
output_hashes: HashMap::new(),
metrics: HashMap::new(),
error: Some(format!("Required input '{}' could not be resolved", inp.name)),
};
}
if let Some(v) = val {
let h = clm_hash_string(v);
input_hashes.insert(inp.name.clone(), h);
resolved_inputs.insert(inp.name.clone(), v.clone());
}
}
let primary_input = manifest
.inputs
.iter()
.find_map(|inp| resolved_inputs.get(&inp.name))
.cloned()
.unwrap_or_default();
let primary_format = manifest.inputs.first().and_then(|i| i.format.clone()).unwrap_or_else(|| "csv".to_string());
let first_out_name = manifest.outputs.first().map(|o| o.name.as_str());
let mut outputs = HashMap::new();
let mut output_hashes = HashMap::new();
let run_res: Result<HashMap<String, String>, String> = if *operator == BaldwinOperator::Custom {
Ok(HashMap::new())
} else {
use crate::cross_cutting::catalog_ids::{
op_id_for, OP_OPERATOR_DOCUMENT_AUGMENT, OP_OPERATOR_DOCUMENT_EXCLUDE,
OP_OPERATOR_DOCUMENT_INVERT, OP_OPERATOR_DOCUMENT_PORT, OP_OPERATOR_DOCUMENT_SPLIT,
OP_OPERATOR_DOCUMENT_SUBSTITUTE, OP_OPERATOR_STRUCTURED_AUGMENT,
OP_OPERATOR_STRUCTURED_EXCLUDE, OP_OPERATOR_STRUCTURED_INVERT,
OP_OPERATOR_STRUCTURED_PORT, OP_OPERATOR_STRUCTURED_SPLIT,
OP_OPERATOR_STRUCTURED_SUBSTITUTE, OP_OPERATOR_TABULAR_AUGMENT,
OP_OPERATOR_TABULAR_EXCLUDE, OP_OPERATOR_TABULAR_INVERT, OP_OPERATOR_TABULAR_PORT,
OP_OPERATOR_TABULAR_SPLIT, OP_OPERATOR_TABULAR_SUBSTITUTE,
};
let op_id = op_id_for(&format!("operator:{primary_format}:{operator}"))
.or_else(|| op_id_for(&format!("operator:structured:{operator}")));
match op_id {
Some(OP_OPERATOR_TABULAR_SPLIT) => TabularManipulator::split(&primary_input, params),
Some(OP_OPERATOR_TABULAR_SUBSTITUTE) => single_output(first_out_name, "output", TabularManipulator::substitute(&primary_input, params)),
Some(OP_OPERATOR_TABULAR_AUGMENT) => single_output(first_out_name, "augmented", TabularManipulator::augment(&primary_input, params)),
Some(OP_OPERATOR_TABULAR_EXCLUDE) => single_output(first_out_name, "sanitized", TabularManipulator::exclude(&primary_input, params)),
Some(OP_OPERATOR_TABULAR_INVERT) => single_output(first_out_name, "inverted", TabularManipulator::invert(&primary_input, params)),
Some(OP_OPERATOR_TABULAR_PORT) => single_output(first_out_name, "ported", TabularManipulator::port(&primary_input, params)),
Some(OP_OPERATOR_DOCUMENT_SPLIT) => DocumentManipulator::split(&primary_input, params),
Some(OP_OPERATOR_DOCUMENT_SUBSTITUTE) => single_output(first_out_name, "substituted", DocumentManipulator::substitute(&primary_input, params)),
Some(OP_OPERATOR_DOCUMENT_AUGMENT) => single_output(first_out_name, "augmented", DocumentManipulator::augment(&primary_input, params)),
Some(OP_OPERATOR_DOCUMENT_EXCLUDE) => single_output(first_out_name, "pruned", DocumentManipulator::exclude(&primary_input, params)),
Some(OP_OPERATOR_DOCUMENT_INVERT) => single_output(first_out_name, "inverted", DocumentManipulator::invert(&primary_input, params)),
Some(OP_OPERATOR_DOCUMENT_PORT) => single_output(first_out_name, "ported", DocumentManipulator::port(&primary_input, params)),
Some(OP_OPERATOR_STRUCTURED_SPLIT) => StructuredManipulator::split(&primary_input, params),
Some(OP_OPERATOR_STRUCTURED_SUBSTITUTE) => single_output(first_out_name, "substituted", StructuredManipulator::substitute(&primary_input, params)),
Some(OP_OPERATOR_STRUCTURED_AUGMENT) => single_output(first_out_name, "augmented", StructuredManipulator::augment(&primary_input, params)),
Some(OP_OPERATOR_STRUCTURED_EXCLUDE) => single_output(first_out_name, "pruned", StructuredManipulator::exclude(&primary_input, params)),
Some(OP_OPERATOR_STRUCTURED_INVERT) => single_output(first_out_name, "inverted", StructuredManipulator::invert(&primary_input, params)),
Some(OP_OPERATOR_STRUCTURED_PORT) => single_output(first_out_name, "ported", StructuredManipulator::port(&primary_input, params)),
_ => Err(format!("Unsupported Baldwin operator '{operator}' for format '{primary_format}'")),
}
};
match run_res {
Ok(res_map) => {
if manifest.outputs.len() > 1 && res_map.len() > 1 {
for out_spec in &manifest.outputs {
if let Some(val) = res_map.get(&out_spec.name) {
outputs.insert(out_spec.name.clone(), val.clone());
output_hashes.insert(out_spec.name.clone(), clm_hash_string(val));
}
}
} else if let Some(out_spec) = manifest.outputs.first() {
let val = res_map.get(&out_spec.name)
.cloned()
.unwrap_or_else(|| res_map.values().next().cloned().unwrap_or_default());
outputs.insert(out_spec.name.clone(), val.clone());
output_hashes.insert(out_spec.name.clone(), clm_hash_string(&val));
}
let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
let mut metrics = HashMap::new();
metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
metrics.insert("operator".to_string(), json!(operator.to_string()));
metrics.insert("action_name".to_string(), json!(manifest.clm.name));
ExecutionResult {
status: "success".to_string(),
operator: operator.to_string(),
outputs,
input_hashes,
output_hashes,
metrics,
error: None,
}
}
Err(e) => {
let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
let mut metrics = HashMap::new();
metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
ExecutionResult {
status: "failed".to_string(),
operator: operator.to_string(),
outputs: HashMap::new(),
input_hashes,
output_hashes: HashMap::new(),
metrics,
error: Some(e),
}
}
}
}
}
pub fn derive_all_passed(precondition_verdicts: &[Verdict], postcondition_verdicts: &[Verdict]) -> bool {
precondition_verdicts
.iter()
.chain(postcondition_verdicts.iter())
.all(|verdict| verdict.passed)
}
pub struct HoareSandwichEngine;
impl HoareSandwichEngine {
pub fn execute(
manifest: &ActionManifest,
input_bindings: &HashMap<String, String>,
) -> HoareSandwichResult {
Self::execute_with_clock(manifest, input_bindings, crate::layer0::gtime::monotonic_now)
}
pub fn execute_with_clock(
manifest: &ActionManifest,
input_bindings: &HashMap<String, String>,
clock: impl Fn() -> std::time::Instant,
) -> HoareSandwichResult {
let t_start = clock();
let action_manifest_val = manifest.to_canonical_json_value();
let action_hash = compute_canonical_hash(&action_manifest_val);
let mut pre_ctx_map = serde_json::Map::new();
for inp in &manifest.inputs {
if let Some(payload) = input_bindings.get(&inp.name) {
let item_ctx = build_item_context(payload);
pre_ctx_map.insert(inp.name.clone(), item_ctx.clone());
if manifest.inputs.len() == 1 || inp.name == "dataset" {
pre_ctx_map.insert("input".to_string(), item_ctx);
}
}
}
let pre_ctx = Value::Object(pre_ctx_map.clone());
let mut pre_verdicts = Vec::new();
for pre in &manifest.preconditions {
let passed = SafeRuleEvaluator::evaluate(&pre.rule, &pre_ctx);
let verdict = Verdict {
invariant: pre.invariant.clone(),
rule: pre.rule.clone(),
passed,
description: pre.description.clone(),
};
pre_verdicts.push(verdict);
if !passed {
let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
let mut metrics = HashMap::new();
metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
return HoareSandwichResult {
status: "failed".to_string(),
action_name: manifest.clm.name.clone(),
outputs: HashMap::new(),
receipt: None,
precondition_verdicts: pre_verdicts,
postcondition_verdicts: Vec::new(),
rollback_occurred: false,
rollback_time_ms: 0.0,
metrics,
error: Some(format!(
"Precondition '{}' violated: '{}' evaluated to false",
pre.invariant, pre.rule
)),
};
}
}
let exec_result = ActionDispatcher::execute_with_clock(manifest, input_bindings, &clock);
if exec_result.status != "success" {
let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
let mut metrics = HashMap::new();
metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
return HoareSandwichResult {
status: "failed".to_string(),
action_name: manifest.clm.name.clone(),
outputs: HashMap::new(),
receipt: None,
precondition_verdicts: pre_verdicts,
postcondition_verdicts: Vec::new(),
rollback_occurred: false,
rollback_time_ms: 0.0,
metrics,
error: exec_result.error,
};
}
let mut post_ctx_map = pre_ctx_map.clone();
let mut out_map = serde_json::Map::new();
for (name, payload) in &exec_result.outputs {
let item_ctx = build_item_context(payload);
out_map.insert(name.clone(), item_ctx);
}
if exec_result.outputs.len() == 1 {
let first_val = out_map.values().next().cloned().unwrap_or(Value::Null);
if let Value::Object(obj) = first_val {
for (k, v) in obj {
out_map.insert(k, v);
}
}
}
post_ctx_map.insert("output".to_string(), Value::Object(out_map));
let post_ctx = Value::Object(post_ctx_map);
let mut post_verdicts = Vec::new();
for post in &manifest.postconditions {
let passed = SafeRuleEvaluator::evaluate(&post.rule, &post_ctx);
let verdict = Verdict {
invariant: post.invariant.clone(),
rule: post.rule.clone(),
passed,
description: post.description.clone(),
};
post_verdicts.push(verdict);
if !passed {
let rb_start = clock();
let rollback_time_ms = (rb_start.elapsed().as_secs_f64() * 1000.0).max(0.01);
let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
let mut metrics = HashMap::new();
metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
return HoareSandwichResult {
status: "failed".to_string(),
action_name: manifest.clm.name.clone(),
outputs: HashMap::new(),
receipt: None,
precondition_verdicts: pre_verdicts,
postcondition_verdicts: post_verdicts,
rollback_occurred: true,
rollback_time_ms,
metrics,
error: Some(format!(
"Postcondition '{}' violated: '{}' evaluated to false",
post.invariant, post.rule
)),
};
}
}
let pre_verdicts_val = serde_json::to_value(&pre_verdicts).unwrap_or(Value::Null);
let post_verdicts_val = serde_json::to_value(&post_verdicts).unwrap_or(Value::Null);
let pre_digest = compute_canonical_hash(&pre_verdicts_val);
let post_digest = compute_canonical_hash(&post_verdicts_val);
let witness_preimage = format!("{}:{}:{}", pre_digest, action_hash, post_digest);
let witness_hash = clm_hash_string(&witness_preimage);
let receipt_canonical_payload = json!({
"archetype": "VCardReceipt",
"action": {
"name": manifest.clm.name,
"hash": action_hash,
},
"inputs": exec_result.input_hashes,
"outputs": exec_result.output_hashes,
"verification": {
"preconditions": pre_verdicts,
"postconditions": post_verdicts,
"all_passed": derive_all_passed(&pre_verdicts, &post_verdicts),
},
"witness": witness_hash,
});
let receipt_hash = compute_canonical_hash(&receipt_canonical_payload);
let receipt_uri = format!("{HANDLE_MCARD_RECEIPTS}{}", &receipt_hash[..16]);
let receipt = VCardReceipt {
uri: receipt_uri,
hash: receipt_hash,
payload: receipt_canonical_payload,
};
let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
let mut final_metrics = exec_result.metrics.clone();
final_metrics.insert("hoare_total_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
HoareSandwichResult {
status: "success".to_string(),
action_name: manifest.clm.name.clone(),
outputs: exec_result.outputs,
receipt: Some(receipt),
precondition_verdicts: pre_verdicts,
postcondition_verdicts: post_verdicts,
rollback_occurred: false,
rollback_time_ms: 0.0,
metrics: final_metrics,
error: None,
}
}
}