More minor naming fixes

gateway/src/node/client_handling/active_clients.rs

@@ -12,7 +12,7 @@ enum ActiveClient {
     /// Handle to a remote client connected via a network socket.
     Remote(ClientIncomingChannels),
 
-    /// Handle to a locally (inside the same process) running network requester client.
+    /// Handle to a locally (inside the same process) running client.
     Embedded(LocalEmbeddedClientHandle),
 }
 
@@ -149,13 +149,14 @@ impl ActiveClientsStore {
         }
     }
 
-    /// Inserts a handle to the embedded network requester
-    pub(crate) fn insert_embedded(&self, local_nr_handle: LocalEmbeddedClientHandle) {
-        let key = local_nr_handle.client_destination();
-        let entry = ActiveClient::Embedded(local_nr_handle);
+    /// Inserts a handle to the embedded client
+    pub(crate) fn insert_embedded(&self, local_client_handle: LocalEmbeddedClientHandle) {
+        let key = local_client_handle.client_destination();
+        let entry = ActiveClient::Embedded(local_client_handle);
         if self.inner.insert(key, entry).is_some() {
-            // this is literally impossible since we're starting local NR before even spawning the websocket listener task
-            panic!("somehow we already had a client with the same address as our local NR!")
+            // this is literally impossible since we're starting the local embedded client before
+            // even spawning the websocket listener task
+            panic!("somehow we already had a client with the same address as our local embedded client!")
         }
     }
 

gateway/src/node/client_handling/embedded_clients/mod.rs

@@ -48,7 +48,7 @@ impl LocalEmbeddedClientHandle {
 // calling the method. however, this would have caused slightly more complexity and more overhead
 // (due to more data being copied to every [mix] connection)
 //
-/// task responsible for receiving messages for locally embedded client from multiple mix
+/// task responsible for receiving messages for locally embedded clients from multiple mix
 /// connections and forwarding them via the router. kinda equivalent of a client socket handler
 pub(crate) struct MessageRouter {
     mix_receiver: MixMessageReceiver,
@@ -71,7 +71,7 @@ impl MessageRouter {
         if let Err(err) = self.packet_router.route_received(messages) {
             // TODO: what should we do here? I don't think this could/should ever fail.
             // is panicking the appropriate thing to do then?
-            error!("failed to route packets to local NR: {err}")
+            error!("failed to route packets to local embedded client: {err}")
         }
     }
 

gateway/src/node/mod.rs

@@ -330,12 +330,11 @@ impl<St> Gateway<St> {
 
         // if network requester is enabled, configuration file must be provided!
         let Some(ip_opts) = &self.ip_packet_router_opts else {
-            log::error!("IP packet router is enabled but no configuration file was provided!");
             return Err(GatewayError::UnspecifiedIpPacketRouterConfig);
         };
 
         // this gateway, whenever it has anything to send to its local NR will use fake_client_tx
-        let (nr_mix_sender, nr_mix_receiver) = mpsc::unbounded();
+        let (ipr_mix_sender, ipr_mix_receiver) = mpsc::unbounded();
         let router_shutdown = shutdown.fork("message_router");
 
         let (router_tx, mut router_rx) = oneshot::channel();
@@ -346,7 +345,6 @@ impl<St> Gateway<St> {
             router_tx,
         );
 
-        // TODO: well, wire it up internally to gateway traffic, shutdowns, etc.
         let (on_start_tx, on_start_rx) = oneshot::channel();
         let mut ip_packet_router =
             nym_ip_packet_router::IpPacketRouter::new(ip_opts.config.clone())
@@ -377,13 +375,11 @@ impl<St> Gateway<St> {
             return Err(GatewayError::IpPacketRouterStartupFailure);
         };
 
-        MessageRouter::new(nr_mix_receiver, packet_router).start_with_shutdown(router_shutdown);
-        info!(
-            "the local ip packet router is running on {}",
-            start_data.address
-        );
+        MessageRouter::new(ipr_mix_receiver, packet_router).start_with_shutdown(router_shutdown);
+        let address = start_data.address;
 
-        Ok(LocalEmbeddedClientHandle::new_ip(start_data, nr_mix_sender))
+        info!("the local ip packet router is running on {address}");
+        Ok(LocalEmbeddedClientHandle::new(address, ipr_mix_sender))
     }
 
     async fn wait_for_interrupt(