Fix clippy feedback.

Author: brocaar

Makefile

@@ -1,5 +1,24 @@
-devshell:
-	docker-compose run --rm chirpstack-udp-forwarder bash
+.PHONY: dist
+
+# Update the version
+version:
+	test -n "$(VERSION)"
+	sed -i 's/^version.*/version = "$(VERSION)"/g' ./Cargo.toml
+	make test
+	git add .
+	git commit -v -m "Bump version to $(VERSION)"
+	git tag -a v$(VERSION) -m "v$(VERSION)"
+
+# Cleanup dist.
+clean:
+	rm -rf dist
 
+# Run tests
 test:
+	docker-compose run --rm chirpstack-udp-forwarder cargo clippy --no-deps
 	docker-compose run --rm chirpstack-udp-forwarder cargo test
+
+# Enter the devshell.
+devshell:
+	docker-compose run --rm chirpstack-udp-forwarder bash
+

src/commands.rs

@@ -10,5 +10,5 @@ pub fn get_socket(endpoint: &str) -> Result<zmq::Socket, zmq::Error> {
     let sock = zmq_ctx.socket(zmq::REQ)?;
     sock.connect(endpoint)?;
 
-    return Ok(sock);
+    Ok(sock)
 }

src/config.rs

@@ -2,7 +2,7 @@ use std::fs;
 
 use serde::Deserialize;
 
-pub const VERSION: &'static str = env!("CARGO_PKG_VERSION");
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 
 #[derive(Deserialize, Default)]
 pub struct UdpForwarder {
@@ -39,7 +39,7 @@ impl Configuration {
         for file_name in filenames {
             content.push_str(&match fs::read_to_string(file_name) {
                 Ok(v) => v,
-                Err(err) => return Err(format!("read config file error: {}", err).to_string()),
+                Err(err) => return Err(format!("read config file error: {}", err)),
             });
         }
 
@@ -48,6 +48,6 @@ impl Configuration {
             Err(err) => return Err(format!("parse config file error: {}", err)),
         };
 
-        return Ok(config);
+        Ok(config)
     }
 }

src/events.rs

@@ -12,10 +12,10 @@ pub fn get_socket(endpoint: &str) -> Result<zmq::Socket, zmq::Error> {
 
     let zmq_ctx = ZMQ_CONTEXT.lock().unwrap();
     let sock = zmq_ctx.socket(zmq::SUB)?;
-    sock.connect(&endpoint).expect("ZMQ connect error");
+    sock.connect(endpoint).expect("ZMQ connect error");
     sock.set_subscribe("".as_bytes())?;
 
-    return Ok(sock);
+    Ok(sock)
 }
 
 pub enum Event {
@@ -29,10 +29,10 @@ pub enum Event {
     Unknown(String, Vec<u8>),
 
     // Uplink event.
-    Uplink(chirpstack_api::gw::UplinkFrame),
+    Uplink(Box<chirpstack_api::gw::UplinkFrame>),
 
     // Stats event.
-    Stats(chirpstack_api::gw::GatewayStats),
+    Stats(Box<chirpstack_api::gw::GatewayStats>),
 }
 
 pub struct Reader<'a> {
@@ -41,11 +41,8 @@ pub struct Reader<'a> {
 }
 
 impl<'a> Reader<'a> {
-    pub fn new(sock: &'a zmq::Socket, timeout: Duration) -> Self {
-        Reader {
-            sub_sock: sock,
-            timeout: timeout,
-        }
+    pub fn new(sub_sock: &'a zmq::Socket, timeout: Duration) -> Self {
+        Reader { sub_sock, timeout }
     }
 }
 
@@ -63,7 +60,7 @@ impl Iterator for Reader<'_> {
         let msg = self.sub_sock.recv_multipart(0).unwrap();
         match handle_message(msg) {
             Ok(v) => Some(v),
-            Err(err) => Some(Event::Error(err.to_string())),
+            Err(err) => Some(Event::Error(err)),
         }
     }
 }
