lints

veilid-core/src/intf/wasm/network/mod.rs

@@ -24,7 +24,7 @@ pub struct Network {
 impl Network {
     fn new_inner(network_manager: NetworkManager) -> NetworkInner {
         NetworkInner {
-            network_manager: network_manager,
+            network_manager,
             stop_network: Eventual::new(),
             network_needs_restart: false,
             //join_handle: None,

veilid-core/src/intf/wasm/network/protocol/ws.rs

@@ -7,7 +7,6 @@ use web_sys::WebSocket;
 use ws_stream_wasm::*;
 
 struct WebsocketNetworkConnectionInner {
-    _ws_meta: WsMeta,
     ws_stream: WsStream,
     ws: WebSocket,
 }
@@ -36,11 +35,10 @@ impl WebsocketNetworkConnection {
     pub fn new(tls: bool, ws_meta: WsMeta, ws_stream: WsStream) -> Self {
         let ws = ws_stream.wrapped().clone();
         Self {
-            tls: tls,
+            tls,
             inner: Arc::new(Mutex::new(WebsocketNetworkConnectionInner {
-                _ws_meta: ws_meta,
-                ws_stream: ws_stream,
-                ws: ws,
+                ws_stream,
+                ws,
             })),
         }
     }
@@ -91,19 +89,19 @@ impl WebsocketProtocolHandler {
     pub async fn connect(
         network_manager: NetworkManager,
         dial_info: &DialInfo,
-    ) -> Result<NetworkConnection, ()> {
+    ) -> Result<NetworkConnection, String> {
         let url = dial_info.to_url_string(None);
         let (tls, host, port, protocol_type) = match dial_info {
             DialInfo::WS(ws) => (false, ws.fqdn.clone(), ws.port, ProtocolType::WS),
             DialInfo::WSS(wss) => (true, wss.fqdn.clone(), wss.port, ProtocolType::WSS),
-            _ => return Err(()),
+            _ => return Err("wrong protocol for WebsocketProtocolHandler".to_owned()),
         };
 
         let peer_addr = PeerAddress::new(Address::from_str(&host)?, port, protocol_type);
 
         let (ws, wsio) = match WsMeta::connect(url, None).await {
             Ok(conn) => conn,
-            Err(_) => return Err(()),
+            Err(e) => return Err(format!("couldn't connect to WS url: {}", e)),
         };
 
         let conn = NetworkConnection::WS(WebsocketNetworkConnection::new(tls, ws, wsio));

veilid-core/src/intf/wasm/table_store.rs

@@ -16,7 +16,7 @@ pub struct TableStore {
 impl TableStore {
     fn new_inner(config: VeilidConfig) -> TableStoreInner {
         TableStoreInner {
-            config: config,
+            config,
             opened: BTreeMap::new(),
         }
     }

veilid-core/src/intf/wasm/utils/channel.rs

@@ -37,7 +37,7 @@ impl<T> Clone for Receiver<T> {
 pub fn channel<T>(cap: usize) -> (Sender<T>, Receiver<T>) {
     let imp = Channel {
         items: VecDeque::with_capacity(cap),
-        cap: cap,
+        cap,
         eventual: Eventual::new(),
     };