Multi-gateway & Failover

Cargo.toml

@@ -56,7 +56,7 @@ dpdk-sysroot-helper = { path = "./dpdk-sysroot-helper", package = "dataplane-dpd
 dplane-rpc = { git = "https://github.com/githedgehog/dplane-rpc.git", rev = "e8fc33db10e1d00785f2a2b90cbadcad7900f200", features = [] }
 errno = { path = "./errno", package = "dataplane-errno", features = [] }
 flow-info = { path = "./flow-info", package = "dataplane-flow-info", features = [] }
-gateway_config = { git = "https://github.com/githedgehog/gateway-proto", tag = "v0.17.0", features = [] }
+gateway_config = { git = "https://github.com/githedgehog/gateway-proto", tag = "v0.20.0", features = [] }
 gwname = { path = "./gwname", package = "dataplane-gwname", features = [] }
 hardware = { path = "./hardware", package = "dataplane-hardware", features = [] }
 id = { path = "./id", package = "dataplane-id", features = [] }

config/Cargo.toml

@@ -8,6 +8,7 @@ version.workspace = true
 [dependencies]
 # internal
 gateway_config = { workspace = true }
+gwname = { workspace = true }
 hardware = { workspace = true }
 net = { workspace = true }
 lpm = { workspace = true }

config/src/converters/grpc/device.rs

@@ -4,33 +4,14 @@
 use ::gateway_config::config as gateway_config;
 use gateway_config::TracingConfig as ApiTracingConfig;
 
-use crate::internal::device::{
-    DeviceConfig,
-    settings::{DeviceSettings, DpdkPortConfig, KernelPacketConfig, PacketDriver},
-    tracecfg::TracingConfig,
-};
+use crate::internal::device::{DeviceConfig, tracecfg::TracingConfig};
 
 impl TryFrom<&gateway_config::Device> for DeviceConfig {
     type Error = String;
 
     fn try_from(device: &gateway_config::Device) -> Result<Self, Self::Error> {
-        // Convert driver enum
-        let driver = match ::gateway_config::PacketDriver::try_from(device.driver) {
-            Ok(::gateway_config::PacketDriver::Kernel) => {
-                PacketDriver::Kernel(KernelPacketConfig {})
-            }
-            Ok(::gateway_config::PacketDriver::Dpdk) => PacketDriver::DPDK(DpdkPortConfig {}),
-            Err(_) => return Err(format!("Invalid driver value: {}", device.driver)),
-        };
-
-        // Create device settings
-        let mut device_settings = DeviceSettings::new(&device.hostname);
-        device_settings = device_settings.set_packet_driver(driver);
-
-        // Create DeviceConfig with these settings
-        // Note: PortConfig is not yet implemented, so we don't add any ports
-        let mut device_config = DeviceConfig::new(device_settings);
-
+        // Create DeviceConfig
+        let mut device_config = DeviceConfig::new();
         if let Some(tracing) = &device.tracing {
             device_config.set_tracing(TracingConfig::try_from(tracing)?);
         }
@@ -42,21 +23,8 @@ impl TryFrom<&DeviceConfig> for gateway_config::Device {
     type Error = String;
 
     fn try_from(device: &DeviceConfig) -> Result<Self, Self::Error> {
-        let driver = match device.settings.driver {
-            PacketDriver::Kernel(_) => ::gateway_config::PacketDriver::Kernel,
-            PacketDriver::DPDK(_) => ::gateway_config::PacketDriver::Dpdk,
-        };
-
-        // Convert ports if available
-        let ports = Vec::new(); // TODO: Implement port conversion when needed
         let tracing = device.tracing.as_ref().map(ApiTracingConfig::from);
 
-        Ok(gateway_config::Device {
-            driver: driver.into(),
-            hostname: device.settings.hostname.clone(),
-            eal: None, // TODO: Handle EAL configuration when needed
-            ports,
-            tracing,
-        })
+        Ok(gateway_config::Device { tracing })
     }
 }

config/src/converters/grpc/gateway_config.rs

@@ -4,10 +4,13 @@
 use tracing::warn;
 
 use crate::external::ExternalConfigBuilder;
+use crate::external::communities::PriorityCommunityTable;
+use crate::external::gwgroup::{GwGroup, GwGroupTable};
 use crate::external::overlay::Overlay;
 use crate::external::underlay::Underlay;
-use crate::internal::device::{DeviceConfig, settings::DeviceSettings};
+use crate::internal::device::DeviceConfig;
 use crate::{ExternalConfig, GwConfig};
+use gateway_config::config::GatewayGroup;
 
 // Helper Functions
 //--------------------------------------------------------------------------------
@@ -26,7 +29,7 @@ pub fn convert_gateway_config_from_grpc_with_defaults(
         DeviceConfig::try_from(device)?
     } else {
         warn!("Missing device configuration!");
-        DeviceConfig::new(DeviceSettings::new("Unset"))
+        DeviceConfig::new()
     };
 
     // convert underlay or provide a default (empty)
@@ -45,12 +48,29 @@ pub fn convert_gateway_config_from_grpc_with_defaults(
         Overlay::default()
     };
 
+    // convert gateway groups
+    let mut gw_groups = GwGroupTable::new();
+    for g in &grpc_config.gw_groups {
+        let group = GwGroup::try_from(g)?;
+        gw_groups.add_group(group).map_err(|e| e.to_string())?;
+    }
+
+    // convert community table
+    let mut comtable = PriorityCommunityTable::new();
+    for (prio, community) in &grpc_config.communities {
+        comtable
+            .insert(*prio, community)
+            .map_err(|e| e.to_string())?;
+    }
+
     // Create the ExternalConfig using the builder pattern
     let external_config = ExternalConfigBuilder::default()
         .genid(grpc_config.generation)
         .device(device_config)
         .underlay(underlay_config)
         .overlay(overlay_config)
+        .gwgroups(gw_groups)
+        .communities(comtable)
         .build()
         .map_err(|e| format!("Failed to build ExternalConfig: {e}"))?;
 
@@ -82,12 +102,29 @@ impl TryFrom<&gateway_config::GatewayConfig> for ExternalConfig {
             Err("Missing overlay configuration!".to_string())
         }?;
 
+        // convert gateway groups
+        let mut gw_groups = GwGroupTable::new();
+        for g in &grpc_config.gw_groups {
+            let group = GwGroup::try_from(g)?;
+            gw_groups.add_group(group).map_err(|e| e.to_string())?;
+        }
+
+        // convert community table
+        let mut comtable = PriorityCommunityTable::new();
+        for (prio, community) in &grpc_config.communities {
+            comtable
+                .insert(*prio, community)
+                .map_err(|e| e.to_string())?;
+        }
+
         // Create the ExternalConfig using the builder pattern
         let external_config = ExternalConfigBuilder::default()
             .genid(grpc_config.generation)
             .device(device_config)
             .underlay(underlay_config)
             .overlay(overlay_config)
+            .gwgroups(gw_groups)
+            .communities(comtable)
             .build()
             .map_err(|e| format!("Failed to build ExternalConfig: {e}"))?;
 
@@ -108,12 +145,21 @@ impl TryFrom<&ExternalConfig> for gateway_config::GatewayConfig {
         // Convert overlay config
         let overlay = gateway_config::Overlay::try_from(&external_config.overlay)?;
 
+        // Convert gateway groups
+        let gw_groups: Vec<_> = external_config
+            .gwgroups
+            .iter()
+            .map(|g| GatewayGroup::try_from(g).unwrap_or_else(|_| unreachable!()))
+            .collect();
+
         // Create the complete gRPC config
         Ok(gateway_config::GatewayConfig {
             generation: external_config.genid,
             device: Some(device),
             underlay: Some(underlay),
             overlay: Some(overlay),
+            gw_groups,
+            communities: external_config.communities.inner().clone(),
         })
     }
 }

config/src/converters/grpc/gwgroups.rs

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Open Network Fabric Authors
+
+use crate::converters::strings::parse_address;
+use crate::external::gwgroup::{GwGroup, GwGroupMember};
+use gateway_config::config as gateway_config;
+
+impl TryFrom<&gateway_config::GatewayGroupMember> for GwGroupMember {
+    type Error = String;
+
+    fn try_from(value: &gateway_config::GatewayGroupMember) -> Result<Self, Self::Error> {
+        let address = parse_address(&value.ipaddress)
+            .map_err(|e| format!("Bad ip address '{}': {e}", value.ipaddress))?;
+        Ok(GwGroupMember::new(&value.name, value.priority, address))
+    }
+}
+impl TryFrom<&GwGroupMember> for gateway_config::GatewayGroupMember {
+    type Error = String;
+
+    fn try_from(value: &GwGroupMember) -> Result<Self, Self::Error> {
+        Ok(gateway_config::GatewayGroupMember {
+            name: value.name.clone(),
+            priority: value.priority,
+            ipaddress: value.ipaddress.to_string(),
+        })
+    }
+}
+
+impl TryFrom<&gateway_config::GatewayGroup> for GwGroup {
+    type Error = String;
+
+    fn try_from(value: &gateway_config::GatewayGroup) -> Result<Self, Self::Error> {
+        let mut rgroup = GwGroup::new(&value.name);
+        for m in &value.members {
+            let member = GwGroupMember::try_from(m)?;
+            rgroup.add_member(member).map_err(|e| e.to_string())?;
+        }
+        Ok(rgroup)
+    }
+}
+
+impl TryFrom<&GwGroup> for gateway_config::GatewayGroup {
+    type Error = String;
+
+    fn try_from(value: &GwGroup) -> Result<Self, Self::Error> {
+        let members: Vec<_> = value
+            .iter()
+            .map(|m| {
+                gateway_config::GatewayGroupMember::try_from(m).unwrap_or_else(|_| unreachable!())
+            })
+            .collect();
+        Ok(Self {
+            name: value.name().to_owned(),
+            members,
+        })
+    }
+}