feat(config): Add conversion of status types to K8s

Signed-off-by: Manish Vachharajani <[email protected]>

Author: mvachhar

Cargo.lock

@@ -15,6 +15,7 @@ tracectl = { workspace = true }
 k8s-intf = { workspace = true }
 
 # external
+chrono = { workspace = true }
 derive_builder = { workspace = true, default-features = false, features = ["default"] }
 ipnet = { workspace = true }
 linkme = { workspace = true }

config/Cargo.toml

@@ -4,6 +4,7 @@
 //! Converter for gateway-schema k8s objects to internal config and status
 
 pub mod config;
+pub mod status;
 
 use thiserror::Error;
 

config/src/converters/k8s/mod.rs

@@ -0,0 +1,212 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Open Network Fabric Authors
+
+use std::collections::BTreeMap;
+
+use chrono::{DateTime, Utc};
+
+use k8s_intf::gateway_agent_crd::{
+    GatewayAgentStatus, GatewayAgentStatusState, GatewayAgentStatusStateFrr,
+    GatewayAgentStatusStatePeerings, GatewayAgentStatusStateVpcs,
+};
+
+use crate::converters::k8s::ToK8sConversionError;
+use crate::internal::status::DataplaneStatus;
+
+pub struct DataplaneStatusForK8sConversion<'a> {
+    pub last_applied_gen: Option<i64>,
+    pub last_applied_time: Option<&'a DateTime<Utc>>,
+    pub last_collected_time: Option<&'a DateTime<Utc>>,
+    pub status: Option<&'a DataplaneStatus>,
+}
+
+impl TryFrom<&DataplaneStatusForK8sConversion<'_>> for GatewayAgentStatus {
+    type Error = ToK8sConversionError;
+
+    fn try_from(status: &DataplaneStatusForK8sConversion<'_>) -> Result<Self, Self::Error> {
+        if status.last_applied_time.is_none() && status.last_applied_gen.is_some() {
+            return Err(ToK8sConversionError::MissingData(
+                "last_applied_gen is set, but last_applied_time is not".to_string(),
+            ));
+        }
+
+        if status.last_collected_time.is_none() && status.status.is_some() {
+            return Err(ToK8sConversionError::MissingData(
+                "status is set, but last_collected_time is not".to_string(),
+            ));
+        }
+
+        let frr_status = status
+            .status
+            .and_then(|status| {
+                status
+                    .frr_status
+                    .as_ref()
+                    .map(GatewayAgentStatusStateFrr::try_from)
+            })
+            .transpose()?;
+
+        let vpcs = status
+            .status
+            .map(|status| {
+                status
+                    .vpc_counters
+                    .iter()
+                    .map(|(k, v)| Ok((k.clone(), GatewayAgentStatusStateVpcs::try_from(v)?)))
+                    .collect::<Result<BTreeMap<_, _>, _>>()
+            })
+            .transpose()?;
+
+        let peerings = status
+            .status
+            .map(|status| {
+                status
+                    .vpc_peering_counters
+                    .iter()
+                    .map(|(k, v)| Ok((k.clone(), GatewayAgentStatusStatePeerings::try_from(v)?)))
+                    .collect::<Result<BTreeMap<_, _>, _>>()
+            })
+            .transpose()?;
+
+        Ok(GatewayAgentStatus {
+            agent_version: None,
+            last_applied_gen: status.last_applied_gen,
+            last_applied_time: status
+                .last_applied_time
+                .map(|lat| lat.to_rfc3339_opts(chrono::SecondsFormat::Nanos, true)),
+            state: status.status.map(|_| GatewayAgentStatusState {
+                frr: frr_status,
+                last_collected_time: status
+                    .last_collected_time
+                    .map(|t| t.to_rfc3339_opts(chrono::SecondsFormat::Nanos, true)),
+                peerings: peerings.filter(|c| !c.is_empty()),
+                vpcs: vpcs.filter(|c| !c.is_empty()),
+            }),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use bolero::generator::*;
+    use bolero::{Driver, TypeGenerator};
+    use chrono::TimeZone;
+
+    use crate::internal::status::DataplaneStatus;
+    use crate::internal::status::contract::LegalValue;
+
+    fn datetime_gen() -> impl ValueGenerator<Output = DateTime<Utc>> {
+        (0..=i64::from(i32::MAX)).map_gen(|ts| Utc.timestamp_opt(ts, 0).unwrap())
+    }
+
+    #[derive(Debug)]
+    struct DataplaneStatusForK8sConversionOwned {
+        status: Option<DataplaneStatus>,
+        last_collected_time: Option<DateTime<Utc>>,
+        last_applied_gen: Option<i64>,
+        last_applied_time: Option<DateTime<Utc>>,
+    }
+
+    impl TypeGenerator for LegalValue<DataplaneStatusForK8sConversionOwned> {
+        fn generate<D: Driver>(d: &mut D) -> Option<Self> {
+            let time_gen = datetime_gen();
+            let last_applied_gen = d.produce()?;
+            let last_applied_time = time_gen.generate(d)?;
+            let status = d
+                .produce::<Option<LegalValue<DataplaneStatus>>>()?
+                .map(|v| v.take());
+            let last_collected_time_raw = time_gen.generate(d)?;
+            let last_collected_time = status.as_ref().map(|_| last_collected_time_raw);
+            Some(LegalValue::new(DataplaneStatusForK8sConversionOwned {
+                status,
+                last_collected_time,
+                last_applied_gen,
+                last_applied_time: last_applied_gen.map(|_| last_applied_time),
+            }))
+        }
+    }
+
+    #[test]
+    fn test_dataplane_status_conversion() {
+        bolero::check!()
+            .with_type::<LegalValue<DataplaneStatusForK8sConversionOwned>>()
+            .for_each(|status_owned| {
+                let status_owned = status_owned.as_ref();
+                let conv_status = DataplaneStatusForK8sConversion {
+                    status: status_owned.status.as_ref(),
+                    last_collected_time: status_owned.last_collected_time.as_ref(),
+                    last_applied_gen: status_owned.last_applied_gen,
+                    last_applied_time: status_owned.last_applied_time.as_ref(),
+                };
+
+                let gateway_agent_status = GatewayAgentStatus::try_from(&conv_status).unwrap();
+
+                assert_eq!(
+                    gateway_agent_status.last_applied_gen,
+                    conv_status.last_applied_gen
+                );
+                assert_eq!(
+                    gateway_agent_status.last_applied_time,
+                    conv_status
+                        .last_applied_time
+                        .map(|lat| lat.to_rfc3339_opts(chrono::SecondsFormat::Nanos, true))
+                );
+                assert_eq!(
+                    gateway_agent_status
+                        .state
+                        .as_ref()
+                        .and_then(|s| s.last_collected_time.clone()),
+                    conv_status
+                        .last_collected_time
+                        .map(|t| t.to_rfc3339_opts(chrono::SecondsFormat::Nanos, true))
+                );
+
+                assert_eq!(
+                    conv_status.status.is_some(),
+                    gateway_agent_status.state.is_some()
+                );
+
+                if let Some(state) = gateway_agent_status.state.as_ref() {
+                    assert!(state.frr.is_some()); // Specifics tested elsewhere
+
+                    match state.vpcs.as_ref() {
+                        Some(vpcs) => {
+                            // Specifics tested elsewhere
+                            assert_eq!(
+                                vpcs.len(),
+                                conv_status
+                                    .status
+                                    .expect("status should not be None")
+                                    .vpc_counters
+                                    .len()
+                            );
+                        }
+                        None => {
+                            assert!(
+                                conv_status.status.is_none()
+                                    || conv_status.status.unwrap().vpc_counters.is_empty()
+                            );
+                        }
+                    }
+
+                    match state.peerings.as_ref() {
+                        // Specifics tested elsewhere
+                        Some(peerings) => assert_eq!(
+                            peerings.len(),
+                            conv_status
+                                .status
+                                .expect("status should not be None")
+                                .vpc_peering_counters
+                                .len()
+                        ),
+                        None => assert!(
+                            conv_status.status.is_none()
+                                || conv_status.status.unwrap().vpc_peering_counters.is_empty()
+                        ),
+                    }
+                }
+            });
+    }
+}

config/src/converters/k8s/status/dataplane_status.rs

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Open Network Fabric Authors
+
+use k8s_intf::gateway_agent_crd::GatewayAgentStatusStateFrr;
+
+use crate::converters::k8s::ToK8sConversionError;
+use crate::internal::status::FrrStatus;
+
+impl TryFrom<&FrrStatus> for GatewayAgentStatusStateFrr {
+    type Error = ToK8sConversionError;
+
+    fn try_from(status: &FrrStatus) -> Result<Self, Self::Error> {
+        Ok(GatewayAgentStatusStateFrr {
+            last_applied_gen: Some(status.applied_config_gen),
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use crate::internal::status::contract::LegalValue;
+
+    #[test]
+    fn test_frr_status_conversion() {
+        bolero::check!()
+            .with_type::<LegalValue<FrrStatus>>()
+            .for_each(|status| {
+                let status = status.as_ref();
+                let k8s_frr_status = GatewayAgentStatusStateFrr::try_from(status)
+                    .expect("Failed to convert frr status");
+
+                assert_eq!(
+                    status.applied_config_gen,
+                    k8s_frr_status
+                        .last_applied_gen
+                        .expect("K8s frr last applied gen not set"),
+                );
+            });
+    }
+}

config/src/converters/k8s/status/frr.rs

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Open Network Fabric Authors
+
+//! Converter for gateway-schema k8s objects from internal status
+
+pub mod dataplane_status;
+pub mod frr;
+pub mod peerings;
+pub mod vpcs;

config/src/converters/k8s/status/mod.rs

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Open Network Fabric Authors
+
+use k8s_intf::gateway_agent_crd::GatewayAgentStatusStatePeerings;
+
+use crate::converters::k8s::ToK8sConversionError;
+use crate::internal::status::VpcPeeringCounters;
+
+impl TryFrom<&VpcPeeringCounters> for GatewayAgentStatusStatePeerings {
+    type Error = ToK8sConversionError;
+
+    fn try_from(counters: &VpcPeeringCounters) -> Result<Self, Self::Error> {
+        Ok(GatewayAgentStatusStatePeerings {
+            b: Some(counters.bytes),
+            d: Some(counters.drops),
+            p: Some(counters.packets),
+            bps: Some(counters.bps),
+            pps: Some(counters.pps),
+        })
+    }
+}

config/src/converters/k8s/status/peerings.rs

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Open Network Fabric Authors
+
+use k8s_intf::gateway_agent_crd::GatewayAgentStatusStateVpcs;
+
+use crate::converters::k8s::ToK8sConversionError;
+use crate::internal::status::VpcCounters;
+
+impl TryFrom<&VpcCounters> for GatewayAgentStatusStateVpcs {
+    type Error = ToK8sConversionError;
+
+    fn try_from(vpc_counters: &VpcCounters) -> Result<Self, Self::Error> {
+        Ok(GatewayAgentStatusStateVpcs {
+            b: Some(vpc_counters.bytes),
+            d: Some(vpc_counters.drops),
+            p: Some(vpc_counters.packets),
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use crate::internal::status::contract::LegalValue;
+
+    #[test]
+    fn test_frr_status_conversion() {
+        bolero::check!()
+            .with_type::<LegalValue<VpcCounters>>()
+            .for_each(|status| {
+                let status = status.as_ref();
+                let k8s_vpc_status = GatewayAgentStatusStateVpcs::try_from(status)
+                    .expect("Failed to convert frr status");
+
+                assert_eq!(status.bytes, k8s_vpc_status.b.expect("K8s vpcs b not set"),);
+                assert_eq!(status.drops, k8s_vpc_status.d.expect("K8s vpcs b not set"),);
+                assert_eq!(
+                    status.packets,
+                    k8s_vpc_status.p.expect("K8s vpcs b not set"),
+                );
+            });
+    }
+}