Implement anyhow::Result.

Author: brocaar

Cargo.lock

@@ -27,3 +27,4 @@ prost = "0.11"
 pbjson-types = "0.5"
 prometheus = "0.13"
 lazy_static = "1.4"
+anyhow = "1.0"

Cargo.toml

@@ -1,6 +1,8 @@
+use anyhow::Result;
+
 use super::socket::ZMQ_CONTEXT;
 
-pub fn get_socket(endpoint: &str) -> Result<zmq::Socket, zmq::Error> {
+pub fn get_socket(endpoint: &str) -> Result<zmq::Socket> {
     info!(
         "Creating new socket for sending commands, endpoint: {}",
         endpoint

src/commands.rs

@@ -1,5 +1,6 @@
 use std::fs;
 
+use anyhow::Result;
 use serde::Deserialize;
 
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
@@ -33,19 +34,19 @@ pub struct Configuration {
 }
 
 impl Configuration {
-    pub fn get(filenames: &[String]) -> Result<Configuration, String> {
+    pub fn get(filenames: &[String]) -> Result<Configuration> {
         let mut content: String = String::new();
 
         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)),
+                Err(err) => return Err(anyhow!("read config file error: {}", err)),
             });
         }
 
         let config: Configuration = match toml::from_str(&content) {
             Ok(v) => v,
-            Err(err) => return Err(format!("parse config file error: {}", err)),
+            Err(err) => return Err(anyhow!("parse config file error: {}", err)),
         };
 
         Ok(config)

src/config.rs

@@ -1,5 +1,6 @@
 use std::time::Duration;
 
+use anyhow::Result;
 use prost::Message;
 
 use super::socket::ZMQ_CONTEXT;
@@ -60,44 +61,35 @@ 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)),
+            Err(err) => Some(Event::Error(err.to_string())),
         }
     }
 }
 
