Skip to main content

clm_rust_core/layer1/
action_sandwich.rs

1#![allow(unused_imports)]
2use crate::layer0::vocabulary::{HANDLE_MCARD_RECEIPTS};
3use super::*;
4
5#[derive(Debug, Clone, Serialize, Deserialize)]
6pub struct ExecutionResult {
7    pub status: String,
8    pub operator: String,
9    pub outputs: HashMap<String, String>,
10    pub input_hashes: HashMap<String, String>,
11    pub output_hashes: HashMap<String, String>,
12    pub metrics: HashMap<String, Value>,
13    pub error: Option<String>,
14}
15
16#[derive(Debug, Clone, Serialize, Deserialize)]
17pub struct Verdict {
18    pub invariant: String,
19    pub rule: String,
20    pub passed: bool,
21    pub description: Option<String>,
22}
23
24#[derive(Debug, Clone, Serialize, Deserialize)]
25pub struct VCardReceipt {
26    pub uri: String,
27    pub hash: String,
28    pub payload: Value,
29}
30
31#[derive(Debug, Clone, Serialize, Deserialize)]
32pub struct HoareSandwichResult {
33    pub status: String,
34    pub action_name: String,
35    pub outputs: HashMap<String, String>,
36    pub receipt: Option<VCardReceipt>,
37    pub precondition_verdicts: Vec<Verdict>,
38    pub postcondition_verdicts: Vec<Verdict>,
39    pub rollback_occurred: bool,
40    pub rollback_time_ms: f64,
41    pub metrics: HashMap<String, Value>,
42    pub error: Option<String>,
43}
44
45fn single_output(
46    out_spec_name: Option<&str>,
47    default_name: &str,
48    val: Result<String, String>,
49) -> Result<HashMap<String, String>, String> {
50    val.map(|s| {
51        let mut m = HashMap::new();
52        m.insert(out_spec_name.unwrap_or(default_name).to_string(), s);
53        m
54    })
55}
56
57pub struct ActionDispatcher;
58
59impl ActionDispatcher {
60    pub fn execute(
61        manifest: &ActionManifest,
62        input_bindings: &HashMap<String, String>,
63    ) -> ExecutionResult {
64        Self::execute_with_clock(manifest, input_bindings, crate::layer0::gtime::monotonic_now)
65    }
66
67    pub fn execute_with_clock(
68        manifest: &ActionManifest,
69        input_bindings: &HashMap<String, String>,
70        clock: impl Fn() -> std::time::Instant,
71    ) -> ExecutionResult {
72        let t_start = clock();
73        let operator = &manifest.operation.operator;
74        let params = &manifest.operation.parameters;
75
76        let mut input_hashes = HashMap::new();
77        let mut resolved_inputs = HashMap::new();
78
79        for inp in &manifest.inputs {
80            let val = input_bindings.get(&inp.name)
81                .or_else(|| inp.uri.as_ref().and_then(|u| input_bindings.get(u)));
82
83            if val.is_none() && inp.required {
84                return ExecutionResult {
85                    status: "failed".to_string(),
86                    operator: operator.to_string(),
87                    outputs: HashMap::new(),
88                    input_hashes,
89                    output_hashes: HashMap::new(),
90                    metrics: HashMap::new(),
91                    error: Some(format!("Required input '{}' could not be resolved", inp.name)),
92                };
93            }
94
95            if let Some(v) = val {
96                let h = clm_hash_string(v);
97                input_hashes.insert(inp.name.clone(), h);
98                resolved_inputs.insert(inp.name.clone(), v.clone());
99            }
100        }
101
102        let primary_input = manifest
103            .inputs
104            .iter()
105            .find_map(|inp| resolved_inputs.get(&inp.name))
106            .cloned()
107            .unwrap_or_default();
108        let primary_format = manifest.inputs.first().and_then(|i| i.format.clone()).unwrap_or_else(|| "csv".to_string());
109        let first_out_name = manifest.outputs.first().map(|o| o.name.as_str());
110
111        let mut outputs = HashMap::new();
112        let mut output_hashes = HashMap::new();
113
114        let run_res: Result<HashMap<String, String>, String> = if *operator == BaldwinOperator::Custom {
115            Ok(HashMap::new())
116        } else {
117            use crate::cross_cutting::catalog_ids::{
118                op_id_for, OP_OPERATOR_DOCUMENT_AUGMENT, OP_OPERATOR_DOCUMENT_EXCLUDE,
119                OP_OPERATOR_DOCUMENT_INVERT, OP_OPERATOR_DOCUMENT_PORT, OP_OPERATOR_DOCUMENT_SPLIT,
120                OP_OPERATOR_DOCUMENT_SUBSTITUTE, OP_OPERATOR_STRUCTURED_AUGMENT,
121                OP_OPERATOR_STRUCTURED_EXCLUDE, OP_OPERATOR_STRUCTURED_INVERT,
122                OP_OPERATOR_STRUCTURED_PORT, OP_OPERATOR_STRUCTURED_SPLIT,
123                OP_OPERATOR_STRUCTURED_SUBSTITUTE, OP_OPERATOR_TABULAR_AUGMENT,
124                OP_OPERATOR_TABULAR_EXCLUDE, OP_OPERATOR_TABULAR_INVERT, OP_OPERATOR_TABULAR_PORT,
125                OP_OPERATOR_TABULAR_SPLIT, OP_OPERATOR_TABULAR_SUBSTITUTE,
126            };
127            let op_id = op_id_for(&format!("operator:{primary_format}:{operator}"))
128                .or_else(|| op_id_for(&format!("operator:structured:{operator}")));
129            match op_id {
130                Some(OP_OPERATOR_TABULAR_SPLIT) => TabularManipulator::split(&primary_input, params),
131                Some(OP_OPERATOR_TABULAR_SUBSTITUTE) => single_output(first_out_name, "output", TabularManipulator::substitute(&primary_input, params)),
132                Some(OP_OPERATOR_TABULAR_AUGMENT) => single_output(first_out_name, "augmented", TabularManipulator::augment(&primary_input, params)),
133                Some(OP_OPERATOR_TABULAR_EXCLUDE) => single_output(first_out_name, "sanitized", TabularManipulator::exclude(&primary_input, params)),
134                Some(OP_OPERATOR_TABULAR_INVERT) => single_output(first_out_name, "inverted", TabularManipulator::invert(&primary_input, params)),
135                Some(OP_OPERATOR_TABULAR_PORT) => single_output(first_out_name, "ported", TabularManipulator::port(&primary_input, params)),
136                Some(OP_OPERATOR_DOCUMENT_SPLIT) => DocumentManipulator::split(&primary_input, params),
137                Some(OP_OPERATOR_DOCUMENT_SUBSTITUTE) => single_output(first_out_name, "substituted", DocumentManipulator::substitute(&primary_input, params)),
138                Some(OP_OPERATOR_DOCUMENT_AUGMENT) => single_output(first_out_name, "augmented", DocumentManipulator::augment(&primary_input, params)),
139                Some(OP_OPERATOR_DOCUMENT_EXCLUDE) => single_output(first_out_name, "pruned", DocumentManipulator::exclude(&primary_input, params)),
140                Some(OP_OPERATOR_DOCUMENT_INVERT) => single_output(first_out_name, "inverted", DocumentManipulator::invert(&primary_input, params)),
141                Some(OP_OPERATOR_DOCUMENT_PORT) => single_output(first_out_name, "ported", DocumentManipulator::port(&primary_input, params)),
142                Some(OP_OPERATOR_STRUCTURED_SPLIT) => StructuredManipulator::split(&primary_input, params),
143                Some(OP_OPERATOR_STRUCTURED_SUBSTITUTE) => single_output(first_out_name, "substituted", StructuredManipulator::substitute(&primary_input, params)),
144                Some(OP_OPERATOR_STRUCTURED_AUGMENT) => single_output(first_out_name, "augmented", StructuredManipulator::augment(&primary_input, params)),
145                Some(OP_OPERATOR_STRUCTURED_EXCLUDE) => single_output(first_out_name, "pruned", StructuredManipulator::exclude(&primary_input, params)),
146                Some(OP_OPERATOR_STRUCTURED_INVERT) => single_output(first_out_name, "inverted", StructuredManipulator::invert(&primary_input, params)),
147                Some(OP_OPERATOR_STRUCTURED_PORT) => single_output(first_out_name, "ported", StructuredManipulator::port(&primary_input, params)),
148                _ => Err(format!("Unsupported Baldwin operator '{operator}' for format '{primary_format}'")),
149            }
150        };
151
152        match run_res {
153            Ok(res_map) => {
154                // Map to declared action outputs
155                if manifest.outputs.len() > 1 && res_map.len() > 1 {
156                    for out_spec in &manifest.outputs {
157                        if let Some(val) = res_map.get(&out_spec.name) {
158                            outputs.insert(out_spec.name.clone(), val.clone());
159                            output_hashes.insert(out_spec.name.clone(), clm_hash_string(val));
160                        }
161                    }
162                } else if let Some(out_spec) = manifest.outputs.first() {
163                    let val = res_map.get(&out_spec.name)
164                        .cloned()
165                        .unwrap_or_else(|| res_map.values().next().cloned().unwrap_or_default());
166                    outputs.insert(out_spec.name.clone(), val.clone());
167                    output_hashes.insert(out_spec.name.clone(), clm_hash_string(&val));
168                }
169
170                let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
171                let mut metrics = HashMap::new();
172                metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
173                metrics.insert("operator".to_string(), json!(operator.to_string()));
174                metrics.insert("action_name".to_string(), json!(manifest.clm.name));
175
176                ExecutionResult {
177                    status: "success".to_string(),
178                    operator: operator.to_string(),
179                    outputs,
180                    input_hashes,
181                    output_hashes,
182                    metrics,
183                    error: None,
184                }
185            }
186            Err(e) => {
187                let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
188                let mut metrics = HashMap::new();
189                metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
190                ExecutionResult {
191                    status: "failed".to_string(),
192                    operator: operator.to_string(),
193                    outputs: HashMap::new(),
194                    input_hashes,
195                    output_hashes: HashMap::new(),
196                    metrics,
197                    error: Some(e),
198                }
199            }
200        }
201    }
202}
203
204/// Conjunction of every recorded precondition and postcondition verdict.
205///
206/// This is the value a `VCardReceipt` records as `verification.all_passed`.
207/// The conjunction over an empty list is true.
208pub fn derive_all_passed(precondition_verdicts: &[Verdict], postcondition_verdicts: &[Verdict]) -> bool {
209    precondition_verdicts
210        .iter()
211        .chain(postcondition_verdicts.iter())
212        .all(|verdict| verdict.passed)
213}
214
215pub struct HoareSandwichEngine;
216
217impl HoareSandwichEngine {
218    pub fn execute(
219        manifest: &ActionManifest,
220        input_bindings: &HashMap<String, String>,
221    ) -> HoareSandwichResult {
222        Self::execute_with_clock(manifest, input_bindings, crate::layer0::gtime::monotonic_now)
223    }
224
225    pub fn execute_with_clock(
226        manifest: &ActionManifest,
227        input_bindings: &HashMap<String, String>,
228        clock: impl Fn() -> std::time::Instant,
229    ) -> HoareSandwichResult {
230        let t_start = clock();
231        let action_manifest_val = manifest.to_canonical_json_value();
232        let action_hash = compute_canonical_hash(&action_manifest_val);
233
234        // 1. Build Precondition Context
235        let mut pre_ctx_map = serde_json::Map::new();
236        for inp in &manifest.inputs {
237            if let Some(payload) = input_bindings.get(&inp.name) {
238                let item_ctx = build_item_context(payload);
239                pre_ctx_map.insert(inp.name.clone(), item_ctx.clone());
240                if manifest.inputs.len() == 1 || inp.name == "dataset" {
241                    pre_ctx_map.insert("input".to_string(), item_ctx);
242                }
243            }
244        }
245        let pre_ctx = Value::Object(pre_ctx_map.clone());
246
247        // 2. Evaluate Preconditions (V_pre Gate)
248        let mut pre_verdicts = Vec::new();
249        for pre in &manifest.preconditions {
250            let passed = SafeRuleEvaluator::evaluate(&pre.rule, &pre_ctx);
251            let verdict = Verdict {
252                invariant: pre.invariant.clone(),
253                rule: pre.rule.clone(),
254                passed,
255                description: pre.description.clone(),
256            };
257            pre_verdicts.push(verdict);
258
259            if !passed {
260                let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
261                let mut metrics = HashMap::new();
262                metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
263                return HoareSandwichResult {
264                    status: "failed".to_string(),
265                    action_name: manifest.clm.name.clone(),
266                    outputs: HashMap::new(),
267                    receipt: None,
268                    precondition_verdicts: pre_verdicts,
269                    postcondition_verdicts: Vec::new(),
270                    rollback_occurred: false,
271                    rollback_time_ms: 0.0,
272                    metrics,
273                    error: Some(format!(
274                        "Precondition '{}' violated: '{}' evaluated to false",
275                        pre.invariant, pre.rule
276                    )),
277                };
278            }
279        }
280
281        // 3. Execute Action
282        let exec_result = ActionDispatcher::execute_with_clock(manifest, input_bindings, &clock);
283        if exec_result.status != "success" {
284            let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
285            let mut metrics = HashMap::new();
286            metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
287            return HoareSandwichResult {
288                status: "failed".to_string(),
289                action_name: manifest.clm.name.clone(),
290                outputs: HashMap::new(),
291                receipt: None,
292                precondition_verdicts: pre_verdicts,
293                postcondition_verdicts: Vec::new(),
294                rollback_occurred: false,
295                rollback_time_ms: 0.0,
296                metrics,
297                error: exec_result.error,
298            };
299        }
300
301        // 4. Build Postcondition Context
302        let mut post_ctx_map = pre_ctx_map.clone();
303        let mut out_map = serde_json::Map::new();
304        for (name, payload) in &exec_result.outputs {
305            let item_ctx = build_item_context(payload);
306            out_map.insert(name.clone(), item_ctx);
307        }
308        if exec_result.outputs.len() == 1 {
309            let first_val = out_map.values().next().cloned().unwrap_or(Value::Null);
310            if let Value::Object(obj) = first_val {
311                for (k, v) in obj {
312                    out_map.insert(k, v);
313                }
314            }
315        }
316        post_ctx_map.insert("output".to_string(), Value::Object(out_map));
317        let post_ctx = Value::Object(post_ctx_map);
318
319        // 5. Evaluate Postconditions (V_post Witness)
320        let mut post_verdicts = Vec::new();
321        for post in &manifest.postconditions {
322            let passed = SafeRuleEvaluator::evaluate(&post.rule, &post_ctx);
323            let verdict = Verdict {
324                invariant: post.invariant.clone(),
325                rule: post.rule.clone(),
326                passed,
327                description: post.description.clone(),
328            };
329            post_verdicts.push(verdict);
330
331            if !passed {
332                let rb_start = clock();
333                // Rollback simulates atomic rollback
334                let rollback_time_ms = (rb_start.elapsed().as_secs_f64() * 1000.0).max(0.01);
335                let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
336                let mut metrics = HashMap::new();
337                metrics.insert("wall_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
338                return HoareSandwichResult {
339                    status: "failed".to_string(),
340                    action_name: manifest.clm.name.clone(),
341                    outputs: HashMap::new(),
342                    receipt: None,
343                    precondition_verdicts: pre_verdicts,
344                    postcondition_verdicts: post_verdicts,
345                    rollback_occurred: true,
346                    rollback_time_ms,
347                    metrics,
348                    error: Some(format!(
349                        "Postcondition '{}' violated: '{}' evaluated to false",
350                        post.invariant, post.rule
351                    )),
352                };
353            }
354        }
355
356        // 6. Generate Deterministic VCardReceipt
357        let pre_verdicts_val = serde_json::to_value(&pre_verdicts).unwrap_or(Value::Null);
358        let post_verdicts_val = serde_json::to_value(&post_verdicts).unwrap_or(Value::Null);
359
360        let pre_digest = compute_canonical_hash(&pre_verdicts_val);
361        let post_digest = compute_canonical_hash(&post_verdicts_val);
362        let witness_preimage = format!("{}:{}:{}", pre_digest, action_hash, post_digest);
363        let witness_hash = clm_hash_string(&witness_preimage);
364
365        let receipt_canonical_payload = json!({
366            "archetype": "VCardReceipt",
367            "action": {
368                "name": manifest.clm.name,
369                "hash": action_hash,
370            },
371            "inputs": exec_result.input_hashes,
372            "outputs": exec_result.output_hashes,
373            "verification": {
374                "preconditions": pre_verdicts,
375                "postconditions": post_verdicts,
376                "all_passed": derive_all_passed(&pre_verdicts, &post_verdicts),
377            },
378            "witness": witness_hash,
379        });
380
381        let receipt_hash = compute_canonical_hash(&receipt_canonical_payload);
382        let receipt_uri = format!("{HANDLE_MCARD_RECEIPTS}{}", &receipt_hash[..16]);
383
384        let receipt = VCardReceipt {
385            uri: receipt_uri,
386            hash: receipt_hash,
387            payload: receipt_canonical_payload,
388        };
389
390        let elapsed_ms = t_start.elapsed().as_secs_f64() * 1000.0;
391        let mut final_metrics = exec_result.metrics.clone();
392        final_metrics.insert("hoare_total_time_ms".to_string(), json!((elapsed_ms * 1000.0).round() / 1000.0));
393
394        HoareSandwichResult {
395            status: "success".to_string(),
396            action_name: manifest.clm.name.clone(),
397            outputs: exec_result.outputs,
398            receipt: Some(receipt),
399            precondition_verdicts: pre_verdicts,
400            postcondition_verdicts: post_verdicts,
401            rollback_occurred: false,
402            rollback_time_ms: 0.0,
403            metrics: final_metrics,
404            error: None,
405        }
406    }
407}
408