Fix cargo clippy feedback.

Author: brocaar

src/backend.rs

@@ -297,7 +297,7 @@ async fn handle_event_msg(
                     )
                 }
 
-                info!("Frame received - {}", helpers::format_uplink(&v)?);
+                info!("Frame received - {}", helpers::format_uplink(v)?);
                 mesh::handle_uplink(border_gateway, v).await?;
             }
         }
@@ -315,26 +315,23 @@ async fn handle_event_msg(
 async fn handle_mesh_event_msg(border_gateway: bool, event: gw::Event) -> Result<()> {
     trace!("Handling mesh event, event: {:?}", event);
 
-    match &event.event {
-        Some(gw::event::Event::UplinkFrame(v)) => {
-            if let Some(rx_info) = &v.rx_info {
-                // Filter out frames with invalid CRC.
-                if rx_info.crc_status() != gw::CrcStatus::CrcOk {
-                    debug!(
-                        "Discarding uplink, CRC != OK, uplink_id: {}",
-                        rx_info.uplink_id
-                    );
-                    return Ok(());
-                }
+    if let Some(gw::event::Event::UplinkFrame(v)) = &event.event {
+        if let Some(rx_info) = &v.rx_info {
+            // Filter out frames with invalid CRC.
+            if rx_info.crc_status() != gw::CrcStatus::CrcOk {
+                debug!(
+                    "Discarding uplink, CRC != OK, uplink_id: {}",
+                    rx_info.uplink_id
+                );
+                return Ok(());
             }
+        }
 
-            // The mesh event msg must always be a proprietary payload.
-            if v.phy_payload.first().cloned().unwrap_or_default() & 0xe0 == 0xe0 {
-                info!("Mesh frame received - {}", helpers::format_uplink(v)?);
-                mesh::handle_mesh(border_gateway, v).await?;
-            }
+        // The mesh event msg must always be a proprietary payload.
+        if v.phy_payload.first().cloned().unwrap_or_default() & 0xe0 == 0xe0 {
+            info!("Mesh frame received - {}", helpers::format_uplink(v)?);
+            mesh::handle_mesh(border_gateway, v).await?;
         }
-        _ => {}
     }
 
     Ok(())

src/commands.rs

@@ -101,12 +101,11 @@ async fn execute_proprietary(typ: u8, value: &[u8]) -> Result<packets::Event> {
 }
 
 async fn get_last_timestamp() -> Option<SystemTime> {
-    LAST_TIMESTAMP
+    *LAST_TIMESTAMP
         .get_or_init(|| async { Mutex::new(None) })
         .await
         .lock()
         .await
-        .clone()
 }
 
 async fn set_last_timestamp(ts: SystemTime) {

src/mesh.rs

@@ -66,11 +66,11 @@ pub async fn handle_mesh(border_gateway: bool, pl: &gw::UplinkFrame) -> Result<(
     match border_gateway {
         // Proxy relayed uplink
         true => match packet.mhdr.payload_type {
-            PayloadType::Uplink => proxy_uplink_mesh_packet(&pl, packet).await,
-            PayloadType::Event => proxy_event_mesh_packet(&pl, packet).await,
+            PayloadType::Uplink => proxy_uplink_mesh_packet(pl, packet).await,
+            PayloadType::Event => proxy_event_mesh_packet(pl, packet).await,
             _ => Ok(()),
         },
-        false => relay_mesh_packet(&pl, packet).await,
+        false => relay_mesh_packet(pl, packet).await,
     }
 }
 
@@ -110,13 +110,7 @@ pub async fn send_mesh_command(pl: gw::MeshCommand) -> Result<()> {
             commands: pl
                 .commands
                 .iter()
-                .map(|v| match &v.command {
-                    Some(gw::mesh_command_item::Command::Proprietary(v)) => Some(
-                        packets::Command::Proprietary((v.command_type as u8, v.payload.clone())),
-                    ),
-                    None => None,
-                })
-                .flatten()
+                .filter_map(|v| v.command.as_ref().map(|gw::mesh_command_item::Command::Proprietary(v)| packets::Command::Proprietary((v.command_type as u8, v.payload.clone()))))
                 .collect(),
         }),
         mic: None,
@@ -371,7 +365,7 @@ async fn relay_mesh_packet(pl: &gw::UplinkFrame, mut packet: MeshPacket) -> Resu
             if pl.relay_id == relay_id {
                 // The command payload was intended for this gateway, execute
                 // the commands.
-                let resp = commands::execute_commands(&pl).await?;
+                let resp = commands::execute_commands(pl).await?;
 
                 // Send back the responses (events).
                 if !resp.is_empty() {

src/packets.rs

@@ -846,10 +846,7 @@ impl Command {
         let mut value = vec![0; tag_length[1] as usize];
         cur.read_exact(&mut value)?;
 
-        Ok(match tag_length[0] {
-            // Add known types here
-            _ => Command::Proprietary((tag_length[0], value)),
-        })
+        Ok(Command::Proprietary((tag_length[0], value)))
     }
 
     pub fn encode(&self) -> Result<Vec<u8>> {

src/proxy.rs

@@ -43,7 +43,7 @@ pub async fn setup(conf: &Configuration) -> Result<()> {
             sock.bind(&event_bind).unwrap();
 
             while let Some(event) = event_rx.blocking_recv() {
-                sock.send(&event.encode_to_vec(), 0).unwrap();
+                sock.send(event.encode_to_vec(), 0).unwrap();
             }
         }
     });
@@ -145,7 +145,7 @@ async fn handle_command(cmd: gw::Command) -> Result<Vec<u8>> {
         Some(gw::command::Command::GetGatewayId(_)) => {
             info!("Get gateway id command received");
             gw::GetGatewayIdResponse {
-                gateway_id: hex::encode(&backend::get_gateway_id().await.unwrap_or_default()),
+                gateway_id: hex::encode(backend::get_gateway_id().await.unwrap_or_default()),
             }
             .encode_to_vec()
         }