formatting

Author: TurtlePU

src/protocols/dsdv.rs

@@ -10,6 +10,7 @@ pub struct RoutingEntry {
 
 const DSDV_HEARTBEAT_PERIOD: u32 = 100;
 const DSDV_RETRY_PERIOD: u32 = 1 * 1000; /* 1 second */
+
 type RoutingTable = HashMap<u32, RoutingEntry>;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -18,20 +19,32 @@ pub enum RoutableMessage {
     Ack(u32),
 }
 
-
 #[derive(Debug, Clone)]
 pub enum DSDVMessage {
     HeartBeat((RoutingTable, u32 /* from */)),
-    RoutingRequest((RoutableMessage, u32 /* rerouting_agent */, u32 /* destination */)),
+    RoutingRequest(
+        (
+            RoutableMessage,
+            u32, /* rerouting_agent */
+            u32, /* destination */
+        ),
+    ),
 }
 
-
 pub async fn dsdv_actor(my_id: u32, mut ctx: Context<DSDVMessage>) {
     let mut last_transmission = ctx.current_step();
-    let mut table = RoutingTable::from([
-        (my_id, RoutingEntry { metric: 0, next_hop: my_id, sequence_number: last_transmission }),
-    ]);
-    ctx.send(MessageType::Comm(DSDVMessage::HeartBeat((table.clone(), my_id))));
+    let mut table = RoutingTable::from([(
+        my_id,
+        RoutingEntry {
+            metric: 0,
+            next_hop: my_id,
+            sequence_number: last_transmission,
+        },
+    )]);
+    ctx.send(MessageType::Comm(DSDVMessage::HeartBeat((
+        table.clone(),
+        my_id,
+    ))));
 
     log::info!("worker {} started", my_id);
 
@@ -50,11 +63,17 @@ pub async fn dsdv_actor(my_id: u32, mut ctx: Context<DSDVMessage>) {
                         if rerouting_agent == my_id {
                             if destination == my_id {
                                 // This message has achieved its addressee
-                                log::warn!("Achieved its dest: {:?} {} {}", rm, rerouting_agent, destination);
+                                log::warn!(
+                                    "Achieved its dest: {:?} {} {}",
+                                    rm,
+                                    rerouting_agent,
+                                    destination
+                                );
                                 match rm {
                                     RoutableMessage::Request(rm) => {
                                         ctx.send(MessageType::Request(rm.clone()));
-                                        messages_to_send.push((RoutableMessage::Ack(rm.id), rm.from));
+                                        messages_to_send
+                                            .push((RoutableMessage::Ack(rm.id), rm.from));
                                     }
                                     RoutableMessage::Ack(message_id) => {
                                         retries.remove(&message_id);
@@ -68,7 +87,11 @@ pub async fn dsdv_actor(my_id: u32, mut ctx: Context<DSDVMessage>) {
                     }
                     DSDVMessage::HeartBeat((other_table, from)) => {
                         for (dst, entry) in other_table.iter() {
-                            if !table.contains_key(dst) || table.contains_key(dst) && table.get(dst).unwrap().sequence_number < entry.sequence_number {
+                            if !table.contains_key(dst)
+                                || table.contains_key(dst)
+                                    && table.get(dst).unwrap().sequence_number
+                                        < entry.sequence_number
+                            {
                                 let mut new_entry = entry.clone();
                                 new_entry.next_hop = from;
                                 new_entry.metric = entry.metric + 1;
@@ -85,24 +108,34 @@ pub async fn dsdv_actor(my_id: u32, mut ctx: Context<DSDVMessage>) {
                 messages_to_send.push((RoutableMessage::Request(rm.clone()), rm.to));
             }
         }
-        log::info!("Size of mq: {} (agent {}) [{:?}]", messages_to_send.len(), my_id, messages_to_send);
-
+        log::info!(
+            "Size of mq: {} (agent {}) [{:?}]",
+            messages_to_send.len(),
+            my_id,
+            messages_to_send
+        );
 
         // Deduplicate messages
-        messages_to_send.sort_by_key(|(rm, dst)| match rm {
+        messages_to_send.sort_by_key(|(rm, _)| match rm {
             RoutableMessage::Request(rm) => rm.id,
-            RoutableMessage::Ack(id) => *id
+            RoutableMessage::Ack(id) => *id,
         });
         messages_to_send.dedup();
         // Send all enqueued on this step messages
         let mut unsent_messages = Vec::<(RoutableMessage, u32 /* destination */)>::default();
         for (msg, destination) in messages_to_send.iter() {
             if table.contains_key(&destination) {
-                ctx.send(MessageType::Comm(DSDVMessage::RoutingRequest((msg.clone(), table.get(&destination).unwrap().next_hop, *destination))));
+                ctx.send(MessageType::Comm(DSDVMessage::RoutingRequest((
+                    msg.clone(),
+                    table.get(&destination).unwrap().next_hop,
+                    *destination,
+                ))));
                 match msg {
                     RoutableMessage::Request(rm) => {
                         if retries.contains_key(&rm.id) {
-                            retries.entry(rm.id).and_modify(|(_, last_transmission)| { *last_transmission = ctx.current_step() as i32; });
+                            retries.entry(rm.id).and_modify(|(_, last_transmission)| {
+                                *last_transmission = ctx.current_step() as i32;
+                            });
                         }
                     }
                     RoutableMessage::Ack(_) => {}
@@ -117,10 +150,13 @@ pub async fn dsdv_actor(my_id: u32, mut ctx: Context<DSDVMessage>) {
         assert!(unsent_messages.is_empty());
         log::info!("Umq: {}", messages_to_send.len());
         if ctx.current_step() - last_transmission >= DSDV_HEARTBEAT_PERIOD {
-            for (k, mut v) in table.iter_mut() {
+            for (_, mut v) in table.iter_mut() {
                 v.sequence_number = ctx.current_step();
             }
-            ctx.send(MessageType::Comm(DSDVMessage::HeartBeat((table.clone(), my_id))));
+            ctx.send(MessageType::Comm(DSDVMessage::HeartBeat((
+                table.clone(),
+                my_id,
+            ))));
             last_transmission = ctx.current_step();
         }
     }