Implemented route manager redistributing routes to peer handlers (not yet announcing to peers)

crates/server/src/path/path_data.rs

@@ -0,0 +1,95 @@
+use std::cmp::Ordering;
+
+use chrono::{DateTime, Utc};
+use serde::Serialize;
+
+use bgp_packet::path_attributes::{OriginPathAttribute, PathAttribute};
+
+use super::path_set::PathSource;
+
+/// PathData is a structure to contain a specific route via one nexthop.
+/// Note that currently there is an assumption that there is only
+/// one route per peer per prefix, but when ADD-PATH support is added
+/// this will no longer hold true.
+#[derive(Debug, Clone, Serialize)]
+pub struct PathData {
+    /// The origin through which this path was learned. This is set to EGP when learned from
+    /// another peer, set to IGP when statically configured or from another control plane.
+    pub origin: OriginPathAttribute,
+    /// The nexthop that traffic can be sent to.
+    pub nexthop: Vec<u8>,
+    /// Where this path was learned from.
+    pub path_source: PathSource,
+    /// The local pref of this path.
+    pub local_pref: u32,
+    /// The multi exit discriminator of this path.
+    pub med: u32,
+    /// The path of autonomous systems to the destination along this path.
+    pub as_path: Vec<u32>,
+    /// Path attributes received from the peer.
+    pub path_attributes: Vec<PathAttribute>,
+    /// When the path was learned.
+    pub learn_time: DateTime<Utc>,
+}
+
+impl PartialOrd for PathData {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for PathData {
+    fn cmp(&self, other: &Self) -> Ordering {
+        // Compare local_pref.
+        match self.local_pref.cmp(&other.local_pref) {
+            Ordering::Equal => {}
+            ord => return ord,
+        }
+
+        // Prefer paths that are locally configured.
+        if matches!(self.path_source, PathSource::LocallyConfigured)
+            && !matches!(other.path_source, PathSource::LocallyConfigured)
+        {
+            return Ordering::Less;
+        }
+
+        // Compare path length.
+        match self.as_path.len().cmp(&other.as_path.len()) {
+            Ordering::Equal => {}
+            ord => return ord,
+        }
+
+        // IGP < EGP < INCOMPLETE
+        match (self.origin as u8).cmp(&(other.origin as u8)) {
+            Ordering::Equal => {}
+            ord => return ord,
+        }
+
+        // MED lower is better, only checked if the announcing ASN is the same.
+        if let (Some(announcing_as_self), Some(announcing_as_other)) =
+            (self.as_path.last(), other.as_path.last())
+        {
+            if announcing_as_self == announcing_as_other && self.med < other.med {
+                return Ordering::Less;
+            }
+        }
+
+        // As a discriminator of last resort, prefer older routes.
+        self.learn_time.cmp(&other.learn_time)
+    }
+}
+
+impl PartialEq for PathData {
+    fn eq(&self, other: &Self) -> bool {
+        self.origin == other.origin
+            && self.nexthop == other.nexthop
+            && self.path_source == other.path_source
+            && self.local_pref == other.local_pref
+            && self.med == other.med
+            && self.as_path == other.as_path
+            && self.path_attributes == other.path_attributes
+            && self.learn_time == other.learn_time
+    }
+}
+
+impl Eq for PathData {}