Rename struct

gateway/src/node/client_handling/active_clients.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
 use super::websocket::message_receiver::{IsActiveRequestSender, MixMessageSender};
-use crate::node::client_handling::embedded_clients::LocalNetworkRequesterHandle;
+use crate::node::client_handling::embedded_clients::LocalEmbeddedClientHandle;
 use dashmap::DashMap;
 use log::warn;
 use nym_sphinx::DestinationAddressBytes;
@@ -13,7 +13,7 @@ enum ActiveClient {
     Remote(ClientIncomingChannels),
 
     /// Handle to a locally (inside the same process) running network requester client.
-    Embedded(LocalNetworkRequesterHandle),
+    Embedded(LocalEmbeddedClientHandle),
 }
 
 impl ActiveClient {
@@ -150,7 +150,7 @@ impl ActiveClientsStore {
     }
 
     /// Inserts a handle to the embedded network requester
-    pub(crate) fn insert_embedded(&self, local_nr_handle: LocalNetworkRequesterHandle) {
+    pub(crate) fn insert_embedded(&self, local_nr_handle: LocalEmbeddedClientHandle) {
         let key = local_nr_handle.client_destination();
         let entry = ActiveClient::Embedded(local_nr_handle);
         if self.inner.insert(key, entry).is_some() {

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

@@ -12,15 +12,15 @@ use nym_sphinx::DestinationAddressBytes;
 use nym_task::TaskClient;
 
 #[derive(Debug)]
-pub(crate) struct LocalNetworkRequesterHandle {
-    /// Nym address of the embedded network requester.
+pub(crate) struct LocalEmbeddedClientHandle {
+    /// Nym address of the embedded client.
     pub(crate) address: Recipient,
 
-    /// Message channel used internally to forward any received mix packets to the network requester.
+    /// Message channel used internally to forward any received mix packets to the client.
     pub(crate) mix_message_sender: MixMessageSender,
 }
 
-impl LocalNetworkRequesterHandle {
+impl LocalEmbeddedClientHandle {
     pub(crate) fn new(address: Recipient, mix_message_sender: MixMessageSender) -> Self {
         Self {
             address,
@@ -48,8 +48,8 @@ impl LocalNetworkRequesterHandle {
 // 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 NR requester from multiple mix connections
-/// and forwarding them via the router. kinda equivalent of a client socket handler
+/// task responsible for receiving messages for locally embedded client from multiple mix
+/// connections and forwarding them via the router. kinda equivalent of a client socket handler
 pub(crate) struct MessageRouter {
     mix_receiver: MixMessageReceiver,
     packet_router: PacketRouter,
@@ -76,24 +76,24 @@ impl MessageRouter {
     }
 
     pub(crate) async fn run_with_shutdown(mut self, mut shutdown: TaskClient) {
-        debug!("Started embedded network requester message router with graceful shutdown support");
+        debug!("Started embedded client message router with graceful shutdown support");
         while !shutdown.is_shutdown() {
             tokio::select! {
                 messages = self.mix_receiver.next() => match messages {
                     Some(messages) => self.handle_received_messages(messages),
                     None => {
-                        log::trace!("embedded_network_requester::MessageRouter: Stopping since channel closed");
+                        log::trace!("embedded_clients::MessageRouter: Stopping since channel closed");
                         break;
                     }
                 },
                 _ = shutdown.recv_with_delay() => {
-                    log::trace!("embedded_network_requester::MessageRouter: Received shutdown");
+                    log::trace!("embedded_clients::MessageRouter: Received shutdown");
                     debug_assert!(shutdown.is_shutdown());
                     break
                 }
             }
         }
 
-        debug!("embedded_network_requester::MessageRouter: Exiting")
+        debug!("embedded_network_clients::MessageRouter: Exiting")
     }
 }

gateway/src/node/client_handling/mod.rs

@@ -3,8 +3,8 @@
 
 use crate::node::client_handling::bandwidth::Bandwidth;
 
-mod bandwidth;
 pub(crate) mod active_clients;
+mod bandwidth;
 pub(crate) mod embedded_clients;
 pub(crate) mod websocket;
 

gateway/src/node/mod.rs

@@ -11,7 +11,7 @@ use crate::config::Config;
 use crate::error::GatewayError;
 use crate::http::HttpApiBuilder;
 use crate::node::client_handling::active_clients::ActiveClientsStore;
-use crate::node::client_handling::embedded_clients::{LocalNetworkRequesterHandle, MessageRouter};
+use crate::node::client_handling::embedded_clients::{LocalEmbeddedClientHandle, MessageRouter};
 use crate::node::client_handling::websocket;
 use crate::node::client_handling::websocket::connection_handler::coconut::CoconutVerifier;
 use crate::node::helpers::{initialise_main_storage, load_network_requester_config};
@@ -49,7 +49,7 @@ struct StartedNetworkRequester {
     used_request_filter: RequestFilter,
 
     /// Handle to interact with the local network requester
-    handle: LocalNetworkRequesterHandle,
+    handle: LocalEmbeddedClientHandle,
 }
 
 /// Wire up and create Gateway instance
@@ -317,7 +317,7 @@ impl<St> Gateway<St> {
         info!("the local network requester is running on {address}",);
         Ok(StartedNetworkRequester {
             used_request_filter: start_data.request_filter,
-            handle: LocalNetworkRequesterHandle::new(address, nr_mix_sender),
+            handle: LocalEmbeddedClientHandle::new(address, nr_mix_sender),
         })
     }
 
@@ -325,7 +325,7 @@ impl<St> Gateway<St> {
         &self,
         forwarding_channel: MixForwardingSender,
         shutdown: TaskClient,
-    ) -> Result<LocalNetworkRequesterHandle, GatewayError> {
+    ) -> Result<LocalEmbeddedClientHandle, GatewayError> {
         info!("Starting IP packet provider...");
 
         // if network requester is enabled, configuration file must be provided!
@@ -383,10 +383,7 @@ impl<St> Gateway<St> {
             start_data.address
         );
 
-        Ok(LocalNetworkRequesterHandle::new_ip(
-            start_data,
-            nr_mix_sender,
-        ))
+        Ok(LocalEmbeddedClientHandle::new_ip(start_data, nr_mix_sender))
     }
 
     async fn wait_for_interrupt(