cargo fmt

src/bin/dfi.rs

@@ -1,13 +1,13 @@
 #[macro_use]
 extern crate clap;
 use async_channel::unbounded;
-use std::sync::Arc;
 use async_executor::Executor;
 use async_std::sync::Mutex;
 use easy_parallel::Parallel;
 use log::*;
 use std::collections::HashMap;
 use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+use std::sync::Arc;
 
 use sapvi::{ClientProtocol, Result, SeedProtocol, ServerProtocol};
 
@@ -64,23 +64,26 @@ async fn start(executor: Arc<Executor<'_>>, options: ProgramOptions) -> Result<(
     for i in 0..options.connection_slots {
         debug!("Starting connection slot {}", i);
 
-        let mut client = ClientProtocol::new(connections.clone(), accept_addr.clone(), stored_addrs.clone());
-        client.clone()
-            .start(executor.clone())
-            .await;
+        let mut client = ClientProtocol::new(
+            connections.clone(),
+            accept_addr.clone(),
+            stored_addrs.clone(),
+        );
+        client.clone().start(executor.clone()).await;
         client_slots.push(client);
     }
 
     for remote_addr in options.manual_connects {
         debug!("Starting connection (manual) to {}", remote_addr);
 
-        let mut client = ClientProtocol::new(connections.clone(), accept_addr.clone(),
-                stored_addrs.clone());
-        client.clone()
-            .start_manual(
-                remote_addr,
-                executor.clone(),
-            )
+        let mut client = ClientProtocol::new(
+            connections.clone(),
+            accept_addr.clone(),
+            stored_addrs.clone(),
+        );
+        client
+            .clone()
+            .start_manual(remote_addr, executor.clone())
             .await;
         client_slots.push(client);
     }

src/net/net.rs

@@ -1,4 +1,3 @@
-use std::sync::Arc;
 use futures::prelude::*;
 use log::*;
 use num_enum::{IntoPrimitive, TryFromPrimitive};
@@ -8,6 +7,7 @@ use std::convert::TryFrom;
 use std::io;
 use std::io::Cursor;
 use std::net::{SocketAddr, TcpStream};
+use std::sync::Arc;
 use std::time::Duration;
 
 use crate::async_serial::{AsyncReadExt, AsyncWriteExt};

src/net/protocol/client_protocol.rs

@@ -1,10 +1,10 @@
 use async_std::sync::Mutex;
-use std::sync::Arc;
 use log::*;
 use rand::seq::SliceRandom;
 use smol::{Async, Executor};
 use std::net::{SocketAddr, TcpStream};
 use std::sync::atomic::AtomicU64;
+use std::sync::Arc;
 
 use crate::error::Result;
 use crate::net::net;
@@ -22,9 +22,11 @@ pub struct ClientProtocol {
 }
 
 impl ClientProtocol {
-    pub fn new(connections: ConnectionsMap, accept_addr: Option<SocketAddr>,
-    stored_addrs: AddrsStorage,
-               ) -> Arc<Self> {
+    pub fn new(
+        connections: ConnectionsMap,
+        accept_addr: Option<SocketAddr>,
+        stored_addrs: AddrsStorage,
+    ) -> Arc<Self> {
         let (send_sx, send_rx) = async_channel::unbounded::<net::Message>();
         Arc::new(Self {
             send_sx,
@@ -32,7 +34,7 @@ impl ClientProtocol {
             connections,
             main_process: Mutex::new(None),
             accept_addr,
-            stored_addrs
+            stored_addrs,
         })
     }
 
@@ -66,10 +68,7 @@ impl ClientProtocol {
         }
     }
 
-    pub async fn start(
-        self: Arc<Self>,
-        executor: Arc<Executor<'_>>,
-    ) {
+    pub async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) {
         let executor2 = executor.clone();
         let self2 = self.clone();
 
@@ -94,11 +93,7 @@ impl ClientProtocol {
 
                 debug!("Attempting connect to {}", addr);
 
-                self.try_connect_process(
-                    addr,
-                    executor2.clone(),
-                )
-                .await;
+                self.try_connect_process(addr, executor2.clone()).await;
 
                 // TODO: Fix this
                 net::sleep(2).await;
@@ -119,30 +114,18 @@ impl ClientProtocol {
                 for _ in 0..4 {
                     debug!("Attempting connect to {}", remote_addr);
 
-                    self.try_connect_process(
-                        remote_addr,
-                        executor2.clone(),
-                    )
-                    .await;
+                    self.try_connect_process(remote_addr, executor2.clone())
+                        .await;
                 }
                 net::sleep(2).await;
             }
         }));
     }
 
-    pub async fn try_connect_process(
-        &self,
-        address: SocketAddr,
-        executor: Arc<Executor<'_>>,
-    ) {
+    pub async fn try_connect_process(&self, address: SocketAddr, executor: Arc<Executor<'_>>) {
         match Async::<TcpStream>::connect(address.clone()).await {
             Ok(stream) => {
-                let _ = self.handle_connect(
-                    stream,
-                    address,
-                    executor,
-                )
-                .await;
+                let _ = self.handle_connect(stream, address, executor).await;
             }
             Err(_err) => {
                 warn!("Unable to connect to addr {:?}: {}", address, _err);
@@ -165,12 +148,7 @@ impl ClientProtocol {
             .insert(address.clone(), self.send_sx.clone());
 
         // Run event loop
-        match self.event_loop_process(
-            stream,
-            executor,
-        )
-        .await
-        {
+        match self.event_loop_process(stream, executor).await {
             Ok(()) => {
                 warn!("Server timeout");
             }
@@ -211,7 +189,8 @@ impl ClientProtocol {
 
         let mut send_addr_task = None;
         if let Some(accept_addr) = self.accept_addr {
-            send_addr_task = Some(executor.spawn(Self::send_addr(self.send_sx.clone(), accept_addr.clone())));
+            send_addr_task =
+                Some(executor.spawn(Self::send_addr(self.send_sx.clone(), accept_addr.clone())));
         }
 
         loop {

src/net/protocol/seed_protocol.rs

@@ -1,8 +1,8 @@
-use std::sync::Arc;
 use log::*;
 use smol::{Async, Executor};
 use std::net::{SocketAddr, TcpStream};
 use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
 
 use crate::error::Result;
 use crate::net::net;

src/net/protocol/server_protocol.rs

@@ -1,7 +1,7 @@
-use std::sync::Arc;
 use log::*;
 use smol::{Async, Executor};
 use std::net::{SocketAddr, TcpListener};
+use std::sync::Arc;
 
 //use super::protocol;
 use crate::error::Result;

src/utility.rs

@@ -1,9 +1,9 @@
-use std::sync::Arc;
 use std::collections::HashMap;
 use std::fs::OpenOptions;
 use std::io::prelude::*;
 use std::net::SocketAddr;
 use std::sync::atomic::AtomicU64;
+use std::sync::Arc;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use rand::seq::SliceRandom;