tigrbl_rs_kernel 0.4.1-dev.3

Rust kernel compiler, packed plan model, and optimizer passes for Tigrbl.
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
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

use std::collections::BTreeMap;

use crate::plan::{KernelPlan, PackedPlan};
use tigrbl_rs_spec::{AppSpec, BindingSpec, Exchange, TxScope};

#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct RouteSnapshot {
    pub alias: String,
    pub target: String,
    pub route: Option<String>,
    pub transport: String,
    pub exchange: String,
    pub family: String,
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct OpViewSnapshot {
    pub alias: String,
    pub target: String,
    pub route: Option<String>,
    pub exchange: String,
    pub tx_scope: String,
    pub family: String,
    pub subevents: Vec<String>,
    pub hook_count: usize,
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct DocsSnapshot {
    pub openapi_paths: Vec<String>,
    pub openrpc_methods: Vec<String>,
    pub asyncapi_channels: Vec<String>,
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct KernelParitySnapshot {
    pub app_name: String,
    pub routes: Vec<RouteSnapshot>,
    pub opviews: Vec<OpViewSnapshot>,
    pub phase_plans: BTreeMap<String, Vec<String>>,
    pub packed_plan: PackedPlan,
    pub docs: DocsSnapshot,
}

fn phase_plan(binding: &BindingSpec) -> Vec<String> {
    let mut phases = vec![
        "INGRESS_BEGIN".to_string(),
        "INGRESS_DISPATCH".to_string(),
        "PRE_HANDLER".to_string(),
        "HANDLER".to_string(),
        "POST_HANDLER".to_string(),
    ];
    if binding.op.tx_scope != TxScope::None {
        phases.insert(2, "START_TX".to_string());
        phases.push("TX_COMMIT".to_string());
    }
    if binding.transport == "sse"
        || binding.transport == "ws"
        || binding.transport == "wss"
        || binding.transport == "webtransport"
        || binding.op.exchange != Exchange::RequestResponse
    {
        phases.push("POST_EMIT".to_string());
    }
    phases.push("POST_RESPONSE".to_string());
    phases
}

pub fn build_parity_snapshot(app: &AppSpec, plan: &KernelPlan) -> KernelParitySnapshot {
    let mut routes = Vec::new();
    let mut opviews = Vec::new();
    let mut phase_plans = BTreeMap::new();
    let mut openapi_paths = Vec::new();
    let mut openrpc_methods = Vec::new();
    let mut asyncapi_channels = Vec::new();

    for binding in &app.bindings {
        let route = binding.path.clone().or_else(|| binding.op.route.clone());
        let transport = if binding.transport.is_empty() {
            "rest".to_string()
        } else {
            binding.transport.clone()
        };
        let exchange = binding.op.exchange.as_str().to_string();
        let family = if binding.family.is_empty() {
            if transport == "ws" || transport == "wss" || transport == "webtransport" {
                "bidirectional".to_string()
            } else if exchange == "server_stream" {
                "server_stream".to_string()
            } else {
                "request_response".to_string()
            }
        } else {
            binding.family.clone()
        };

        routes.push(RouteSnapshot {
            alias: binding.alias.clone(),
            target: binding.op.kind.as_str().to_string(),
            route: route.clone(),
            transport: transport.clone(),
            exchange: exchange.clone(),
            family: family.clone(),
        });
        opviews.push(OpViewSnapshot {
            alias: binding.alias.clone(),
            target: binding.op.kind.as_str().to_string(),
            route: route.clone(),
            exchange: exchange.clone(),
            tx_scope: binding.op.tx_scope.as_str().to_string(),
            family,
            subevents: binding.op.subevents.clone(),
            hook_count: binding.hooks.len(),
        });
        phase_plans.insert(binding.alias.clone(), phase_plan(binding));

        if let Some(path) = route.clone() {
            if exchange == "request_response" && (transport == "rest" || transport == "jsonrpc") {
                openapi_paths.push(path.clone());
            }
            if exchange != "request_response" {
                asyncapi_channels.push(path);
            }
        } else if exchange != "request_response" {
            asyncapi_channels.push(binding.alias.clone());
        }
        openrpc_methods.push(binding.alias.clone());
    }

    KernelParitySnapshot {
        app_name: app.name.clone(),
        routes,
        opviews,
        phase_plans,
        packed_plan: plan.packed.clone().unwrap_or_default(),
        docs: DocsSnapshot {
            openapi_paths,
            openrpc_methods,
            asyncapi_channels,
        },
    }
}