clean-ups + vpc route abstraction + extend validation for failover

cli/bin/cmdtree_dp.rs

@@ -81,6 +81,11 @@ fn cmd_show_vpc() -> Node {
     root += Node::new("peerings")
         .desc("Show the peerings of each vpc")
         .action(CliAction::ShowVpcPeerings);
+
+    root += Node::new("routing")
+        .desc("Show the routing table of each vpc")
+        .action(CliAction::ShowVpcRouting);
+
     root
 }
 fn cmd_show_ip() -> Node {

cli/src/cliproto.rs

@@ -286,6 +286,7 @@ pub enum CliAction {
     // config: vpcs & peerings
     ShowVpc,
     ShowVpcPeerings,
+    ShowVpcRouting,
 
     // router: Eventlog
     RouterEventLog,

config/src/display.rs

@@ -16,8 +16,11 @@ use crate::external::overlay::vpcpeering::{
     VpcExposePortForwarding, VpcExposeStaticNat,
 };
 use crate::external::overlay::vpcpeering::{VpcManifest, VpcPeering, VpcPeeringTable};
+use crate::external::overlay::vpcrouting::{ExposeAction, VpcRoute, VpcRouteTable};
 use crate::external::overlay::{Overlay, ValidatedOverlay};
+
 use chrono::{DateTime, Utc};
+use net::vxlan::Vni;
 
 use common::cliprovider::Heading;
 const SEP: &str = "       ";
@@ -134,10 +137,11 @@ fn fmt_remote_manifest(
     f: &mut std::fmt::Formatter<'_>,
     manifest: &VpcManifest,
     remote_id: &VpcId,
+    remote_vni: Vni,
 ) -> std::fmt::Result {
     writeln!(
         f,
-        "     remote VPC is {} (id:{}):",
+        "     remote VPC is {} (id:{}), vni: {remote_vni}:",
         manifest.name, remote_id
     )?;
     for e in &manifest.exposes {
@@ -152,7 +156,7 @@ impl Display for Peering {
         writeln!(f, "   gwgroup: {}", &self.gwgroup)?;
         fmt_local_manifest(f, &self.local)?;
         writeln!(f)?;
-        fmt_remote_manifest(f, &self.remote, &self.remote_id)?;
+        fmt_remote_manifest(f, &self.remote, &self.remote_id, self.remote_vni)?;
         writeln!(f)
     }
 }
@@ -172,12 +176,12 @@ fn fmt_remote_validated_manifest(
     f: &mut std::fmt::Formatter<'_>,
     manifest: &ValidatedManifest,
     remote_id: &VpcId,
+    remote_vni: Vni,
 ) -> std::fmt::Result {
     writeln!(
         f,
-        "     remote VPC is {} (id:{}):",
+        "     remote VPC is {} (id:{remote_id}) vni:{remote_vni} :",
         manifest.name(),
-        remote_id
     )?;
     for e in manifest.valexp() {
         e.fmt(f)?;
@@ -191,7 +195,7 @@ impl Display for ValidatedPeering {
         writeln!(f, "   gwgroup: {}", self.gwgroup())?;
         fmt_local_validated_manifest(f, self.local())?;
         writeln!(f)?;
-        fmt_remote_validated_manifest(f, self.remote(), self.remote_id())?;
+        fmt_remote_validated_manifest(f, self.remote(), self.remote_id(), self.remote_vni())?;
         writeln!(f)
     }
 }
@@ -345,6 +349,18 @@ impl Display for ValidatedVpcSummary<'_> {
     }
 }
 
+pub struct VpcTableRoutingTables<'a>(&'a ValidatedVpcTable);
+impl Display for VpcTableRoutingTables<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for vpc in self.0.values() {
+            Heading(vpc.name().to_string()).fmt(f)?;
+            vpc.route_table().fmt(f)?;
+            writeln!(f)?;
+        }
+        Ok(())
+    }
+}
+
 pub struct VpcTableSummary<'a>(&'a VpcTable);
 impl Display for VpcTableSummary<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -409,6 +425,10 @@ impl ValidatedVpcTable {
     pub fn as_peerings(&self) -> ValidatedVpcTablePeerings<'_> {
         ValidatedVpcTablePeerings(self)
     }
+    #[must_use]
+    pub fn as_route_tables(&self) -> VpcTableRoutingTables<'_> {
+        VpcTableRoutingTables(self)
+    }
 }
 
 impl Vpc {
@@ -478,6 +498,58 @@ impl Display for ValidatedOverlay {
     }
 }
 
