more routingdomain refactor

veilid-core/src/network_manager/mod.rs

@@ -1884,7 +1884,7 @@ impl NetworkManager {
                     unord.push(async move {
                         // Update the node
                         if let Err(e) = rpc
-                            .rpc_call_node_info_update(Destination::Direct(nr.clone()), None)
+                            .rpc_call_node_info_update(nr.clone, routing_domain)
                             .await
                         {
                             // Not fatal, but we should be able to see if this is happening

veilid-core/src/network_manager/native/network_class_discovery.rs

@@ -118,11 +118,13 @@ impl DiscoveryContext {
 
         // Build an filter that matches our protocol and address type
         // and excludes relays so we can get an accurate external address
-        let dial_info_filter = DialInfoFilter::global()
+        let dial_info_filter = DialInfoFilter::all()
             .with_protocol_type(protocol_type)
             .with_address_type(address_type);
-        let inbound_dial_info_entry_filter =
-            RoutingTable::make_inbound_dial_info_entry_filter(dial_info_filter.clone());
+        let inbound_dial_info_entry_filter = RoutingTable::make_inbound_dial_info_entry_filter(
+            RoutingDomain::PublicInternet,
+            dial_info_filter.clone(),
+        );
         let disallow_relays_filter = move |e: &BucketEntryInner| {
             if let Some(n) = e.node_info(RoutingDomain::PublicInternet) {
                 n.relay_peer_info.is_none()
@@ -169,7 +171,7 @@ impl DiscoveryContext {
         protocol_type: ProtocolType,
         address_type: AddressType,
     ) -> Vec<SocketAddress> {
-        let filter = DialInfoFilter::local()
+        let filter = DialInfoFilter::all()
             .with_protocol_type(protocol_type)
             .with_address_type(address_type);
         self.routing_table

veilid-core/src/network_manager/native/start_protocols.rs

@@ -253,12 +253,11 @@ impl Network {
     pub(super) async fn start_udp_listeners(&self) -> EyreResult<()> {
         trace!("starting udp listeners");
         let routing_table = self.routing_table();
-        let (listen_address, public_address, enable_local_peer_scope, detect_address_changes) = {
+        let (listen_address, public_address, detect_address_changes) = {
             let c = self.config.get();
             (
                 c.network.protocol.udp.listen_address.clone(),
                 c.network.protocol.udp.public_address.clone(),
-                c.network.enable_local_peer_scope,
                 c.network.detect_address_changes,
             )
         };
@@ -288,6 +287,9 @@ impl Network {
 
         // Register local dial info
         for di in &local_dial_info_list {
+
+xxx write routing table sieve for routing domain from dialinfo and local network detection and registration
+
             // If the local interface address is global, or we are enabling local peer scope
             // register global dial info if no public address is specified
             if !detect_address_changes

veilid-core/src/network_manager/tasks.rs

@@ -476,7 +476,9 @@ impl NetworkManager {
                 // Otherwise we must need an inbound relay
                 } else {
                     // Find a node in our routing table that is an acceptable inbound relay
-                    if let Some(nr) = routing_table.find_inbound_relay(cur_ts) {
+                    if let Some(nr) =
+                        routing_table.find_inbound_relay(RoutingDomain::PublicInternet, cur_ts)
+                    {
                         info!("Inbound relay node selected: {}", nr);
                         routing_table.set_relay_node(RoutingDomain::PublicInternet, Some(nr));
                         node_info_changed = true;