vil_validate 0.1.1

VIL validation passes (stub — masa depan: layout/ownership/boundary legality)
Documentation 
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

// =============================================================================
// crates/vil_validate/src/failover.rs
// =============================================================================

use crate::traits::{Diagnostic, ValidationPass, ValidationReport};
use vil_ir::core::WorkflowIR;

/// Validation rule to ensure Failover strategies are legally defined.
/// Checks that:
/// 1. The source process exists.
/// 2. If the target is a process (not a retry strategy), the target process exists.
/// 3. The target process (if applicable) must have at least all the input/output ports of the source process, ensuring interface compatibility.
pub struct FailoverLegalityPass;

impl ValidationPass for FailoverLegalityPass {
    fn name(&self) -> &'static str {
        "FailoverLegalityPass"
    }

    fn run(&self, ir: &WorkflowIR) -> ValidationReport {
        let mut report = ValidationReport::new();

        for failover in &ir.failovers {
            // Source must exist
            let source_proc = match ir.processes.get(&failover.source) {
                Some(p) => p,
                None => {
                    report.push(Diagnostic::error(
                        "FA01",
                        format!(
                            "Failover source process '{}' does not exist in workflow.",
                            failover.source
                        ),
                        failover.source.clone(),
                    ));
                    continue;
                }
            };

            // If target starts with "retry(", it is a retry strategy, skip process checks
            if failover.target.starts_with("retry(") {
                continue;
            }

            // Target must exist
            let target_proc = match ir.processes.get(&failover.target) {
                Some(p) => p,
                None => {
                    report.push(Diagnostic::error(
                        "FA02",
                        format!(
                            "Failover target process '{}' does not exist in workflow.",
                            failover.target
                        ),
                        failover.target.clone(),
                    ));
                    continue;
                }
            };

            // Target must be compatible (must have all ports from source)
            let src_iface = match ir.interfaces.get(&source_proc.interface_name) {
                Some(i) => i,
                None => continue, // Should be caught by another pass
            };

            let mut target_has_compatible_iface = false;

            if let Some(target_iface) = ir.interfaces.get(&target_proc.interface_name) {
                // Check if the target has all the ports
                let mut all_ports_found = true;
                for (_, src_port) in &src_iface.ports {
                    let has_port = target_iface.ports.iter().any(|(_, target_port)| {
                        target_port.name == src_port.name
                            && target_port.direction == src_port.direction
                            && target_port.message_name == src_port.message_name
                    });

                    if !has_port {
                        all_ports_found = false;
                        break;
                    }
                }

                if all_ports_found {
                    target_has_compatible_iface = true;
                }
            }

            if !target_has_compatible_iface {
                report.push(Diagnostic::error(
                    "FA03",
                    format!(
                        "Failover target '{}' is incompatible. It lacks the ports defined in source '{}'s interface '{}'.",
                        failover.target, failover.source, src_iface.name
                    ),
                    failover.target.clone(),
                ));
            }
        }

        report
    }
}