@@ -80,11 +77,11 @@ fn handle_message(msg: Vec<Vec<u8>>) -> Result<Event, String> {
 
     Ok(match event.as_str() {
         "up" => match parse_up(&msg[1]) {
-            Ok(v) => Event::Uplink(v),
+            Ok(v) => Event::Uplink(Box::new(v)),
             Err(err) => Event::Error(err),
         },
         "stats" => match parse_stats(&msg[1]) {
-            Ok(v) => Event::Stats(v),
+            Ok(v) => Event::Stats(Box::new(v)),
             Err(err) => Event::Error(err),
         },
         _ => Event::Unknown(event, msg[1].clone()),

src/forwarder.rs

@@ -34,7 +34,7 @@ impl State {
         let mut rng = rand::thread_rng();
         let mut token = self.pull_data_token.lock().unwrap();
         *token = rng.gen();
-        return *token;
+        *token
     }
 
     fn get_pull_data_token(&self) -> u16 {
@@ -54,7 +54,7 @@ impl State {
         let mut rng = rand::thread_rng();
         let mut token = self.push_data_token.lock().unwrap();
         *token = rng.gen();
-        return *token;
+        *token
     }
 
     fn get_push_data_token(&self) -> u16 {
@@ -63,7 +63,7 @@ impl State {
 
     fn incr_push_data_sent(&self) {
         let mut sent = self.push_data_sent.lock().unwrap();
-        *sent = *sent + 1;
+        *sent += 1;
     }
 
     fn get_and_reset_push_data_sent(&self) -> u32 {
@@ -75,7 +75,7 @@ impl State {
 
     fn incr_push_data_acked(&self) {
         let mut acked = self.push_data_acked.lock().unwrap();
-        *acked = *acked + 1;
+        *acked += 1;
     }
 
     fn get_and_reset_push_data_acked(&self) -> u32 {
@@ -87,14 +87,14 @@ impl State {
 
     fn incr_rxfw(&self) {
         let mut rxfw = self.rxfw.lock().unwrap();
-        *rxfw = *rxfw + 1;
+        *rxfw += 1;
     }
 
     fn get_and_reset_rxfw(&self) -> u32 {
         let mut rxfw = self.rxfw.lock().unwrap();
         let out = *rxfw;
         *rxfw = 0;
-        return out;
+        out
     }
 }
 
@@ -114,14 +114,14 @@ pub fn start(conf: &Server, event_url: String, command_url: String, gateway_id:
 
         // setup state
         let state = State {
+            socket,
             server: conf.server.clone(),
             keepalive_interval: match conf.keepalive_interval_secs {
                 0 => time::Duration::from_secs(5),
                 _ => time::Duration::from_secs(conf.keepalive_interval_secs),
             },
             keepalive_max_failures: conf.keepalive_max_failures,
             gateway_id: gateway_id.clone(),
-            socket: socket,
             push_data_token: Mutex::new(0),
             push_data_sent: Mutex::new(0),
             push_data_acked: Mutex::new(0),
@@ -192,7 +192,7 @@ fn pull_data_loop(state: Arc<State>, signal_pool: signals::SignalPool) {
                 state.server,
                 state.get_pull_data_token()
             );
-            missed_acks = missed_acks + 1;
+            missed_acks += 1;
         } else {
             missed_acks = 0;
         }
@@ -233,7 +233,10 @@ fn udp_receive_loop(state: Arc<State>, stop_receive: Receiver<signals::Signal>)
     let mut buffer: [u8; 65535] = [0; 65535];
 
     loop {
-        if let Ok(_) = stop_receive.recv_timeout(time::Duration::from_millis(0)) {
+        if stop_receive
+            .recv_timeout(time::Duration::from_millis(0))
+            .is_ok()
+        {
             debug!("Terminating UDP receive loop, server: {}", state.server);
             return;
         };
@@ -298,17 +301,20 @@ fn events_loop(state: Arc<State>, stop_receive: Receiver<signals::Signal>) {
     let reader = events::Reader::new(&event_sock, time::Duration::from_millis(100));
 
     for cmd in reader {
-        if let Ok(_) = stop_receive.recv_timeout(time::Duration::from_millis(0)) {
+        if stop_receive
+            .recv_timeout(time::Duration::from_millis(0))
+            .is_ok()
+        {
             debug!("Terminating events loop, server: {}", state.server);
             return;
         }
 
         match cmd {
             events::Event::Uplink(up) => {
-                events_up(&state, up);
+                events_up(&state, *up);
             }
             events::Event::Stats(stats) => {
-                events_stats(&state, stats);
+                events_stats(&state, *stats);
             }
             events::Event::Timeout => {
                 continue;
@@ -367,10 +373,10 @@ fn events_stats(state: &Arc<State>, stats: chirpstack_api::gw::GatewayStats) {
 }
 
 fn events_up(state: &Arc<State>, up: chirpstack_api::gw::UplinkFrame) {
-    let rxpk = match structs::RXPK::from_proto(&up) {
+    let rxpk = match structs::RxPk::from_proto(&up) {
         Ok(v) => v,
         Err(err) => {
-            error!("RXPK from proto message error: {}", err);
+            error!("RxPk from proto message error: {}", err);
             return;
         }
     };
@@ -404,7 +410,7 @@ fn events_up(state: &Arc<State>, up: chirpstack_api::gw::UplinkFrame) {
 }
 
 fn handle_push_ack(state: &Arc<State>, data: &[u8]) -> Result<(), String> {
-    let push_ack = structs::PushAck::from_bytes(&data)?;
+    let push_ack = structs::PushAck::from_bytes(data)?;
     let expected_token = state.get_push_data_token();
 
     if push_ack.random_token == expected_token {
@@ -445,7 +451,7 @@ fn handle_pull_resp(state: &Arc<State>, data: &[u8]) -> Result<(), String> {
     {
         Ok(v) => v,
         Err(err) => {
-            return Err(format!("TXPK to proto error: {}", err).to_string());
+            return Err(format!("TxPk to proto error: {}", err));
         }
     };
 
@@ -468,7 +474,7 @@ fn handle_pull_resp(state: &Arc<State>, data: &[u8]) -> Result<(), String> {
     let tx_ack = match chirpstack_api::gw::DownlinkTxAck::decode(resp_b) {
         Ok(v) => v,
         Err(err) => {
-            return Err(format!("decode DownlinkTxAck error: {}", err).to_string());
+            return Err(format!("decode DownlinkTxAck error: {}", err));
         }
     };
 

src/helpers.rs

@@ -18,5 +18,5 @@ pub fn get_gateway_id(command_url: &str) -> Result<Vec<u8>, String> {
 
     // read 'gateway_id' response
     let gateway_id = sock.recv_bytes(0).unwrap();
-    return Ok(gateway_id);
+    Ok(gateway_id)
 }

src/logging.rs

@@ -8,11 +8,11 @@ pub fn setup(name: &str, level: log::Level, syslog: bool) -> Result<(), String>
             facility: Facility::LOG_USER,
             hostname: None,
             process: name.to_string(),
-            pid: process::id() as u32,
+            pid: process::id(),
         };
         let logger = match syslog::unix(formatter) {
             Ok(v) => v,
-            Err(err) => return Err(format!("create syslog logger error: {}", err).to_string()),
+            Err(err) => return Err(format!("create syslog logger error: {}", err)),
         };
 
         log::set_boxed_logger(Box::new(BasicLogger::new(logger)))
@@ -22,5 +22,5 @@ pub fn setup(name: &str, level: log::Level, syslog: bool) -> Result<(), String>
         simple_logger::init_with_level(level).unwrap();
     }
 
-    return Ok(());
+    Ok(())
 }

src/main.rs

@@ -33,7 +33,7 @@ fn main() {
         log::Level::from_str(&config.udp_forwarder.log_level).expect("parse log_level error");
 
     logging::setup(
-        &"chirpstack-udp-forwarder",
+        "chirpstack-udp-forwarder",
         log_level,
         config.udp_forwarder.log_to_syslog,
     )
@@ -69,9 +69,9 @@ fn main() {
     }
 
     // metrics
-    if config.udp_forwarder.metrics_bind != "" {
+    if !config.udp_forwarder.metrics_bind.is_empty() {
         threads.push(thread::spawn({
-            let bind = config.udp_forwarder.metrics_bind.clone();
+            let bind = config.udp_forwarder.metrics_bind;
             move || metrics::start(bind)
         }));
     }

src/metrics.rs

@@ -69,7 +69,7 @@ fn handle_request(stream: TcpStream) {
 
 fn handle_read(mut stream: &TcpStream) {
     let mut buffer = [0; 1024];
-    stream.read(&mut buffer).unwrap();
+    let _ = stream.read(&mut buffer).unwrap();
 }
 
 fn handle_write(mut stream: TcpStream) {
@@ -89,6 +89,5 @@ fn handle_write(mut stream: TcpStream) {
 
     if let Err(err) = stream.write(&buffer) {
         error!("Write metrics error: {}", err);
-        return;
     };
 }

src/signals.rs

@@ -17,7 +17,7 @@ impl SignalPool {
     pub fn new_receiver(&mut self) -> Receiver<Signal> {
         let (sender, receiver) = channel();
         self.senders.push(sender);
-        return receiver;
+        receiver
     }
 
     pub fn send_signal(self, signal: Signal) {