feat(config): unify address conversions

Some configuration objects related to addresses contain a mask
length which is unnecessary. Add methods to attempt to convert
those anyway, ignoring the mask.

Signed-off-by: Fredi Raspall <[email protected]>

Author: Fredi-raspall

config/src/converters/grpc/gwgroups.rs

@@ -1,18 +1,17 @@
 // 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;
-use std::net::IpAddr;
-use std::str::FromStr;
 
 impl TryFrom<&gateway_config::GatewayGroupMember> for GwGroupMember {
     type Error = String;
 
     fn try_from(value: &gateway_config::GatewayGroupMember) -> Result<Self, Self::Error> {
-        let ipaddress = IpAddr::from_str(&value.ipaddress)
-            .map_err(|e| format!("Bad ip address '{}': {e}", &value.ipaddress))?;
-        Ok(GwGroupMember::new(&value.name, value.priority, ipaddress))
+        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 {

config/src/converters/k8s/config/gwgroups.rs

@@ -2,8 +2,8 @@
 // Copyright Open Network Fabric Authors
 
 use crate::converters::k8s::FromK8sConversionError;
+use crate::converters::strings::parse_address;
 use k8s_intf::gateway_agent_crd::{GatewayAgentGroupsMembers, GatewayAgentSpec};
-use std::net::IpAddr;
 
 use crate::external::gwgroup::{GwGroup, GwGroupMember, GwGroupTable};
 
@@ -22,13 +22,11 @@ impl TryFrom<&GatewayAgentGroupsMembers> for GwGroupMember {
             .try_into()
             .map_err(|e| Self::Error::ParseError(format!("Bad priority value: {e}")))?;
 
-        let ipaddress = value.vtep_ip.as_ref().ok_or_else(|| {
+        let address = value.vtep_ip.as_ref().ok_or_else(|| {
             Self::Error::MissingData("Gateway group member ip address".to_string())
         })?;
-
-        let ipaddress = ipaddress
-            .parse::<IpAddr>()
-            .map_err(|e| Self::Error::ParseError(format!("Invalid ip address {ipaddress}: {e}")))?;
+        let ipaddress = parse_address(address)
+            .map_err(|e| Self::Error::ParseError(format!("Invalid ip address {address}: {e}")))?;
 
         Ok(Self {
             name: name.clone(),

config/src/converters/k8s/config/underlay.rs

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: Apache-2.0
 // Copyright Open Network Fabric Authors
 
+use crate::converters::strings::parse_address_v4;
 use std::net::IpAddr;
 
-use ipnet::Ipv4Net;
 use k8s_intf::gateway_agent_crd::GatewayAgentGateway;
 use lpm::prefix::{Prefix, PrefixString};
 use net::eth::mac::SourceMac;
@@ -98,21 +98,17 @@ fn add_bgp_config(
             "Gateway protocol IP not specified".to_string(),
         ))?;
 
-    let router_id = protocol_ip
-        .parse::<Ipv4Net>()
-        .map_err(|e| {
-            FromK8sConversionError::ParseError(format!(
-                "Invalid IPv4 protocol IP {protocol_ip}: {e}"
-            ))
-        })?
-        .addr();
+    let router_id = parse_address_v4(protocol_ip).map_err(|e| {
+        FromK8sConversionError::ParseError(format!("Invalid IPv4 protocol IP {protocol_ip}: {e}"))
+    })?;
 
     let vtep_ip_raw = gateway
         .vtep_ip
         .as_ref()
         .ok_or(FromK8sConversionError::MissingData(
             "Gateway VTEP IP not specified".to_string(),
         ))?;
+
     let vtep_prefix = Prefix::try_from(PrefixString(vtep_ip_raw)).map_err(|e| {
         FromK8sConversionError::ParseError(format!("Invalid VTEP IP {vtep_ip_raw}: {e}"))
     })?;

config/src/converters/mod.rs

@@ -5,3 +5,4 @@
 
 pub mod grpc;
 pub mod k8s;
+pub mod strings;

config/src/converters/strings.rs

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Open Network Fabric Authors
+
+//! Commonly used conversions from strings
+
+use ipnet::{AddrParseError, IpNet, Ipv4Net};
+use std::net::{IpAddr, Ipv4Addr};
+
+/// Parse a string containing an IP address. If the string contains a mask
+/// length, ignore it. On Success, returns an `IpAddr`.
+///
+/// # Errors
+/// This function returns `AddrParseError` if the address could not be parsed.
+pub fn parse_address(input: &str) -> Result<IpAddr, AddrParseError> {
+    match input.parse::<IpAddr>() {
+        Ok(address) => Ok(address),
+        Err(_) => match input.parse::<IpNet>()? {
+            IpNet::V4(a) => Ok(a.addr().into()),
+            IpNet::V6(a) => Ok(a.addr().into()),
+        },
+    }
+}
+
+/// Parse a string containing an IPv4 address. If the string contains a mask
+/// length, ignore it. On Success, returns an `Ipv4Addr`.
+///
+/// # Errors
+/// This function returns `AddrParseError` if the address could not be parsed.
+pub fn parse_address_v4(input: &str) -> Result<Ipv4Addr, AddrParseError> {
+    match input.parse::<Ipv4Addr>() {
+        Ok(address) => Ok(address),
+        Err(_) => Ok(input.parse::<Ipv4Net>()?.addr()),
+    }
+}