0
0
use std::collections::BTreeMap;
use serde::Deserialize;
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct ObjectMeta {
#[serde(default)]
pub name: String,
#[serde(default)]
pub annotations: BTreeMap<String, String>,
#[serde(default)]
pub resource_version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq)]
pub struct NodeSpec {
#[serde(rename = "podCIDR", default)]
pub pod_cidr: Option<String>,
#[serde(rename = "podCIDRs", default)]
pub pod_cidrs: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq)]
pub struct Node {
#[serde(default)]
pub metadata: ObjectMeta,
#[serde(default)]
pub spec: NodeSpec,
}
impl Node {
pub fn pod_cidr_strings(&self) -> Vec<String> {
if !self.spec.pod_cidrs.is_empty() {
return self.spec.pod_cidrs.clone();
}
self.spec.pod_cidr.iter().cloned().collect()
}
pub fn annotation(&self, key: &str) -> Option<&str> {
self.metadata.annotations.get(key).map(String::as_str)
}
}
#[derive(Clone, Debug, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ListMeta {
#[serde(default)]
pub resource_version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize)]
pub struct NodeList {
#[serde(default)]
pub metadata: ListMeta,
#[serde(default)]
pub items: Vec<Node>,
}
#[derive(Debug, Deserialize)]
pub struct WatchEvent {
#[serde(rename = "type")]
pub kind: String,
pub object: serde_json::Value,
}
#[derive(Clone, Debug, Default)]
pub struct NodeSet {
nodes: BTreeMap<String, Node>,
}
impl NodeSet {
pub fn from_list(list: NodeList) -> NodeSet {
let mut set = NodeSet::default();
for node in list.items {
set.upsert(node);
}
set
}
pub fn upsert(&mut self, node: Node) {
self.nodes.insert(node.metadata.name.clone(), node);
}
pub fn remove(&mut self, name: &str) {
self.nodes.remove(name);
}
pub fn get(&self, name: &str) -> Option<&Node> {
self.nodes.get(name)
}
pub fn to_vec(&self) -> Vec<Node> {
self.nodes.values().cloned().collect()
}
pub fn len(&self) -> usize {
self.nodes.len()
}
pub fn is_empty(&self) -> bool {
self.nodes.is_empty()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_kubectl_node_list_parses_with_pod_cidrs_and_annotations() {
let json = r#"{
"apiVersion": "v1", "kind": "NodeList",
"metadata": {"resourceVersion": "42"},
"items": [
{"metadata": {"name": "a", "resourceVersion": "7",
"annotations": {"socialweb.computer/mesh-endpoint": "ab"}},
"spec": {"podCIDR": "10.42.1.0/24", "podCIDRs": ["10.42.1.0/24", "fd00:42:1::/64"]}},
{"metadata": {"name": "b"}, "spec": {"podCIDR": "10.42.2.0/24"}},
{"metadata": {"name": "c"}, "spec": {}}
]}"#;
let list: NodeList = serde_json::from_str(json).unwrap();
assert_eq!(list.metadata.resource_version.as_deref(), Some("42"));
let set = NodeSet::from_list(list);
assert_eq!(set.len(), 3);
let a = set.get("a").unwrap();
assert_eq!(a.pod_cidr_strings(), vec!["10.42.1.0/24", "fd00:42:1::/64"]);
assert_eq!(a.annotation("socialweb.computer/mesh-endpoint"), Some("ab"));
assert_eq!(
set.get("b").unwrap().pod_cidr_strings(),
vec!["10.42.2.0/24"]
);
assert!(set.get("c").unwrap().pod_cidr_strings().is_empty());
}
#[test]
fn a_watch_event_line_parses() {
let line = r#"{"type":"MODIFIED","object":{"kind":"Node","metadata":{"name":"a"}}}"#;
let event: WatchEvent = serde_json::from_str(line).unwrap();
assert_eq!(event.kind, "MODIFIED");
let node: Node = serde_json::from_value(event.object).unwrap();
assert_eq!(node.metadata.name, "a");
}
}