rustfmt on changed files

facebookincubator · Jan 31, 2024 · bb0c013 · bb0c013
1 parent a598dcc
commit bb0c013
Show file tree

Hide file tree

Showing 8 changed files with 118 additions and 104 deletions.
diff --git a/below/dump/src/lib.rs b/below/dump/src/lib.rs
@@ -52,8 +52,8 @@ pub mod network;
 pub mod print;
 pub mod process;
 pub mod system;
-pub mod tmain;
 pub mod tc;
+pub mod tmain;
 pub mod transport;
 
 #[cfg(test)]

diff --git a/below/dump/src/test.rs b/below/dump/src/test.rs
@@ -1338,9 +1338,7 @@ fn test_dump_tc_content() {
         network: model::NetworkModel::default(),
         gpu: None,
         resctrl: None,
-        tc: Some(model::TcModel {
-            tc: tc_models,
-        }),
+        tc: Some(model::TcModel { tc: tc_models }),
     };
 
     let mut opts: GeneralOpt = Default::default();

diff --git a/below/model/src/collector.rs b/below/model/src/collector.rs
@@ -318,7 +318,7 @@ fn collect_sample(
                     Default::default()
                 }
             }
-        }
+        },
     })
 }
 

diff --git a/below/model/src/collector_plugin.rs b/below/model/src/collector_plugin.rs
@@ -155,14 +155,14 @@ mod test {
             // Test overwriting sample
             futures::executor::block_on(collector.collect_and_update()).unwrap();
             c.wait(); // <-- 1
-            // Consumer checking overwritten sample
+                      // Consumer checking overwritten sample
             c.wait(); // <-- 2
-            // Test sending None
+                      // Test sending None
             futures::executor::block_on(collector.collect_and_update()).unwrap();
             c.wait(); // <-- 3
-            // Consumer checking None
+                      // Consumer checking None
             c.wait(); // <-- 4
-            // Test sending error. Will fail on both collector and consumer threads.
+                      // Test sending error. Will fail on both collector and consumer threads.
             let is_error = matches!(
                 futures::executor::block_on(collector.collect_and_update()),
                 Err(_)
@@ -174,11 +174,11 @@ mod test {
         barrier.wait(); // <-- 1
         assert_eq!(Some(2), consumer.try_take().unwrap());
         barrier.wait(); // <-- 2
-        // Collector sending None
+                        // Collector sending None
         barrier.wait(); // <-- 3
         assert_eq!(None, consumer.try_take().unwrap());
         barrier.wait(); // <-- 4
-        // Collector sending error
+                        // Collector sending error
         barrier.wait(); // <-- 5
         assert!(matches!(consumer.try_take(), Err(_)));
 

diff --git a/below/model/src/tc_model.rs b/below/model/src/tc_model.rs
@@ -28,18 +28,14 @@ pub struct TcModel {
 }
 
 impl TcModel {
-    pub fn new(
-        sample: &Vec<Tc>,
-        last: Option<(&Vec<Tc>, Duration)>,
-    ) -> Self {
+    pub fn new(sample: &Vec<Tc>, last: Option<(&Vec<Tc>, Duration)>) -> Self {
         // Assumption: sample and last are always ordered
         let tc = match last {
-            Some((last_tcs, d)) if last_tcs.len() == sample.len() => {
-                sample.iter()
-                    .zip(last_tcs.iter())
-                    .map(|(sample, last)| SingleTcModel::new(sample, Some((last, d))))
-                    .collect::<Vec<_>>()
-            }
+            Some((last_tcs, d)) if last_tcs.len() == sample.len() => sample
+                .iter()
+                .zip(last_tcs.iter())
+                .map(|(sample, last)| SingleTcModel::new(sample, Some((last, d))))
+                .collect::<Vec<_>>(),
             _ => Vec::new(),
         };
 
@@ -110,8 +106,7 @@ impl SingleTcModel {
         });
 
         if let Some(sample) = stats.xstats.as_ref() {
-            let last =
-                last.and_then(|(last, d)| last.stats.xstats.as_ref().map(|l| (l, d)));
+            let last = last.and_then(|(last, d)| last.stats.xstats.as_ref().map(|l| (l, d)));
 
             tc_model.xstats = Some(XStatsModel::new(sample, last));
         }

diff --git a/below/tc/src/lib.rs b/below/tc/src/lib.rs
@@ -6,9 +6,11 @@ mod test;
 
 use std::collections::BTreeMap;
 
-use netlink_packet_core::{NetlinkHeader, NetlinkMessage, NetlinkPayload, NLM_F_DUMP, NLM_F_REQUEST};
-use netlink_packet_route::RouteNetlinkMessage;
+use netlink_packet_core::{
+    NetlinkHeader, NetlinkMessage, NetlinkPayload, NLM_F_DUMP, NLM_F_REQUEST,
+};
 use netlink_packet_route::tc::TcMessage;
+use netlink_packet_route::RouteNetlinkMessage;
 use netlink_sys::constants::NETLINK_ROUTE;
 use netlink_sys::{Socket, SocketAddr};
 use nix::net::if_;
@@ -25,7 +27,10 @@ pub fn tc_stats() -> Result<TcStats> {
     read_tc_stats(ifaces, &get_netlink_qdiscs)
 }
 
-fn read_tc_stats(interfaces: BTreeMap<u32, String>, netlink_retriever: &dyn Fn() -> Result<Vec<TcMessage>>) -> Result<TcStats> {
+fn read_tc_stats(
+    interfaces: BTreeMap<u32, String>,
+    netlink_retriever: &dyn Fn() -> Result<Vec<TcMessage>>,
+) -> Result<TcStats> {
     let messages = netlink_retriever()?;
     let tc_stats = messages
         .into_iter()
@@ -41,7 +46,9 @@ fn read_tc_stats(interfaces: BTreeMap<u32, String>, netlink_retriever: &dyn Fn()
 fn get_netlink_qdiscs() -> Result<Vec<TcMessage>> {
     // open a socket
     let socket = Socket::new(NETLINK_ROUTE).map_err(|e| TcError::Netlink(e.to_string()))?;
-    socket.connect(&SocketAddr::new(0, 0)).map_err(|e| TcError::Netlink(e.to_string()))?;
+    socket
+        .connect(&SocketAddr::new(0, 0))
+        .map_err(|e| TcError::Netlink(e.to_string()))?;
 
     // create a netlink request
     let mut nl_hdr = NetlinkHeader::default();
@@ -53,7 +60,9 @@ fn get_netlink_qdiscs() -> Result<Vec<TcMessage>> {
     packet.serialize(&mut buf[..]);
 
     // send the request
-    socket.send(&buf[..], 0).map_err(|e| TcError::Netlink(e.to_string()))?;
+    socket
+        .send(&buf[..], 0)
+        .map_err(|e| TcError::Netlink(e.to_string()))?;
 
     // receive the response
     let mut recv_buf = vec![0; 4096];
@@ -83,7 +92,9 @@ fn get_netlink_qdiscs() -> Result<Vec<TcMessage>> {
 
     let mut tc_msgs = Vec::new();
     for msg in response {
-        if let NetlinkPayload::InnerMessage(RouteNetlinkMessage::NewQueueDiscipline(tc)) = msg.payload {
+        if let NetlinkPayload::InnerMessage(RouteNetlinkMessage::NewQueueDiscipline(tc)) =
+            msg.payload
+        {
             tc_msgs.push(tc);
         }
     }
@@ -95,17 +106,17 @@ fn get_netlink_qdiscs() -> Result<Vec<TcMessage>> {
 fn get_interfaces() -> Result<BTreeMap<u32, String>> {
     let ifaces = if_::if_nameindex().map_err(|e| TcError::ReadInterfaces(e.to_string()))?;
     let if_map = ifaces
-    .iter()
-    .map(|iface| {
-        let index = iface.index();
-        let name = if let Ok(name) = iface.name().to_str() {
-            name.to_string()
-        } else {
-            String::new()
-        };
-        (index, name)
-    })
-    .collect::<BTreeMap<u32, String>>();
+        .iter()
+        .map(|iface| {
+            let index = iface.index();
+            let name = if let Ok(name) = iface.name().to_str() {
+                name.to_string()
+            } else {
+                String::new()
+            };
+            (index, name)
+        })
+        .collect::<BTreeMap<u32, String>>();
 
     Ok(if_map)
 }
diff --git a/below/tc/src/test.rs b/below/tc/src/test.rs
@@ -1,4 +1,7 @@
-use netlink_packet_route::tc::{TcAttribute, TcFqCodelQdStats, TcFqCodelXstats, TcHandle, TcHeader, TcMessage, TcOption, TcQdiscFqCodelOption, TcStats, TcStats2, TcStatsBasic, TcStatsQueue, TcXstats};
+use netlink_packet_route::tc::{
+    TcAttribute, TcFqCodelQdStats, TcFqCodelXstats, TcHandle, TcHeader, TcMessage, TcOption,
+    TcQdiscFqCodelOption, TcStats, TcStats2, TcStatsBasic, TcStatsQueue, TcXstats,
+};
 
 use super::*;
 
@@ -53,24 +56,20 @@ fn fake_netlink_qdiscs() -> Result<Vec<TcMessage>> {
                     queue
                 }),
             ]),
-            TcAttribute::Xstats(
-                TcXstats::FqCodel(
-                    TcFqCodelXstats::Qdisc({
-                        let mut fq_codel = TcFqCodelQdStats::default();
-                        fq_codel.maxpacket = 258;
-                        fq_codel.drop_overlimit = 0;
-                        fq_codel.ecn_mark = 0;
-                        fq_codel.new_flow_count = 91;
-                        fq_codel.new_flows_len = 0;
-                        fq_codel.old_flows_len = 0;
-                        fq_codel.ce_mark = 0;
-                        fq_codel.memory_usage = 0;
-                        fq_codel.drop_overmemory = 0;
-                        fq_codel
-                    }
-                )
-            )
-        ),],
+            TcAttribute::Xstats(TcXstats::FqCodel(TcFqCodelXstats::Qdisc({
+                let mut fq_codel = TcFqCodelQdStats::default();
+                fq_codel.maxpacket = 258;
+                fq_codel.drop_overlimit = 0;
+                fq_codel.ecn_mark = 0;
+                fq_codel.new_flow_count = 91;
+                fq_codel.new_flows_len = 0;
+                fq_codel.old_flows_len = 0;
+                fq_codel.ce_mark = 0;
+                fq_codel.memory_usage = 0;
+                fq_codel.drop_overmemory = 0;
+                fq_codel
+            }))),
+        ],
     );
     tc_msgs.push(msg1);
 
@@ -95,28 +94,34 @@ fn test_tc_stats() {
     assert_eq!(tc.stats.pps, Some(400));
 
     // qdisc
-    assert_eq!(tc.qdisc, Some(QDisc::FqCodel(FqCodelQDisc {
-        target: 4999,
-        limit: 10240,
-        interval: 99999,
-        ecn: 1,
-        flows: 1024,
-        quantum: 1514,
-        ce_threshold: 0,
-        drop_batch_size: 64,
-        memory_limit: 33554432,
-    })));
+    assert_eq!(
+        tc.qdisc,
+        Some(QDisc::FqCodel(FqCodelQDisc {
+            target: 4999,
+            limit: 10240,
+            interval: 99999,
+            ecn: 1,
+            flows: 1024,
+            quantum: 1514,
+            ce_threshold: 0,
+            drop_batch_size: 64,
+            memory_limit: 33554432,
+        }))
+    );
 
     // xstats
-    assert_eq!(tc.stats.xstats, Some(XStats::FqCodel(FqCodelXStats {
-        maxpacket: 258,
-        drop_overlimit: 0,
-        ecn_mark: 0,
-        new_flow_count: 91,
-        new_flows_len: 0,
-        old_flows_len: 0,
-        ce_mark: 0,
-        memory_usage: 0,
-        drop_overmemory: 0,
-    })));
+    assert_eq!(
+        tc.stats.xstats,
+        Some(XStats::FqCodel(FqCodelXStats {
+            maxpacket: 258,
+            drop_overlimit: 0,
+            ecn_mark: 0,
+            new_flow_count: 91,
+            new_flows_len: 0,
+            old_flows_len: 0,
+            ce_mark: 0,
+            memory_usage: 0,
+            drop_overmemory: 0,
+        }))
+    );
 }
diff --git a/below/tc/src/types.rs b/below/tc/src/types.rs
@@ -1,7 +1,9 @@
 use std::collections::BTreeMap;
 
 use netlink_packet_route::tc;
-use netlink_packet_route::tc::{TcAttribute, TcFqCodelXstats, TcMessage, TcOption, TcQdiscFqCodelOption};
+use netlink_packet_route::tc::{
+    TcAttribute, TcFqCodelXstats, TcMessage, TcOption, TcQdiscFqCodelOption,
+};
 use serde::{Deserialize, Serialize};
 
 const FQ_CODEL: &str = "fq_codel";
@@ -21,7 +23,9 @@ pub struct Tc {
 impl Tc {
     pub fn new(interfaces: &BTreeMap<u32, String>, tc_msg: &TcMessage) -> Self {
         let if_index = tc_msg.header.index as u32;
-        let if_name = interfaces.get(&if_index).map_or_else(String::new, |iface| iface.to_string());
+        let if_name = interfaces
+            .get(&if_index)
+            .map_or_else(String::new, |iface| iface.to_string());
         let mut tc = Self {
             if_index,
             if_name,
@@ -57,19 +61,16 @@ impl Tc {
                         }
                     }
                 }
-                TcAttribute::Xstats(tc_xstats) => {
-                    match tc_xstats {
-                        tc::TcXstats::FqCodel(fq_codel_xstats) => {
-                            tc.stats.xstats = Some(XStats::FqCodel(FqCodelXStats::new(fq_codel_xstats)))
-                        }
-                        _ => {}
+                TcAttribute::Xstats(tc_xstats) => match tc_xstats {
+                    tc::TcXstats::FqCodel(fq_codel_xstats) => {
+                        tc.stats.xstats = Some(XStats::FqCodel(FqCodelXStats::new(fq_codel_xstats)))
                     }
-                }
+                    _ => {}
+                },
                 _ => {}
             }
         }
 
-
         tc.qdisc = QDisc::new(&tc.kind, opts);
 
         tc
@@ -108,20 +109,24 @@ impl QDisc {
             let mut fq_codel = FqCodelQDisc::default();
             for opt in opts {
                 match opt {
-                    TcOption::FqCodel(fq_codel_opt) => {
-                        match fq_codel_opt {
-                            TcQdiscFqCodelOption::Target(target) => fq_codel.target = target,
-                            TcQdiscFqCodelOption::Limit(limit) => fq_codel.limit = limit,
-                            TcQdiscFqCodelOption::Interval(interval) => fq_codel.interval = interval,
-                            TcQdiscFqCodelOption::Ecn(ecn) => fq_codel.ecn = ecn,
-                            TcQdiscFqCodelOption::Flows(flows) => fq_codel.flows = flows,
-                            TcQdiscFqCodelOption::Quantum(quantum) => fq_codel.quantum = quantum,
-                            TcQdiscFqCodelOption::CeThreshold(ce_threshold) => fq_codel.ce_threshold = ce_threshold,
-                            TcQdiscFqCodelOption::DropBatchSize(drop_batch_size) => fq_codel.drop_batch_size = drop_batch_size,
-                            TcQdiscFqCodelOption::MemoryLimit(memory_limit) => fq_codel.memory_limit = memory_limit,
-                            _ => {}
+                    TcOption::FqCodel(fq_codel_opt) => match fq_codel_opt {
+                        TcQdiscFqCodelOption::Target(target) => fq_codel.target = target,
+                        TcQdiscFqCodelOption::Limit(limit) => fq_codel.limit = limit,
+                        TcQdiscFqCodelOption::Interval(interval) => fq_codel.interval = interval,
+                        TcQdiscFqCodelOption::Ecn(ecn) => fq_codel.ecn = ecn,
+                        TcQdiscFqCodelOption::Flows(flows) => fq_codel.flows = flows,
+                        TcQdiscFqCodelOption::Quantum(quantum) => fq_codel.quantum = quantum,
+                        TcQdiscFqCodelOption::CeThreshold(ce_threshold) => {
+                            fq_codel.ce_threshold = ce_threshold
                         }
-                    }
+                        TcQdiscFqCodelOption::DropBatchSize(drop_batch_size) => {
+                            fq_codel.drop_batch_size = drop_batch_size
+                        }
+                        TcQdiscFqCodelOption::MemoryLimit(memory_limit) => {
+                            fq_codel.memory_limit = memory_limit
+                        }
+                        _ => {}
+                    },
                     _ => {}
                 }
             }
-Original file line number
+Diff line change
@@ Expand Up / @@ -318,7 +318,7 @@ fn collect_sample( @@
                         Default::default()
                     }
                 }
-            }
+            },
         })
     }
@@ Expand Down @@