more sequencing

veilid-core/src/network_manager/mod.rs

@@ -878,6 +878,7 @@ impl NetworkManager {
         data: &mut [u8],
         connection_descriptor: ConnectionDescriptor,
     ) -> EyreResult<bool> {
+        #[cfg(feature="verbose-tracing")]
         let root = span!(
             parent: None,
             Level::TRACE,
@@ -885,6 +886,7 @@ impl NetworkManager {
             "data.len" = data.len(),
             "descriptor" = ?connection_descriptor
         );
+        #[cfg(feature="verbose-tracing")]
         let _root_enter = root.enter();
 
         log_net!(
@@ -1017,6 +1019,17 @@ impl NetworkManager {
             };
 
             if let Some(relay_nr) = some_relay_nr {
+                // Force sequencing if this came in sequenced. 
+                // The sender did the prefer/ensure calculation when it did get_contact_method,
+                // so we don't need to do it here.
+                let relay_nr = if connection_descriptor.remote().protocol_type().is_ordered() {
+                    let mut relay_nr = relay_nr.clone();
+                    relay_nr.set_sequencing(Sequencing::EnsureOrdered);
+                    relay_nr
+                } else {
+                    relay_nr
+                };
+
                 // Relay the packet to the desired destination
                 log_net!("relaying {} bytes to {}", data.len(), relay_nr);
 

veilid-core/src/network_manager/send_data.rs

@@ -342,21 +342,24 @@ impl NetworkManager {
             ContactMethod::Existing => NodeContactMethod::Existing,
             ContactMethod::Direct(di) => NodeContactMethod::Direct(di),
             ContactMethod::SignalReverse(relay_key, target_key) => {
-                let relay_nr = routing_table
+                let mut relay_nr = routing_table
                     .lookup_and_filter_noderef(relay_key, routing_domain.into(), dial_info_filter)?
                     .ok_or_else(|| eyre!("couldn't look up relay"))?;
                 if !target_node_ref.node_ids().contains(&target_key) {
                     bail!("signalreverse target noderef didn't match target key: {:?} != {} for relay {}", target_node_ref, target_key, relay_key );
                 }
+                relay_nr.set_sequencing(sequencing);
                 NodeContactMethod::SignalReverse(relay_nr, target_node_ref)
             }
             ContactMethod::SignalHolePunch(relay_key, target_key) => {
-                let relay_nr = routing_table
+                let mut relay_nr = routing_table
                     .lookup_and_filter_noderef(relay_key, routing_domain.into(), dial_info_filter)?
                     .ok_or_else(|| eyre!("couldn't look up relay"))?;
                 if !target_node_ref.node_ids().contains(&target_key) {
                     bail!("signalholepunch target noderef didn't match target key: {:?} != {} for relay {}", target_node_ref, target_key, relay_key );
                 }
+                relay_nr.set_sequencing(sequencing);
+
                 // if any other protocol were possible here we could update this and do_hole_punch
                 // but tcp hole punch is very very unreliable it seems
                 let udp_target_node_ref = target_node_ref
@@ -365,15 +368,17 @@ impl NetworkManager {
                 NodeContactMethod::SignalHolePunch(relay_nr, udp_target_node_ref)
             }
             ContactMethod::InboundRelay(relay_key) => {
-                let relay_nr = routing_table
+                let mut relay_nr = routing_table
                     .lookup_and_filter_noderef(relay_key, routing_domain.into(), dial_info_filter)?
                     .ok_or_else(|| eyre!("couldn't look up relay"))?;
+                relay_nr.set_sequencing(sequencing);
                 NodeContactMethod::InboundRelay(relay_nr)
             }
             ContactMethod::OutboundRelay(relay_key) => {
-                let relay_nr = routing_table
+                let mut relay_nr = routing_table
                     .lookup_and_filter_noderef(relay_key, routing_domain.into(), dial_info_filter)?
                     .ok_or_else(|| eyre!("couldn't look up relay"))?;
+                relay_nr.set_sequencing(sequencing);
                 NodeContactMethod::OutboundRelay(relay_nr)
             }
         };

veilid-core/src/network_manager/types/connection_descriptor.rs

@@ -30,9 +30,7 @@ pub struct ConnectionDescriptor {
 
 impl ConnectionDescriptor {
     pub fn new(remote: PeerAddress, local: SocketAddress) -> Self {
-        assert!(
-            !remote.protocol_type().is_connection_oriented() || !local.address().is_unspecified()
-        );
+        assert!(!remote.protocol_type().is_ordered() || !local.address().is_unspecified());
 
         Self {
             remote,

veilid-core/src/network_manager/types/protocol_type.rs

@@ -25,7 +25,7 @@ pub enum ProtocolType {
 }
 
 impl ProtocolType {
-    pub fn is_connection_oriented(&self) -> bool {
+    pub fn is_ordered(&self) -> bool {
         matches!(
             self,
             ProtocolType::TCP | ProtocolType::WS | ProtocolType::WSS