WIP: feat: gRPC <-> external for nat config

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

Author: mvachhar

Cargo.lock

@@ -42,7 +42,7 @@ dpdk-sysroot-helper = { path = "./dpdk-sysroot-helper", package = "dataplane-dpd
 dplane-rpc = { git = "https://github.com/githedgehog/dplane-rpc.git", version = "1.1.2" }
 errno = { path = "./errno", package = "dataplane-errno" }
 flow-info = { path = "./flow-info", package = "dataplane-flow-info" }
-gateway_config = { git = "https://github.com/githedgehog/gateway-proto", tag = "v0.14.0", version = "0.14.0"}
+gateway_config = { git = "https://github.com/githedgehog/gateway-proto", version ="0.14.0", branch = "pr/mvachhar/nat-config" }
 hardware = { path = "./hardware", package = "dataplane-hardware" }
 id = { path = "./id", package = "dataplane-id" }
 interface-manager = { path = "./interface-manager", package = "dataplane-interface-manager" }

Cargo.toml

@@ -4,7 +4,9 @@
 use gateway_config::config as gateway_config;
 use std::convert::TryFrom;
 
-use crate::external::overlay::vpcpeering::VpcExpose;
+use crate::external::overlay::vpcpeering::{
+    VpcExpose, VpcExposeNatConfig, VpcExposeStatefulNat, VpcExposeStatelessNat,
+};
 use lpm::prefix::{Prefix, PrefixString};
 
 impl TryFrom<&gateway_config::Expose> for VpcExpose {
@@ -54,6 +56,34 @@ impl TryFrom<&gateway_config::Expose> for VpcExpose {
             }
         }
 
+        if !expose.r#as.is_empty() {
+            vpc_expose = vpc_expose.make_nat();
+            if let (Some(grpc_nat), Some(nat)) = (expose.nat.as_ref(), vpc_expose.nat.as_mut()) {
+                #[allow(clippy::default_constructed_unit_structs)]
+                match grpc_nat {
+                    gateway_config::expose::Nat::Stateless(_) => {
+                        nat.config =
+                            VpcExposeNatConfig::Stateless(VpcExposeStatelessNat::default());
+                    }
+                    gateway_config::expose::Nat::Stateful(grpc_s) => {
+                        if let Some(nat) = vpc_expose.nat.as_mut() {
+                            nat.config = VpcExposeNatConfig::Stateful(VpcExposeStatefulNat {
+                                idle_timeout: grpc_s
+                                    .idle_timeout
+                                    .ok_or(
+                                        "stateful nat requires idle_timeout, got None".to_string(),
+                                    )
+                                    .and_then(|t| {
+                                        std::time::Duration::try_from(t)
+                                            .map_err(|e| format!("Invalid duration: {e}"))
+                                    })?,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+
         Ok(vpc_expose)
     }
 }
@@ -77,7 +107,7 @@ impl TryFrom<&VpcExpose> for gateway_config::Expose {
             ips.push(gateway_config::PeeringIPs { rule: Some(rule) });
         }
 
-        if let Some(nat) = expose.nat.as_ref() {
+        let nat = if let Some(nat) = expose.nat.as_ref() {
             // Convert AS inclusion rules
             for prefix in &nat.as_range {
                 let rule = gateway_config::peering_as::Rule::Cidr(prefix.to_string());
@@ -89,10 +119,29 @@ impl TryFrom<&VpcExpose> for gateway_config::Expose {
                 let rule = gateway_config::peering_as::Rule::Not(prefix.to_string());
                 as_rules.push(gateway_config::PeeringAs { rule: Some(rule) });
             }
-        }
+
+            match nat.config {
+                VpcExposeNatConfig::Stateful(config) => {
+                    let idle_timeout =
+                        gateway_config::google::protobuf::Duration::try_from(config.idle_timeout)
+                            .map_err(|e| {
+                            format!("Unable to convert stateful nat idle timeout: {}", e)
+                        })?;
+                    Some(gateway_config::expose::Nat::Stateful(
+                        gateway_config::PeeringStatefulNat { idle_timeout },
+                    ))
+                }
+                VpcExposeNatConfig::Stateless(config) => Some(
+                    gateway_config::expose::Nat::Stateless(gateway_config::PeeringStatelessNat {}),
+                ),
+            }
+        } else {
+            None
+        };
         Ok(gateway_config::Expose {
             ips,
             r#as: as_rules,
+            nat,
         })
     }
 }

config/src/converters/grpc/expose.rs

@@ -266,11 +266,17 @@ mod test {
         let vpc1_expose = gateway_config::Expose {
             ips: vec![include_ip],
             r#as: vec![include_as],
+            nat: Some(gateway_config::config::expose::Nat::Stateless(
+                gateway_config::config::PeeringStatelessNat {},
+            )),
         };
 
         let vpc2_expose = gateway_config::Expose {
             ips: vec![exclude_ip],
             r#as: vec![exclude_as],
+            nat: Some(gateway_config::config::expose::Nat::Stateless(
+                gateway_config::config::PeeringStatelessNat {},
+            )),
         };
 
         // Create PeeringEntryFor