route fixes

veilid-core/src/network_manager/wasm/protocol/ws.rs

@@ -11,12 +11,20 @@ struct WebsocketNetworkConnectionInner {
 
 fn to_io(err: WsErr) -> io::Error {
     match err {
-        WsErr::InvalidWsState { supplied: _ } => io::Error::new(io::ErrorKind::InvalidInput, err.to_string()),
+        WsErr::InvalidWsState { supplied: _ } => {
+            io::Error::new(io::ErrorKind::InvalidInput, err.to_string())
+        }
         WsErr::ConnectionNotOpen => io::Error::new(io::ErrorKind::NotConnected, err.to_string()),
-        WsErr::InvalidUrl { supplied: _ } => io::Error::new(io::ErrorKind::InvalidInput, err.to_string()),
-        WsErr::InvalidCloseCode { supplied: _ } => io::Error::new(io::ErrorKind::InvalidInput, err.to_string()),
+        WsErr::InvalidUrl { supplied: _ } => {
+            io::Error::new(io::ErrorKind::InvalidInput, err.to_string())
+        }
+        WsErr::InvalidCloseCode { supplied: _ } => {
+            io::Error::new(io::ErrorKind::InvalidInput, err.to_string())
+        }
         WsErr::ReasonStringToLong => io::Error::new(io::ErrorKind::InvalidInput, err.to_string()),
-        WsErr::ConnectionFailed { event: _ }  => io::Error::new(io::ErrorKind::ConnectionRefused, err.to_string()),
+        WsErr::ConnectionFailed { event: _ } => {
+            io::Error::new(io::ErrorKind::ConnectionRefused, err.to_string())
+        }
         WsErr::InvalidEncoding => io::Error::new(io::ErrorKind::InvalidInput, err.to_string()),
         WsErr::CantDecodeBlob => io::Error::new(io::ErrorKind::InvalidInput, err.to_string()),
         WsErr::UnknownDataType => io::Error::new(io::ErrorKind::InvalidInput, err.to_string()),
@@ -80,19 +88,19 @@ impl WebsocketNetworkConnection {
         let out = match SendWrapper::new(self.inner.ws_stream.clone().next()).await {
             Some(WsMessage::Binary(v)) => {
                 if v.len() > MAX_MESSAGE_SIZE {
-                    return Err(io::Error::new(
-                        io::ErrorKind::InvalidData,
-                        "too large ws message",
-                    ));
+                    return Ok(NetworkResult::invalid_message("too large ws message"));
                 }
                 NetworkResult::Value(v)
             }
-            Some(_) => NetworkResult::NoConnection(io::Error::new(
+            Some(_) => NetworkResult::no_connection_other(io::Error::new(
                 io::ErrorKind::ConnectionReset,
                 "Unexpected WS message type",
             )),
             None => {
-                bail_io_error_other!("WS stream closed");
+                return Ok(NetworkResult::no_connection(io::Error::new(
+                    io::ErrorKind::ConnectionReset,
+                    "WS stream closed",
+                )));
             }
         };
         // tracing::Span::current().record("network_result", &tracing::field::display(&out));
@@ -126,7 +134,7 @@ impl WebsocketProtocolHandler {
         let fut = SendWrapper::new(timeout(timeout_ms, async move {
             WsMeta::connect(request, None).await.map_err(to_io)
         }));
-        
+
         let (wsmeta, wsio) = network_result_try!(network_result_try!(fut
             .await
             .into_network_result())

veilid-core/src/routing_table/route_spec_store.rs

@@ -1087,7 +1087,7 @@ impl RouteSpecStore {
                 && detail.1.sequencing >= sequencing
                 && detail.1.hops.len() >= min_hop_count
                 && detail.1.hops.len() <= max_hop_count
-                && detail.1.directions.is_subset(directions)
+                && detail.1.directions.is_superset(directions)
                 && !detail.1.published
                 && !detail.1.stats.needs_testing(cur_ts)
             {
@@ -1742,6 +1742,11 @@ impl RouteSpecStore {
         F: FnOnce(&mut RouteStats) -> R,
     {
         let inner = &mut *self.inner.lock();
+
+        // Check for stub route
+        if *key == self.unlocked_inner.routing_table.node_id() {
+            return None;
+        }
         // Check for local route
         if let Some(rsd) = Self::detail_mut(inner, key) {
             return Some(f(&mut rsd.stats));

veilid-core/src/veilid_api/debug.rs

@@ -701,10 +701,17 @@ impl VeilidAPI {
         let rss = routing_table.route_spec_store();
 
         let routes = rss.list_allocated_routes(|k, _| Some(*k));
-        let mut out = format!("Routes: (count = {}):\n", routes.len());
+        let mut out = format!("Allocated Routes: (count = {}):\n", routes.len());
         for r in routes {
             out.push_str(&format!("{}\n", r.encode()));
         }
+
+        let remote_routes = rss.list_remote_routes(|k, _| Some(*k));
+        let mut out = format!("Remote Routes: (count = {}):\n", remote_routes.len());
+        for r in remote_routes {
+            out.push_str(&format!("{}\n", r.encode()));
+        }
+
         Ok(out)
     }
     async fn debug_route_import(&self, args: Vec<String>) -> Result<String, VeilidAPIError> {
@@ -858,9 +865,9 @@ impl VeilidAPI {
                 Ok(">>> Unknown command\n".to_owned())
             }
         };
-        if let Ok(res) = &res {
-            debug!("{}", res);
-        }
+        // if let Ok(res) = &res {
+        //     debug!("{}", res);
+        // }
         res
     }
 }