+/* ===== VPC routing tables =====*/
+
+macro_rules! VPC_RT_TBL_FMT {
+    () => {
+        " {:<30} {:<10} {:<12} {:<13} {:<16}"
+    };
+}
+fn fmt_vpc_rt_table_heading(f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    writeln!(
+        f,
+        VPC_RT_TBL_FMT!(),
+        "destinations", "remote-VPC", "remote-vni", "remote-action", "gw-group"
+    )
+}
+
+impl Display for ExposeAction {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.pad(match self {
+            ExposeAction::Default => "default",
+            ExposeAction::Forward => "forward",
+            ExposeAction::StaticNat => "static-nat",
+            ExposeAction::PortForwarding => "port-forward",
+            ExposeAction::Masquerade => "masqueraded",
+        })
+    }
+}
+
+impl Display for VpcRoute {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let dst = self.destination().to_string();
+        writeln!(
+            f,
+            VPC_RT_TBL_FMT!(),
+            dst,
+            self.dst_vpc(),
+            self.dst_vni(),
+            self.remote_action(),
+            self.gw_group()
+        )
+    }
+}
+
+impl Display for VpcRouteTable {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        fmt_vpc_rt_table_heading(f)?;
+        for route_set in self.iter() {
+            route_set.fmt(f)?;
+        }
+        Ok(())
+    }
+}
+
 /* ===== Configuration history ===== */
 
 macro_rules! CONFIGDB_TBL_FMT {

config/src/errors.rs

@@ -42,8 +42,6 @@ pub enum ConfigError {
     InvalidVpcVni(u32),
     #[error("Config with id {0} not found")]
     NoSuchConfig(GenId),
-    #[error("A config with id {0} already exists")]
-    ConfigAlreadyExists(GenId),
     #[error("Failure applying config: {0}")]
     FailureApply(String),
     #[error("Forbidden: {0}")]
@@ -58,20 +56,14 @@ pub enum ConfigError {
     MissingIdentifier(&'static str),
     #[error("Missing mandatory parameter: {0}")]
     MissingParameter(&'static str),
-    #[error("Incomplete: {0}")]
-    Incomplete(String),
     #[error("Multiple instances of {0} found, expected {1}")]
     TooManyInstances(&'static str, usize),
     #[error("Internal error: {0}")]
     InternalFailure(String),
-    #[error("MTU out of range [68, 65535]: {0}")]
-    BadMtu(u32),
 
     // Peering and VpcExpose validation
     #[error("All prefixes are excluded in VpcExpose: {0}")]
     ExcludedAllPrefixes(Box<VpcExpose>),
-    #[error("Exclusion prefix {0} not contained within existing allowed prefix")]
-    OutOfRangeExclusionPrefix(PrefixWithOptionalPorts),
     #[error("VPC prefixes overlap: {0} and {1}")]
     OverlappingPrefixes(PrefixWithOptionalPorts, PrefixWithOptionalPorts),
     #[error("Inconsistent IP version in VpcExpose: {0}")]

config/src/external/overlay/mod.rs

@@ -7,10 +7,11 @@ pub mod tests;
 pub mod validation_tests;
 pub mod vpc;
 pub mod vpcpeering;
+pub mod vpcrouting;
 
 use crate::{ConfigError, ConfigResult};
 use tracing::{debug, error};
-use vpc::{ValidatedVpcTable, VpcIdMap, VpcTable};
+use vpc::{ValidatedVpcTable, VpcTable};
 use vpcpeering::{VpcManifest, VpcPeeringTable};
 
 #[derive(Clone, Debug, Default)]
@@ -27,6 +28,7 @@ impl Overlay {
             peering_table,
         }
     }
+
     /// Check if a `Vpc` referred in a peering exists
     fn check_peering_vpc(&self, peering: &str, manifest: &VpcManifest) -> ConfigResult {
         self.vpc_table.get_vpc(&manifest.name).ok_or_else(|| {
@@ -36,12 +38,8 @@ impl Overlay {
         Ok(())
     }
 
-    /// Validate all peerings, checking if the VPCs they refer to exist in vpc table
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if a peering references a VPC that does not exist in the VPC table.
-    pub fn validate_peerings(&self) -> ConfigResult {
+    /// Validate all peerings: check if the VPCs they refer to exist in vpc table
+    fn validate_peering_vpcs(&self) -> ConfigResult {
         debug!("Validating VPC peerings...");
         for peering in self.peering_table.values() {
             self.check_peering_vpc(&peering.name, &peering.left)?;
@@ -50,17 +48,6 @@ impl Overlay {
         Ok(())
     }
 
-    /// Build a `VpcIdMap`. We have already checked that all VPC Ids are distinct
-    #[must_use]
-    pub(crate) fn vpcid_map(&self) -> VpcIdMap {
-        let id_map: VpcIdMap = self
-            .vpc_table
-            .values()
-            .map(|vpc| (vpc.name.clone(), vpc.id.clone()))
-            .collect();
-        id_map
-    }
-
     /// Validate the overlay configuration, returning a `ValidatedOverlay` if successful.
     ///
     /// # Errors
@@ -69,28 +56,22 @@ impl Overlay {
     pub fn validate(&self) -> Result<ValidatedOverlay, ConfigError> {
         debug!("Validating overlay configuration...");
 
-        self.validate_peerings()?;
+        // validate peerings:
+        self.validate_peering_vpcs()?;
 
         // Collect peerings for every VPC and validate the table
-        let validated_vpc_table = self.collect_peerings().validate()?;
-        let validated_overlay = ValidatedOverlay {
-            vpc_table: validated_vpc_table,
-        };
+        let vpc_table = self
+            .vpc_table
+            .collect_peerings(&self.peering_table)
+            .validate()?;
+
+        let validated_overlay = ValidatedOverlay { vpc_table };
 
         let peering_table = &self.peering_table;
         debug!("Overlay configuration is VALID:\n{validated_overlay}\n{peering_table}");
         Ok(validated_overlay)
     }
 
-    /// Collect peerings from the peering table for every VPC.
-    ///
-    /// Should only be called in `validate`, or in tests.
-    pub(crate) fn collect_peerings(&self) -> VpcTable {
-        let id_map = self.vpcid_map();
-        self.vpc_table
-            .collect_peerings(&self.peering_table, &id_map)
-    }
-
     /// FOR TESTS ONLY. Fake validation for the overlay.
     ///
     /// # Safety
@@ -100,15 +81,15 @@ impl Overlay {
     #[allow(unsafe_code)]
     #[must_use]
     pub unsafe fn fake_validated_overlay_for_tests(&self) -> ValidatedOverlay {
-        let vpc_table = self.collect_peerings();
+        let vpc_table = self.vpc_table.collect_peerings(&self.peering_table);
         let fake_valid_vpc_table = unsafe { vpc_table.fake_validated_vpc_table_for_tests() };
         ValidatedOverlay {
             vpc_table: fake_valid_vpc_table,
         }
     }
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Debug, Default)]
 pub struct ValidatedOverlay {
     vpc_table: ValidatedVpcTable,
 }

config/src/external/overlay/tests.rs

@@ -10,7 +10,6 @@
 pub mod test {
     use crate::external::ConfigError;
     use crate::external::overlay::Overlay;
-    use crate::external::overlay::VpcIdMap;
     use crate::external::overlay::vpc::{Vpc, VpcTable};
     use crate::external::overlay::vpcpeering::VpcExpose;
     use crate::external::overlay::vpcpeering::VpcManifest;
@@ -66,7 +65,7 @@ pub mod test {
 
         /* invalid vni should be rejected */
         let vpc1 = Vpc::new("VPC-1", "AAAAA", 0);
-        assert_eq!(vpc1, Err(ConfigError::InvalidVpcVni(0)));
+        assert!(vpc1.is_err_and(|e| matches!(e, ConfigError::InvalidVpcVni(0))));
 
         /* add vpc with valid vni 3000 */
         let vpc1 = Vpc::new("VPC-1", "AAAAA", 3000).expect("Should succeed");
@@ -91,12 +90,14 @@ pub mod test {
         );
 
         /* vpc with bad Id should not build */
-        let bad = Vpc::new("VPC-2", "AAA", 9000);
-        assert_eq!(bad, Err(ConfigError::BadVpcId("AAA".to_string())));
+        let bad_id = "AAA".to_string();
+        let bad = Vpc::new("VPC-2", &bad_id, 9000);
+        assert!(bad.is_err_and(|e| matches!(e, ConfigError::BadVpcId(_bad_id))));
 
         /* vpc with bad Id should not build */
-        let bad = Vpc::new("VPC-2", "!1234", 9000);
-        assert_eq!(bad, Err(ConfigError::BadVpcId("!1234".to_string())));
+        let bad_id = "!1234".to_string();
+        let bad = Vpc::new("VPC-2", &bad_id, 9000);
+        assert!(bad.is_err_and(|e| matches!(e, ConfigError::BadVpcId(_bad_id))));
     }
 
     #[test]
@@ -688,14 +689,8 @@ pub mod test {
         /* display peering table */
         println!("{peering_table}");
 
-        /* collect ids */
-        let id_map: VpcIdMap = vpc_table
-            .values()
-            .map(|vpc| (vpc.name.clone(), vpc.id.clone()))
-            .collect();
-
         /* collect the peerings for each VPC */
-        vpc_table.collect_peerings(&peering_table, &id_map);
+        vpc_table = vpc_table.collect_peerings(&peering_table);
 
         /* display VPC table */
         println!("{}", vpc_table.as_summary());
@@ -1176,7 +1171,7 @@ pub mod test {
 
         let overlay = Overlay::new(vpc_table, peering_table);
         assert!(overlay.validate().is_err_and(
-            |e| e == ConfigError::Forbidden("Multiple 'default' destinations exposed to VPC")
+            |e| e == ConfigError::Forbidden("Multiple default destinations exposed to VPC")
         ));
     }