Merge pull request #10 from brummer-simon/fix-clippy-lints

Fix lints found by clippy and some minor cleanup

Author: brummer-simon

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "reachable"
-version = "0.2.1"
+version = "0.2.2"
 edition = "2021"
 authors = ["Simon Brummer <[email protected]>"]
 description = "Check if a Target (ICMP, TCP, custom) is reachable."

README.md

@@ -7,7 +7,7 @@ an async task executor to perform availability checks of "Targets" on a regular
 ## Usage
 
 With this crate you can easily check if a computer is currently reachable over the network.
-Since all targets are implementations of trait "Target" the availabilty check behavior is customizable.
+Since all targets are implementations of trait "Target" the availability check behavior is customizable.
 For example, it is easy to implement a custom Target to check if a Process is
 running or not.
 
@@ -19,7 +19,7 @@ use std::str::FromStr;
 use reachable::*;
 
 fn main() {
-    // Construct ICMP Target and if its availabile
+    // Construct ICMP Target check if the target is availabile
     let icmp_target = IcmpTarget::from_str("www.google.de").unwrap();
     match icmp_target.check_availability() {
         Ok(status) => println!("{} is {}", icmp_target.get_id(), status),

examples/usage/src/main.rs

@@ -9,7 +9,7 @@ use std::str::FromStr;
 use reachable::*;
 
 fn main() {
-    // Construct ICMP Target and if its availability
+    // Construct ICMP Target check if the target is availabile
     let icmp_target = IcmpTarget::from_str("www.google.de").unwrap();
     match icmp_target.check_availability() {
         Ok(status) => println!("{} is {}", icmp_target.get_id(), status),

src/async_target.rs

@@ -23,13 +23,19 @@ use tokio::time::{self};
 /// check and the current availability check
 pub type OldStatus = Status;
 
+/// Type for a boxed trait object implementing [Target]
+type BoxedTarget<'a> = Box<dyn Target + Send + 'a>;
+
+/// Type containing a boxed trait object implementing [FnMut] that is called with each async check.
+type BoxedHandler<'a> = Box<dyn FnMut(&dyn Target, Status, OldStatus, Option<CheckTargetError>) + Send + 'a>;
+
 /// Struct storing all data used during asynchronous execution.
 ///
 /// For async check execution, wrap the instances of [Target] in [AsyncTarget] and hand them to
 /// [AsyncTargetExecutor::start].
 pub struct AsyncTarget<'a> {
-    target: Box<dyn Target + Send + 'a>,
-    check_handler: Box<dyn FnMut(&dyn Target, Status, OldStatus, Option<CheckTargetError>) + Send + 'a>,
+    target: BoxedTarget<'a>,
+    check_handler: BoxedHandler<'a>,
     check_interval: Duration,
     status: Status,
 }
@@ -44,15 +50,11 @@ impl<'a> AsyncTarget<'a> {
     ///
     /// # Returns
     /// Instance of [AsyncTarget].
-    pub fn new(
-        target: Box<dyn Target + Send + 'a>,
-        check_handler: Box<dyn FnMut(&dyn Target, Status, OldStatus, Option<CheckTargetError>) + Send + 'a>,
-        check_interval: Duration,
-    ) -> Self {
+    pub fn new(target: BoxedTarget<'a>, check_handler: BoxedHandler<'a>, check_interval: Duration) -> Self {
         AsyncTarget {
-            target: target,
-            check_handler: check_handler,
-            check_interval: check_interval,
+            target,
+            check_handler,
+            check_interval,
             status: Status::Unknown,
         }
     }
@@ -152,13 +154,19 @@ impl AsyncTargetExecutor {
     }
 }
 
+impl Default for AsyncTargetExecutor {
+    fn default() -> Self {
+        AsyncTargetExecutor::new()
+    }
+}
+
 impl Drop for AsyncTargetExecutor {
     fn drop(&mut self) {
         self.stop()
     }
 }
 
-async fn check_target_periodically(mut target: AsyncTarget<'static>, mut teardown_recv: Receiver<()>) -> () {
+async fn check_target_periodically(mut target: AsyncTarget<'static>, mut teardown_recv: Receiver<()>) {
     loop {
         target = select! {
             // Teardown message was not received. Perform next check.
@@ -170,7 +178,7 @@ async fn check_target_periodically(mut target: AsyncTarget<'static>, mut teardow
     }
 }
 
-async fn check_target(mut target: AsyncTarget<'static>) -> AsyncTarget<'_> {
+async fn check_target(mut target: AsyncTarget<'static>) -> AsyncTarget<'static> {
     // Setup sleep timer to wait, to prevent further execution before the check_interval elapsed.
     let sleep = time::sleep(target.check_interval);
 

src/resolve_policy.rs

@@ -37,8 +37,8 @@ impl ResolvePolicy {
     ///
     /// # Returns
     /// * On success, vector containing all ip addresses the fqhn resolved to.
-    /// * On failure, a [ResolveTargetError]. Either failed the name resolution itself or all
-    ///   addresses were filtered out according to [ResolvePolicy].
+    /// * On failure, a [ResolveTargetError]. Either failed the name resolution itself or all addresses were filtered
+    ///   out according to [ResolvePolicy].
     ///
     /// # Example
     /// ```

src/target.rs

@@ -50,8 +50,7 @@ pub trait Target {
     ///
     /// # Returns
     /// * On success, the current [Status] of this [Target].
-    /// * On failure, a [CheckTargetError]. This error should be returned in case some internal
-    ///   error occurred.
+    /// * On failure, a [CheckTargetError]. This error should be returned in case some internal error occurred.
     ///
     /// # Notes
     /// This method should be implemented in a non-blocking way to improve performance then used
@@ -119,8 +118,8 @@ impl IcmpTarget {
     /// For more convenience use the implementations of trait "From" and "FromStr".
     pub fn new(fqhn: Fqhn, resolve_policy: ResolvePolicy) -> Self {
         IcmpTarget {
-            fqhn: fqhn,
-            resolve_policy: resolve_policy,
+            fqhn,
+            resolve_policy,
         }
     }
 
@@ -248,10 +247,10 @@ impl TcpTarget {
     /// For more convenience use the implementations of trait "From" and "FromStr".
     pub fn new(fqhn: Fqhn, port: Port, connect_timeout: Duration, resolve_policy: ResolvePolicy) -> Self {
         TcpTarget {
-            fqhn: fqhn,
-            port: port,
-            connect_timeout: connect_timeout,
-            resolve_policy: resolve_policy,
+            fqhn,
+            port,
+            connect_timeout,
+            resolve_policy,
         }
     }
 
@@ -300,16 +299,12 @@ impl Target for TcpTarget {
         // Network services should be able to deal with this behavior.
 
         // Resolve and construct address/port pairs
-        let addrs = self.resolve_policy.resolve(&self.fqhn)?;
-        let sock_addrs: Vec<SocketAddr> = addrs
-            .into_iter()
-            .map(|addr| SocketAddr::from((addr, self.port)))
-            .collect();
-
         // Try for each address/port pair to establish a connection.
         // Occurring errors are treated as a sign of target is not available.
-        let available = sock_addrs
+        let addrs = self.resolve_policy.resolve(&self.fqhn)?;
+        let available = addrs
             .into_iter()
+            .map(|addr| SocketAddr::from((addr, self.port)))
             .any(|addr| TcpStream::connect_timeout(&addr, self.connect_timeout).is_ok());
 
         if available {
@@ -388,8 +383,8 @@ impl FromStr for TcpTarget {
             let maybe_port = &s[index + 1..];
             match maybe_port.parse() as Result<u16, ParseIntError> {
                 Ok(port) => {
-                    if port <= 0 {
-                        Err(ParseTargetError::from("Invalid Portnumber 0 found"))
+                    if port == 0 {
+                        Err(ParseTargetError::from("Invalid Portnumber '0' found"))
                     } else {
                         Ok(TcpTarget::new(
                             fqhn,
@@ -607,7 +602,7 @@ mod tests {
         // Expectency: The TcpTarget returns an error if portnumber is 0 (invalid port).
         assert_eq!(
             format!("{}", TcpTarget::from_str("foo:0").unwrap_err()),
-            "Invalid Portnumber 0 found"
+            "Invalid Portnumber '0' found"
         );
     }