Changes to the interactive queue and geotiming queue

Author: Pietroro

bgpsim/src/event/rand_queue.rs

@@ -167,7 +167,7 @@ impl<P: Prefix> PartialEq for SimpleTimingModel<P> {
     }
 }
 
-/// Timing model based on geological information. This timing model uses seconds as time unit.
+/// Timing model based on geographical information. This timing model uses seconds as time unit.
 ///
 /// The delay of a message from `a` to `b` is computed as follows: First, we compute the message's
 /// path through the network (based on the current IGP table). For each traversed link, we add the
@@ -315,7 +315,9 @@ impl<P: Prefix> GeoTimingModel<P> {
 
     /// Set the distance between two nodes in light seconds
     pub fn set_distance(&mut self, src: RouterId, dst: RouterId, dist: f64) {
-        let dist = NotNan::new(dist).unwrap();
+        let mut dist = NotNan::new(dist).unwrap();
+        // dist is in light seconds (c [m/s] * [s]), need to normalize for the speed of light
+        dist /= GEO_TIMING_MODEL_F_LIGHT_SPEED;
         self.distances.insert((src, dst), dist);
         self.distances.insert((dst, src), dist);
     }
@@ -443,6 +445,9 @@ impl<P: Prefix> EventQueue<P> for GeoTimingModel<P> {
             } => {
                 // compute the next time
                 let key = (src, dst);
+                // add any existing propagation delay introduced from external queues
+                // TODO: check that putting this here is correct (I think that normally this is always 0 and not really used)
+                next_time += *t;
                 // compute the propagation time
                 next_time += self.propagation_time(src, dst, &mut rng);
                 // compute the processing time
@@ -540,6 +545,7 @@ impl<P: Prefix> EventQueue<P> for GeoTimingModel<P> {
                 );
             }
         }
+        // TODO: add external routers to this
     }
 
     unsafe fn clone_events(&self, conquered: Self) -> Self {

bgpsim/src/formatter.rs

@@ -21,6 +21,7 @@ use itertools::{join, Itertools};
 
 use crate::{
     bgp::{BgpEvent, BgpRibEntry, BgpRoute},
+    builder::GaoRexfordPeerType,
     config::{Config, ConfigExpr, ConfigExprKey, ConfigModifier, ConfigPatch, RouteMapEdit},
     event::{BasicEventQueue, Event, FmtPriority},
     forwarding_state::{ForwardingState, TO_DST},
@@ -1143,6 +1144,20 @@ impl<'n, P: Prefix, Q, Ospf: OspfImpl<Process = LocalOspfProcess>> NetworkFormat
     }
 }
 
+//
+// Gao-Rexford
+//
+impl<'n, P: Prefix, Q, Ospf: OspfImpl> NetworkFormatter<'n, P, Q, Ospf> for GaoRexfordPeerType {
+    fn fmt(&self, _: &'n Network<P, Q, Ospf>) -> String {
+        match self {
+            GaoRexfordPeerType::Peer => "Peer".to_string(),
+            GaoRexfordPeerType::Provider => "Provider".to_string(),
+            GaoRexfordPeerType::Customer => "Customer".to_string(),
+            GaoRexfordPeerType::Ignore => "Ignore".to_string(),
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use crate::prelude::*;

bgpsim/src/interactive.rs

@@ -79,12 +79,13 @@ where
     ///
     /// If the closure is called *before* the event is processed:
     ///  - The third argument will be `None`
-    ///  - The event is still present in the network's queue
+    ///  - The event is still present in the network's queue (and therefore unfiltered)
     ///
     /// If the closure is called *after* the event is processed:
     ///  - The third argument will contain a `Some((StepUpdate, Vec<Event>))` tuple, where the second element
     ///    contains a list of events that were generated by the event that was just processed.
     ///  - These events have not been enqueued yet
+    ///  - The second argument will be the popped (filtered) event
     fn simulate_hooked(
         &mut self,
         f: impl FnMut(
@@ -263,7 +264,7 @@ impl<P: Prefix, Q: EventQueue<P>, Ospf: OspfImpl> InteractiveNetwork<P, Q, Ospf>
         let mut remaining_iter = self.stop_after;
         'timeout: loop {
             // While there are events in the queue
-            while let Some(event) = self.queue().peek() {
+            'queue: while let Some(event) = self.queue().peek() {
                 // Ensure the convergence limit is not overstepped
                 if let Some(rem) = remaining_iter {
                     if rem == 0 {
@@ -276,18 +277,20 @@ impl<P: Prefix, Q: EventQueue<P>, Ospf: OspfImpl> InteractiveNetwork<P, Q, Ospf>
                 // Straddle the trigger_event function with the pre- and post-event hooks
                 f(self, event, None);
                 // Safety: This is safe because we trigger the next event in the queue and
-                // we still push all resulting events to the queue. The extracted events are
-                // all immutable and won't be modified.
-                // Since the closure's reference to the network is immutable as well, this unwrap
-                // is always safe
-                let event = self.queue_mut().pop().unwrap();
-                let event_clone = event.clone();
-                let result = unsafe { self.trigger_event(event)? };
-                f(self, &event_clone, Some(&result));
+                // we still push all resulting events to the queue. The extracted events as well as the
+                // reference to the network are all immutable in this closure and won't be modified.
+                //
+                // The check below however is still needed, because `EventQueue::peek()` is allowed
+                // to return an event that is actually not returned by `EventQueue::pop()`
+                let Some(popped_event) = self.queue_mut().pop() else {
+                    break 'queue;
+                };
+                let result = unsafe { self.trigger_event(popped_event.clone())? };
+                f(self, &popped_event, Some(&result));
 
                 self.enqueue_events(result.1);
 
-                if matches!(event_clone, Event::Ospf { .. }) {
+                if matches!(popped_event, Event::Ospf { .. }) {
                     // OSPF event received! Check the BGP session state
                     self.refresh_bgp_sessions()?;
                 }

bgpsim/src/network.rs

@@ -41,7 +41,7 @@ use std::collections::{HashMap, HashSet};
 
 static DEFAULT_STOP_AFTER: usize = 1_000_000;
 /// The AS number assigned to internal routers.
-pub const INTERNAL_AS: AsId = AsId(65535);
+pub const INTERNAL_AS: AsId = AsId(10);
 
 /// # Network struct
 /// The struct contains all information about the underlying physical network (Links), a manages