Rename Service::add_requester to connect_client

Signed-off-by: Didier Wenzek <didier.wenzek@free.fr>

Author: didier-wenzek

crates/core/tedge_actors/src/examples/mod.rs

@@ -60,13 +60,13 @@
 //! // Connecting the two boxes, so the box built by the `player_box_builder`:
 //! // - receives as input, the output messages sent from the server message box
 //! // - sends output messages to the server message box as its input.
-//! let request_sender = server_box_builder.add_requester(player_1_box_builder.get_sender());
+//! let request_sender = server_box_builder.connect_client(player_1_box_builder.get_sender());
 //! player_1_box_builder.connect_sink(NoConfig, &request_sender);
 //!
 //! // It matters that the builder of the server box is a `ServerMessageBoxBuilder`:
 //! // as this builder accepts multiple client actors to connect to the same server.
 //! let mut player_2_box_builder = SimpleMessageBoxBuilder::new("Player 2", 1);
-//! let request_sender = server_box_builder.add_requester(player_2_box_builder.get_sender());
+//! let request_sender = server_box_builder.connect_client(player_2_box_builder.get_sender());
 //! player_2_box_builder.connect_sink(NoConfig, &request_sender);
 //!
 //! // One can then build the message boxes

crates/core/tedge_actors/src/servers/mod.rs

@@ -146,15 +146,18 @@ impl<Request, Response> AsRef<Request> for RequestEnvelope<Request, Response> {
 pub trait Service<Request: Message, Response: Message>:
     MessageSink<RequestEnvelope<Request, Response>>
 {
-    /// Connect a request message box to the server box under construction
-    fn add_requester(&mut self, response_sender: DynSender<Response>) -> DynSender<Request>;
+    /// Connect a client message box to the server box under construction
+    ///
+    /// The client provides a `response_sender` on which it wants to response to be sent to.
+    /// In exchange the client is returned a request sender on which its requests will have to be sent.
+    fn connect_client(&mut self, response_sender: DynSender<Response>) -> DynSender<Request>;
 }
 
 impl<T, Request: Message, Response: Message> Service<Request, Response> for T
 where
     T: MessageSink<RequestEnvelope<Request, Response>>,
 {
-    fn add_requester(&mut self, reply_to: DynSender<Response>) -> DynSender<Request> {
+    fn connect_client(&mut self, reply_to: DynSender<Response>) -> DynSender<Request> {
         let request_sender = RequestSender {
             sender: self.get_sender(),
             reply_to,

crates/core/tedge_actors/src/test_helpers.rs

@@ -527,7 +527,7 @@ impl<I: MessagePlus, O: MessagePlus> Probe<I, O> {
 
     /// Connect this probe to a service provider
     pub fn connect_to_server(&mut self, service: &mut impl Service<O, I>) {
-        self.output_forwarder = service.add_requester(self.input_interceptor.clone().into())
+        self.output_forwarder = service.connect_client(self.input_interceptor.clone().into())
     }
 
     /// Return the next event observed between the two connected actors.

crates/core/tedge_agent/src/operation_file_cache/mod.rs

@@ -295,7 +295,7 @@ impl FileCacheActorBuilder {
         let message_box = SimpleMessageBoxBuilder::new("RestartManager", 10);
 
         let download_sender =
-            downloader_actor.add_requester(message_box.get_sender().sender_clone());
+            downloader_actor.connect_client(message_box.get_sender().sender_clone());
 
         let mqtt_sender = mqtt_actor.get_sender();
         mqtt_actor.connect_sink(Self::subscriptions(&mqtt_schema), &message_box.get_sender());

crates/extensions/c8y_mapper_ext/src/actor.rs

@@ -312,9 +312,9 @@ impl C8yMapperBuilder {
         let mqtt_publisher = mqtt.get_sender();
         mqtt.connect_sink(config.topics.clone(), &box_builder.get_sender());
         let http_proxy = C8YHttpProxy::new(http);
-        let timer_sender = timer.add_requester(box_builder.get_sender().sender_clone());
-        let upload_sender = uploader.add_requester(box_builder.get_sender().sender_clone());
-        let download_sender = downloader.add_requester(box_builder.get_sender().sender_clone());
+        let timer_sender = timer.connect_client(box_builder.get_sender().sender_clone());
+        let upload_sender = uploader.connect_client(box_builder.get_sender().sender_clone());
+        let download_sender = downloader.connect_client(box_builder.get_sender().sender_clone());
         fs_watcher.connect_sink(config.ops_dir.clone(), &box_builder.get_sender());
         let auth_proxy = ProxyUrlGenerator::new(
             config.auth_proxy_addr.clone(),

crates/extensions/tedge_config_manager/src/lib.rs

@@ -67,9 +67,9 @@ impl ConfigManagerBuilder {
         mqtt.connect_sink(Self::subscriptions(&config), &events_sender);
         let mqtt_publisher = mqtt.get_sender();
 
-        let download_sender = downloader_actor.add_requester(events_sender.sender_clone());
+        let download_sender = downloader_actor.connect_client(events_sender.sender_clone());
 
-        let upload_sender = uploader_actor.add_requester(events_sender.sender_clone());
+        let upload_sender = uploader_actor.connect_client(events_sender.sender_clone());
 
         fs_notify.connect_sink(
             ConfigManagerBuilder::watched_directory(&config),

crates/extensions/tedge_log_manager/src/lib.rs

@@ -57,7 +57,7 @@ impl LogManagerBuilder {
             &box_builder.get_sender(),
         );
 
-        let upload_sender = uploader_actor.add_requester(box_builder.get_sender().sender_clone());
+        let upload_sender = uploader_actor.connect_client(box_builder.get_sender().sender_clone());
 
         Ok(Self {
             config,

crates/extensions/tedge_timer_ext/src/tests.rs

@@ -152,7 +152,7 @@ async fn spawn_timer_actor<T: Message>(
     DynSender<RuntimeRequest>,
 ) {
     let mut actor = TimerActor::builder();
-    peer.connect_sink(NoConfig, &actor.add_requester(peer.get_sender()));
+    peer.connect_sink(NoConfig, &actor.connect_client(peer.get_sender()));
     let signal_sender = actor.get_signal_sender();
 
     let handle = tokio::spawn(actor.build().run());