Run cargo clippy and cargo fmt

cathay4t · cathay4t · commit 514cd9e928fb · 2023-01-29T18:30:01.000+08:00
Signed-off-by: Gris Ge &lt;fge@redhat.com&gt;
diff --git a/.rustfmt.toml b/.rustfmt.toml
@@ -0,0 +1,4 @@
+max_width = 80
+wrap_comments = true
+reorder_imports = true
+edition = "2021"
diff --git a/examples/dump_mptcp.rs b/examples/dump_mptcp.rs
@@ -22,7 +22,7 @@ async fn get_addresses() {
     }
     assert!(!msgs.is_empty());
     for msg in msgs {
-        println!("{:?}", msg);
+        println!("{msg:?}");
     }
 
     let mut limits_handle = handle.limits().get().execute().await;
@@ -33,6 +33,6 @@ async fn get_addresses() {
     }
     assert!(!msgs.is_empty());
     for msg in msgs {
-        println!("{:?}", msg);
+        println!("{msg:?}");
     }
 }
diff --git a/src/address/attr.rs b/src/address/attr.rs
@@ -66,11 +66,21 @@ fn u32_to_vec_flags(value: u32) -> Vec<MptcpPathManagerAddressAttrFlag> {
 impl From<&MptcpPathManagerAddressAttrFlag> for u32 {
     fn from(v: &MptcpPathManagerAddressAttrFlag) -> u32 {
         match v {
-            MptcpPathManagerAddressAttrFlag::Signal => MPTCP_PM_ADDR_FLAG_SIGNAL,
-            MptcpPathManagerAddressAttrFlag::Subflow => MPTCP_PM_ADDR_FLAG_SUBFLOW,
-            MptcpPathManagerAddressAttrFlag::Backup => MPTCP_PM_ADDR_FLAG_BACKUP,
-            MptcpPathManagerAddressAttrFlag::Fullmesh => MPTCP_PM_ADDR_FLAG_FULLMESH,
-            MptcpPathManagerAddressAttrFlag::Implicit => MPTCP_PM_ADDR_FLAG_IMPLICIT,
+            MptcpPathManagerAddressAttrFlag::Signal => {
+                MPTCP_PM_ADDR_FLAG_SIGNAL
+            }
+            MptcpPathManagerAddressAttrFlag::Subflow => {
+                MPTCP_PM_ADDR_FLAG_SUBFLOW
+            }
+            MptcpPathManagerAddressAttrFlag::Backup => {
+                MPTCP_PM_ADDR_FLAG_BACKUP
+            }
+            MptcpPathManagerAddressAttrFlag::Fullmesh => {
+                MPTCP_PM_ADDR_FLAG_FULLMESH
+            }
+            MptcpPathManagerAddressAttrFlag::Implicit => {
+                MPTCP_PM_ADDR_FLAG_IMPLICIT
+            }
             MptcpPathManagerAddressAttrFlag::Other(d) => *d,
         }
     }
@@ -114,7 +124,9 @@ impl Nla for MptcpPathManagerAddressAttr {
 
     fn emit_value(&self, buffer: &mut [u8]) {
         match self {
-            Self::Family(d) | Self::Port(d) => NativeEndian::write_u16(buffer, *d),
+            Self::Family(d) | Self::Port(d) => {
+                NativeEndian::write_u16(buffer, *d)
+            }
             Self::Addr4(i) => buffer.copy_from_slice(&i.octets()),
             Self::Addr6(i) => buffer.copy_from_slice(&i.octets()),
             Self::Id(d) => buffer[0] = *d,
@@ -131,12 +143,14 @@ impl Nla for MptcpPathManagerAddressAttr {
     }
 }
 
-impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>> for MptcpPathManagerAddressAttr {
+impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
+    for MptcpPathManagerAddressAttr
+{
     fn parse(buf: &NlaBuffer<&'a T>) -> Result<Self, DecodeError> {
         let payload = buf.value();
         Ok(match buf.kind() {
             MPTCP_PM_ADDR_ATTR_FAMILY => {
-                let err_msg = format!("Invalid MPTCP_PM_ADDR_ATTR_FAMILY value {:?}", payload);
+                let err_msg = format!("Invalid MPTCP_PM_ADDR_ATTR_FAMILY value {payload:?}");
                 Self::Family(parse_u16(payload).context(err_msg)?)
             }
             MPTCP_PM_ADDR_ATTR_ID => {
diff --git a/src/address/get.rs b/src/address/get.rs
@@ -4,7 +4,8 @@ use futures::TryStream;
 use netlink_packet_generic::GenlMessage;
 
 use crate::{
-    mptcp_execute, MptcpPathManagerError, MptcpPathManagerHandle, MptcpPathManagerMessage,
+    mptcp_execute, MptcpPathManagerError, MptcpPathManagerHandle,
+    MptcpPathManagerMessage,
 };
 
 pub struct MptcpPathManagerAddressGetRequest {
@@ -18,8 +19,10 @@ impl MptcpPathManagerAddressGetRequest {
 
     pub async fn execute(
         self,
-    ) -> impl TryStream<Ok = GenlMessage<MptcpPathManagerMessage>, Error = MptcpPathManagerError>
-    {
+    ) -> impl TryStream<
+        Ok = GenlMessage<MptcpPathManagerMessage>,
+        Error = MptcpPathManagerError,
+    > {
         let MptcpPathManagerAddressGetRequest { mut handle } = self;
 
         let mptcp_msg = MptcpPathManagerMessage::new_address_get();
diff --git a/src/handle.rs b/src/handle.rs
@@ -7,8 +7,9 @@ use netlink_packet_generic::GenlMessage;
 use netlink_packet_utils::DecodeError;
 
 use crate::{
-    try_mptcp, MptcpPathManagerAddressHandle, MptcpPathManagerCmd, MptcpPathManagerError,
-    MptcpPathManagerLimitsHandle, MptcpPathManagerMessage,
+    try_mptcp, MptcpPathManagerAddressHandle, MptcpPathManagerCmd,
+    MptcpPathManagerError, MptcpPathManagerLimitsHandle,
+    MptcpPathManagerMessage,
 };
 
 #[derive(Clone, Debug)]
@@ -37,19 +38,29 @@ impl MptcpPathManagerHandle {
         &mut self,
         message: NetlinkMessage<GenlMessage<MptcpPathManagerMessage>>,
     ) -> Result<
-        impl Stream<Item = Result<NetlinkMessage<GenlMessage<MptcpPathManagerMessage>>, DecodeError>>,
+        impl Stream<
+            Item = Result<
+                NetlinkMessage<GenlMessage<MptcpPathManagerMessage>>,
+                DecodeError,
+            >,
+        >,
         MptcpPathManagerError,
     > {
         self.handle.request(message).await.map_err(|e| {
-            MptcpPathManagerError::RequestFailed(format!("BUG: Request failed with {}", e))
+            MptcpPathManagerError::RequestFailed(format!(
+                "BUG: Request failed with {e}"
+            ))
         })
     }
 }
 
 pub(crate) async fn mptcp_execute(
     handle: &mut MptcpPathManagerHandle,
     mptcp_msg: MptcpPathManagerMessage,
-) -> impl TryStream<Ok = GenlMessage<MptcpPathManagerMessage>, Error = MptcpPathManagerError> {
+) -> impl TryStream<
+    Ok = GenlMessage<MptcpPathManagerMessage>,
+    Error = MptcpPathManagerError,
+> {
     let nl_header_flags = match mptcp_msg.cmd {
         MptcpPathManagerCmd::AddressGet => NLM_F_REQUEST | NLM_F_DUMP,
         MptcpPathManagerCmd::LimitsGet => NLM_F_REQUEST,
@@ -60,10 +71,15 @@ pub(crate) async fn mptcp_execute(
     nl_msg.header.flags = nl_header_flags;
 
     match handle.request(nl_msg).await {
-        Ok(response) => Either::Left(response.map(move |msg| Ok(try_mptcp!(msg)))),
+        Ok(response) => {
+            Either::Left(response.map(move |msg| Ok(try_mptcp!(msg))))
+        }
         Err(e) => Either::Right(
-            futures::future::err::<GenlMessage<MptcpPathManagerMessage>, MptcpPathManagerError>(e)
-                .into_stream(),
+            futures::future::err::<
+                GenlMessage<MptcpPathManagerMessage>,
+                MptcpPathManagerError,
+            >(e)
+            .into_stream(),
         ),
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
@@ -18,8 +18,11 @@ pub use connection::new_connection_with_socket;
 pub use error::MptcpPathManagerError;
 pub use handle::MptcpPathManagerHandle;
 pub use limits::{
-    MptcpPathManagerLimitsAttr, MptcpPathManagerLimitsGetRequest, MptcpPathManagerLimitsHandle,
+    MptcpPathManagerLimitsAttr, MptcpPathManagerLimitsGetRequest,
+    MptcpPathManagerLimitsHandle,
+};
+pub use message::{
+    MptcpPathManagerAttr, MptcpPathManagerCmd, MptcpPathManagerMessage,
 };
-pub use message::{MptcpPathManagerAttr, MptcpPathManagerCmd, MptcpPathManagerMessage};
 
 pub(crate) use handle::mptcp_execute;
diff --git a/src/limits/attr.rs b/src/limits/attr.rs
@@ -36,23 +36,31 @@ impl Nla for MptcpPathManagerLimitsAttr {
 
     fn emit_value(&self, buffer: &mut [u8]) {
         match self {
-            Self::RcvAddAddrs(d) | Self::Subflows(d) => NativeEndian::write_u32(buffer, *d),
+            Self::RcvAddAddrs(d) | Self::Subflows(d) => {
+                NativeEndian::write_u32(buffer, *d)
+            }
             Self::Other(ref attr) => attr.emit(buffer),
         }
     }
 }
 
-impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>> for MptcpPathManagerLimitsAttr {
+impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NlaBuffer<&'a T>>
+    for MptcpPathManagerLimitsAttr
+{
     fn parse(buf: &NlaBuffer<&'a T>) -> Result<Self, DecodeError> {
         let payload = buf.value();
         Ok(match buf.kind() {
             MPTCP_PM_ATTR_RCV_ADD_ADDRS => Self::RcvAddAddrs(
-                parse_u32(payload).context("Invalid MPTCP_PM_ATTR_RCV_ADD_ADDRS value")?,
+                parse_u32(payload)
+                    .context("Invalid MPTCP_PM_ATTR_RCV_ADD_ADDRS value")?,
+            ),
+            MPTCP_PM_ATTR_SUBFLOWS => Self::Subflows(
+                parse_u32(payload)
+                    .context("Invalid MPTCP_PM_ATTR_SUBFLOWS value")?,
+            ),
+            _ => Self::Other(
+                DefaultNla::parse(buf).context("invalid NLA (unknown kind)")?,
             ),
-            MPTCP_PM_ATTR_SUBFLOWS => {
-                Self::Subflows(parse_u32(payload).context("Invalid MPTCP_PM_ATTR_SUBFLOWS value")?)
-            }
-            _ => Self::Other(DefaultNla::parse(buf).context("invalid NLA (unknown kind)")?),
         })
     }
 }
diff --git a/src/limits/get.rs b/src/limits/get.rs
@@ -4,7 +4,8 @@ use futures::TryStream;
 use netlink_packet_generic::GenlMessage;
 
 use crate::{
-    mptcp_execute, MptcpPathManagerError, MptcpPathManagerHandle, MptcpPathManagerMessage,
+    mptcp_execute, MptcpPathManagerError, MptcpPathManagerHandle,
+    MptcpPathManagerMessage,
 };
 
 pub struct MptcpPathManagerLimitsGetRequest {
@@ -18,8 +19,10 @@ impl MptcpPathManagerLimitsGetRequest {
 
     pub async fn execute(
         self,
-    ) -> impl TryStream<Ok = GenlMessage<MptcpPathManagerMessage>, Error = MptcpPathManagerError>
-    {
+    ) -> impl TryStream<
+        Ok = GenlMessage<MptcpPathManagerMessage>,
+        Error = MptcpPathManagerError,
+    > {
         let MptcpPathManagerLimitsGetRequest { mut handle } = self;
 
         let mptcp_msg = MptcpPathManagerMessage::new_limits_get();
diff --git a/src/message.rs b/src/message.rs
@@ -7,7 +7,9 @@ use netlink_packet_utils::{
     DecodeError, Emitable, Parseable, ParseableParametrized,
 };
 
-use crate::{address::MptcpPathManagerAddressAttr, limits::MptcpPathManagerLimitsAttr};
+use crate::{
+    address::MptcpPathManagerAddressAttr, limits::MptcpPathManagerLimitsAttr,
+};
 
 const MPTCP_PM_CMD_GET_ADDR: u8 = 3;
 const MPTCP_PM_CMD_GET_LIMITS: u8 = 6;
@@ -113,12 +115,15 @@ impl Emitable for MptcpPathManagerMessage {
 fn parse_nlas(buffer: &[u8]) -> Result<Vec<MptcpPathManagerAttr>, DecodeError> {
     let mut nlas = Vec::new();
     for nla in NlasIterator::new(buffer) {
-        let error_msg = format!("Failed to parse mptcp address message attribute {:?}", nla);
+        let error_msg =
+            format!("Failed to parse mptcp address message attribute {nla:?}");
         let nla = &nla.context(error_msg)?;
         match nla.kind() {
             MPTCP_PM_ATTR_ADDR => {
                 for addr_nla in NlasIterator::new(nla.value()) {
-                    let error_msg = format!("Failed to parse MPTCP_PM_ATTR_ADDR {:?}", addr_nla);
+                    let error_msg = format!(
+                        "Failed to parse MPTCP_PM_ATTR_ADDR {addr_nla:?}"
+                    );
                     let addr_nla = &addr_nla.context(error_msg)?;
 
                     nlas.push(MptcpPathManagerAttr::Address(
@@ -127,10 +132,13 @@ fn parse_nlas(buffer: &[u8]) -> Result<Vec<MptcpPathManagerAttr>, DecodeError> {
                     ))
                 }
             }
-            MPTCP_PM_ATTR_RCV_ADD_ADDRS => nlas.push(MptcpPathManagerAttr::Limits(
-                MptcpPathManagerLimitsAttr::parse(nla)
-                    .context("Failed to parse MPTCP_PM_ATTR_RCV_ADD_ADDRS")?,
-            )),
+            MPTCP_PM_ATTR_RCV_ADD_ADDRS => {
+                nlas.push(MptcpPathManagerAttr::Limits(
+                    MptcpPathManagerLimitsAttr::parse(nla).context(
+                        "Failed to parse MPTCP_PM_ATTR_RCV_ADD_ADDRS",
+                    )?,
+                ))
+            }
             MPTCP_PM_ATTR_SUBFLOWS => nlas.push(MptcpPathManagerAttr::Limits(
                 MptcpPathManagerLimitsAttr::parse(nla)
                     .context("Failed to parse MPTCP_PM_ATTR_RCV_ADD_ADDRS")?,
@@ -144,7 +152,10 @@ fn parse_nlas(buffer: &[u8]) -> Result<Vec<MptcpPathManagerAttr>, DecodeError> {
 }
 
 impl ParseableParametrized<[u8], GenlHeader> for MptcpPathManagerMessage {
-    fn parse_with_param(buffer: &[u8], header: GenlHeader) -> Result<Self, DecodeError> {
+    fn parse_with_param(
+        buffer: &[u8],
+        header: GenlHeader,
+    ) -> Result<Self, DecodeError> {
         Ok(match header.cmd {
             MPTCP_PM_CMD_GET_ADDR => Self {
                 cmd: MptcpPathManagerCmd::AddressGet,
@@ -156,8 +167,7 @@ impl ParseableParametrized<[u8], GenlHeader> for MptcpPathManagerMessage {
             },
             cmd => {
                 return Err(DecodeError::from(format!(
-                    "Unsupported mptcp reply command: {}",
-                    cmd
+                    "Unsupported mptcp reply command: {cmd}"
                 )))
             }
         })
diff --git a/tests/dump_mptcp.rs b/tests/dump_mptcp.rs
@@ -59,7 +59,9 @@ async fn assert_empty_addresses_and_limits() {
     let mptcp_nlas = &msgs[0].payload.nlas;
     assert_eq!(
         mptcp_nlas[0],
-        MptcpPathManagerAttr::Limits(MptcpPathManagerLimitsAttr::RcvAddAddrs(0))
+        MptcpPathManagerAttr::Limits(MptcpPathManagerLimitsAttr::RcvAddAddrs(
+            0
+        ))
     );
     assert_eq!(
         mptcp_nlas[1],

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ async fn get_addresses() {`
`22`	`22`	`}`
`23`	`23`	`assert!(!msgs.is_empty());`
`24`	`24`	`for msg in msgs {`
`25`		`- println!("{:?}", msg);`
	`25`	`+ println!("{msg:?}");`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`let mut limits_handle = handle.limits().get().execute().await;`
`@@ -33,6 +33,6 @@ async fn get_addresses() {`
`33`	`33`	`}`
`34`	`34`	`assert!(!msgs.is_empty());`
`35`	`35`	`for msg in msgs {`
`36`		`- println!("{:?}", msg);`
	`36`	`+ println!("{msg:?}");`
`37`	`37`	`}`
`38`	`38`	`}`