phoxal 0.4.0

Phoxal — production-oriented autonomous robot framework (engine, model, typed bus, contracts).
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

use crate::bus::zenoh::TypedSchema;
use serde::{Deserialize, Serialize};

pub const SCHEMA_NAME: &str = "phoxal-api-presence/v1";
pub const SCHEMA_VERSION: u32 = 1;

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct RuntimeId(pub String);

impl RuntimeId {
    pub fn new(id: impl Into<String>) -> Self {
        Self(id.into())
    }
}

impl std::fmt::Display for RuntimeId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(&self.0)
    }
}

#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Readiness {
    NotStarted,
    Initializing,
    Ready,
    Degraded,
    Failed,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Heartbeat {
    pub runtime_id: RuntimeId,
    pub readiness: Readiness,
}

impl TypedSchema for Heartbeat {
    const SCHEMA_NAME: &'static str = "runtime/presence/heartbeat";
    const SCHEMA_VERSION: u32 = 1;
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct RuntimeReadiness {
    pub runtime_id: RuntimeId,
    pub readiness: Readiness,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Summary {
    pub autonomy_ready: bool,
    pub runtimes: Vec<RuntimeReadiness>,
}

impl TypedSchema for Summary {
    const SCHEMA_NAME: &'static str = "runtime/presence/summary";
    const SCHEMA_VERSION: u32 = 1;
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DebugReadiness {
    pub runtimes: Vec<RuntimeReadiness>,
}

impl TypedSchema for DebugReadiness {
    const SCHEMA_NAME: &'static str = "runtime/presence/debug/readiness";
    const SCHEMA_VERSION: u32 = 1;
}

crate::bus::topic_leaf! {
    pubsub heartbeat {
        path: "runtime/presence/heartbeat",
        payload: Heartbeat
    }
}

crate::bus::topic_leaf! {
    pubsub summary {
        path: "runtime/presence/summary",
        payload: Summary
    }
}

pub mod debug {
    use super::*;

    crate::bus::topic_leaf! {
        pubsub readiness {
            path: "runtime/presence/debug/readiness",
            payload: DebugReadiness
        }
    }
}

#[cfg(test)]
mod tests {
    use super::{DebugReadiness, Heartbeat, SCHEMA_NAME, SCHEMA_VERSION, Summary};
    use crate::bus::zenoh::TypedSchema;

    #[test]
    fn schema_contracts_do_not_drift() {
        assert_eq!(Heartbeat::SCHEMA_NAME, "runtime/presence/heartbeat");
        assert_eq!(Heartbeat::SCHEMA_VERSION, 1);
        assert_eq!(Summary::SCHEMA_NAME, "runtime/presence/summary");
        assert_eq!(Summary::SCHEMA_VERSION, 1);
        assert_eq!(
            DebugReadiness::SCHEMA_NAME,
            "runtime/presence/debug/readiness"
        );
        assert_eq!(DebugReadiness::SCHEMA_VERSION, 1);
    }

    #[test]
    fn api_contract_version_is_stable() {
        assert_eq!(SCHEMA_NAME, "phoxal-api-presence/v1");
        assert_eq!(SCHEMA_VERSION, 1);
    }

    #[test]
    fn topic_paths_are_stable() {
        assert_eq!(super::heartbeat::path(), "runtime/presence/heartbeat");
        assert_eq!(super::summary::path(), "runtime/presence/summary");
        assert_eq!(
            super::debug::readiness::path(),
            "runtime/presence/debug/readiness"
        );
    }
}