-fn handle_message(msg: Vec<Vec<u8>>) -> Result<Event, String> {
+fn handle_message(msg: Vec<Vec<u8>>) -> Result<Event> {
     if msg.len() != 2 {
-        return Err("event must have two frames".to_string());
+        return Err(anyhow!("Event must have two frames"));
     }
 
-    let event = match String::from_utf8(msg[0].clone()) {
-        Ok(v) => v,
-        Err(err) => return Err(err.to_string()),
-    };
+    let event = String::from_utf8(msg[0].clone())?;
 
     Ok(match event.as_str() {
         "up" => match parse_up(&msg[1]) {
             Ok(v) => Event::Uplink(Box::new(v)),
-            Err(err) => Event::Error(err),
+            Err(err) => Event::Error(err.to_string()),
         },
         "stats" => match parse_stats(&msg[1]) {
             Ok(v) => Event::Stats(Box::new(v)),
-            Err(err) => Event::Error(err),
+            Err(err) => Event::Error(err.to_string()),
         },
         _ => Event::Unknown(event, msg[1].clone()),
     })
 }
 
-fn parse_up(msg: &[u8]) -> Result<chirpstack_api::gw::UplinkFrame, String> {
-    match chirpstack_api::gw::UplinkFrame::decode(msg) {
-        Ok(v) => Ok(v),
-        Err(err) => Err(err.to_string()),
-    }
+fn parse_up(msg: &[u8]) -> Result<chirpstack_api::gw::UplinkFrame> {
+    Ok(chirpstack_api::gw::UplinkFrame::decode(msg)?)
 }
 
-fn parse_stats(msg: &[u8]) -> Result<chirpstack_api::gw::GatewayStats, String> {
-    match chirpstack_api::gw::GatewayStats::decode(msg) {
-        Ok(v) => Ok(v),
-        Err(err) => Err(err.to_string()),
-    }
+fn parse_stats(msg: &[u8]) -> Result<chirpstack_api::gw::GatewayStats> {
+    Ok(chirpstack_api::gw::GatewayStats::decode(msg)?)
 }

src/events.rs

@@ -3,6 +3,7 @@ use std::sync::mpsc::Receiver;
 use std::sync::{Arc, Mutex};
 use std::{thread, time};
 
+use anyhow::Result;
 use prost::Message;
 use rand::Rng;
 
@@ -409,7 +410,7 @@ fn events_up(state: &Arc<State>, up: chirpstack_api::gw::UplinkFrame) {
     metrics::incr_udp_sent_bytes(&state.server, "PUSH_DATA_RXPK", bytes.len());
 }
 
-fn handle_push_ack(state: &Arc<State>, data: &[u8]) -> Result<(), String> {
+fn handle_push_ack(state: &Arc<State>, data: &[u8]) -> Result<()> {
     let push_ack = structs::PushAck::from_bytes(data)?;
     let expected_token = state.get_push_data_token();
 
@@ -425,7 +426,7 @@ fn handle_push_ack(state: &Arc<State>, data: &[u8]) -> Result<(), String> {
     Ok(())
 }
 
-fn handle_pull_ack(state: &Arc<State>, data: &[u8]) -> Result<(), String> {
+fn handle_pull_ack(state: &Arc<State>, data: &[u8]) -> Result<()> {
     let push_ack = structs::PullAck::from_bytes(data)?;
     let expected_token = state.get_pull_data_token();
     state.set_pull_data_token_acked(push_ack.random_token);
@@ -440,7 +441,7 @@ fn handle_pull_ack(state: &Arc<State>, data: &[u8]) -> Result<(), String> {
     Ok(())
 }
 
-fn handle_pull_resp(state: &Arc<State>, data: &[u8]) -> Result<(), String> {
+fn handle_pull_resp(state: &Arc<State>, data: &[u8]) -> Result<()> {
     let pull_resp = structs::PullResp::from_bytes(data)?;
     let sock = state.command_sock.lock().unwrap();
 
@@ -451,7 +452,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));
+            return Err(anyhow!("TxPk to proto error: {}", err));
         }
     };
 
@@ -466,15 +467,15 @@ fn handle_pull_resp(state: &Arc<State>, data: &[u8]) -> Result<(), String> {
     let mut items = [sock.as_poll_item(zmq::POLLIN)];
     zmq::poll(&mut items, 100).unwrap();
     if !items[0].is_readable() {
-        return Err("could not read down response".to_string());
+        return Err(anyhow!("could not read down response"));
     }
 
     // read tx ack response.
     let resp_b: &[u8] = &sock.recv_bytes(0).unwrap();
     let tx_ack = match chirpstack_api::gw::DownlinkTxAck::decode(resp_b) {
         Ok(v) => v,
         Err(err) => {
-            return Err(format!("decode DownlinkTxAck error: {}", err));
+            return Err(anyhow!("decode DownlinkTxAck error: {}", err));
         }
     };
 
@@ -490,7 +491,7 @@ fn handle_pull_resp(state: &Arc<State>, data: &[u8]) -> Result<(), String> {
             txpk_ack: structs::TxAckPayloadError {
                 error: {
                     if tx_ack.items.len() != 1 {
-                        return Err("".to_string());
+                        return Err(anyhow!(""));
                     }
 
                     match tx_ack.items[0].status() {

src/forwarder.rs

@@ -1,6 +1,8 @@
+use anyhow::Result;
+
 use super::commands;
 
-pub fn get_gateway_id(command_url: &str) -> Result<Vec<u8>, String> {
+pub fn get_gateway_id(command_url: &str) -> Result<Vec<u8>> {
     debug!("Reading gateway id, server: {}", command_url);
 
     let sock = commands::get_socket(command_url).expect("get client error");
@@ -13,7 +15,7 @@ pub fn get_gateway_id(command_url: &str) -> Result<Vec<u8>, String> {
     let mut items = [sock.as_poll_item(zmq::POLLIN)];
     zmq::poll(&mut items, 100).unwrap();
     if !items[0].is_readable() {
-        return Err("could not read gateway_id".to_string());
+        return Err(anyhow!("could not read gateway_id"));
     }
 
     // read 'gateway_id' response

src/helpers.rs

@@ -1,8 +1,9 @@
 use std::process;
 
+use anyhow::Result;
 use syslog::{BasicLogger, Facility, Formatter3164};
 
-pub fn setup(name: &str, level: log::Level, syslog: bool) -> Result<(), String> {
+pub fn setup(name: &str, level: log::Level, syslog: bool) -> Result<()> {
     if syslog {
         let formatter = Formatter3164 {
             facility: Facility::LOG_USER,
@@ -12,7 +13,7 @@ pub fn setup(name: &str, level: log::Level, syslog: bool) -> Result<(), String>
         };
         let logger = match syslog::unix(formatter) {
             Ok(v) => v,
-            Err(err) => return Err(format!("create syslog logger error: {}", err)),
+            Err(err) => return Err(anyhow!("create syslog logger error: {}", err)),
         };
 
         log::set_boxed_logger(Box::new(BasicLogger::new(logger)))

src/logging.rs

@@ -2,6 +2,8 @@
 extern crate lazy_static;
 #[macro_use]
 extern crate log;
+#[macro_use]
+extern crate anyhow;
 
 use std::str::FromStr;
 use std::thread;