From 49ebbbf428f174bfd4443dc42bf9beea1f64adca Mon Sep 17 00:00:00 2001 From: Didier Wenzek Date: Thu, 7 Mar 2024 18:00:42 +0100 Subject: [PATCH 1/6] Remove impl ServiceProvider for ServerActorBuilder Connecting a server actor to its clients has been the main motivation for the ServiceProvider trait which where used to let the client and the server exchange senders, one given by the server to the client requests and another given by the client to server responses. With the new mechanism of RequestEnvelope, this exchange is no more useful. The actor server is a simple MessageSink accepting requests wrapped in an envelope with a reply-to address, i.e. a sender. Clients only needs a sender to post their request. The next step will be to fully deprecate the ServiceProvider trait, in favor of the combination of two traits MessageSource + MessageSink. Indeed, the complexity of the ServiceProvider was only used by server actors and not the actors, such as the MQTTActor, for which the messages received and sent don't have a request-response relationship. Signed-off-by: Didier Wenzek --- crates/common/batcher/src/driver.rs | 3 +- crates/core/tedge_actors/src/actors.rs | 2 +- crates/core/tedge_actors/src/lib.rs | 2 +- .../core/tedge_actors/src/servers/builders.rs | 10 --- .../tedge_actors/src/servers/message_boxes.rs | 5 +- crates/core/tedge_actors/src/servers/mod.rs | 34 ++++----- crates/core/tedge_actors/src/test_helpers.rs | 76 +++++++++---------- crates/core/tedge_actors/src/tests.rs | 10 +-- .../src/operation_file_cache/mod.rs | 5 +- crates/extensions/c8y_mapper_ext/src/actor.rs | 10 +-- crates/extensions/c8y_mapper_ext/src/tests.rs | 14 ++-- .../tedge_config_manager/src/lib.rs | 15 ++-- .../tedge_config_manager/src/tests.rs | 17 ++--- .../extensions/tedge_log_manager/src/lib.rs | 7 +- .../extensions/tedge_log_manager/src/tests.rs | 8 +- 15 files changed, 93 insertions(+), 125 deletions(-) diff --git a/crates/common/batcher/src/driver.rs b/crates/common/batcher/src/driver.rs index 59ea414cd9e..c09c2c6cf23 100644 --- a/crates/common/batcher/src/driver.rs +++ b/crates/common/batcher/src/driver.rs @@ -178,7 +178,6 @@ mod tests { use std::time::Duration; use tedge_actors::test_helpers::ServiceProviderExt; use tedge_actors::Builder; - use tedge_actors::NoConfig; use tedge_actors::SimpleMessageBoxBuilder; use tokio::time::timeout; @@ -256,7 +255,7 @@ mod tests { .build(); let batcher = Batcher::new(config); let mut box_builder = SimpleMessageBoxBuilder::new("test", 1); - let test_box = box_builder.new_client_box(NoConfig); + let test_box = box_builder.new_client_box(); let driver_box = box_builder.build(); let driver = BatchDriver::new(batcher, driver_box); diff --git a/crates/core/tedge_actors/src/actors.rs b/crates/core/tedge_actors/src/actors.rs index 967505a8a92..30dd6555da9 100644 --- a/crates/core/tedge_actors/src/actors.rs +++ b/crates/core/tedge_actors/src/actors.rs @@ -77,7 +77,7 @@ pub mod tests { #[tokio::test] async fn running_an_actor_without_a_runtime() { let mut box_builder = SimpleMessageBoxBuilder::new("test", 16); - let mut client_message_box = box_builder.new_client_box(NoConfig); + let mut client_message_box = box_builder.new_client_box(); let mut runtime_box = box_builder.get_signal_sender(); let actor_message_box = box_builder.build(); let actor = Echo { diff --git a/crates/core/tedge_actors/src/lib.rs b/crates/core/tedge_actors/src/lib.rs index ef710010907..e32b2efc103 100644 --- a/crates/core/tedge_actors/src/lib.rs +++ b/crates/core/tedge_actors/src/lib.rs @@ -133,7 +133,7 @@ //! let mut actor_box_builder = SimpleMessageBoxBuilder::new("Actor", 10); //! //! // Create a test box ready then the actor box -//! let mut test_box = actor_box_builder.new_client_box(NoConfig); +//! let mut test_box = actor_box_builder.new_client_box(); //! let actor_box = actor_box_builder.build(); //! //! // The actor is then spawn in the background with its message box. diff --git a/crates/core/tedge_actors/src/servers/builders.rs b/crates/core/tedge_actors/src/servers/builders.rs index 3781dce864a..66a39b487b0 100644 --- a/crates/core/tedge_actors/src/servers/builders.rs +++ b/crates/core/tedge_actors/src/servers/builders.rs @@ -201,16 +201,6 @@ impl Builder> for ServerActorBuilder } } -impl ServiceProvider for ServerActorBuilder { - fn connect_consumer( - &mut self, - config: NoConfig, - response_sender: DynSender, - ) -> DynSender { - self.box_builder.connect_consumer(config, response_sender) - } -} - impl MessageSink, NoConfig> for ServerActorBuilder { diff --git a/crates/core/tedge_actors/src/servers/message_boxes.rs b/crates/core/tedge_actors/src/servers/message_boxes.rs index a10a9e950ba..509df15e00b 100644 --- a/crates/core/tedge_actors/src/servers/message_boxes.rs +++ b/crates/core/tedge_actors/src/servers/message_boxes.rs @@ -166,7 +166,6 @@ mod tests { use crate::Builder; use crate::ConcurrentServerActor; use crate::DynSender; - use crate::NoConfig; use crate::Runtime; use crate::RuntimeRequest; use crate::RuntimeRequestSink; @@ -181,7 +180,7 @@ mod tests { #[tokio::test] async fn only_processes_messages_up_to_max_concurrency() { let mut builder = ServerMessageBoxBuilder::new("ConcurrentServerMessageBoxTest", 16); - let mut test_box = builder.new_client_box(NoConfig); + let mut test_box = builder.new_client_box(); let message_box: ServerMessageBox = builder.build(); let mut concurrent_box = ConcurrentServerMessageBox::new(4, message_box); @@ -285,7 +284,7 @@ mod tests { } fn client_box(&mut self) -> SimpleMessageBox { - self.box_builder.new_client_box(NoConfig) + self.box_builder.new_client_box() } } diff --git a/crates/core/tedge_actors/src/servers/mod.rs b/crates/core/tedge_actors/src/servers/mod.rs index 1898f028229..84a2c1ccb87 100644 --- a/crates/core/tedge_actors/src/servers/mod.rs +++ b/crates/core/tedge_actors/src/servers/mod.rs @@ -68,8 +68,8 @@ //! let mut handle = actor.request_sender(); //! //! // This handle can then be used to connect client message boxes -//! let mut client_1 = handle.new_client_box(NoConfig); -//! let mut client_2 = handle.new_client_box(NoConfig); +//! let mut client_1 = handle.new_client_box(); +//! let mut client_2 = handle.new_client_box(); //! //! // The actor is then spawn in the background. //! tokio::spawn(async move { actor.run().await } ); @@ -103,7 +103,6 @@ use crate::Message; use crate::MessageSink; use crate::NoConfig; use crate::Sender; -use crate::ServiceProvider; use async_trait::async_trait; /// Define how a server process a request @@ -141,28 +140,23 @@ impl Debug for RequestEnvelope { /// A request sender to some [Server] pub type DynRequestSender = DynSender>; -impl ServiceProvider - for DynRequestSender -{ - fn connect_consumer( - &mut self, - _config: NoConfig, - reply_to: DynSender, - ) -> DynSender { - Box::new(RequestSender { - sender: self.sender_clone(), - reply_to, - }) - } -} - /// A connector to a [Server] expecting Request and returning Response. pub trait Service: MessageSink, NoConfig> { + /// Connect a request message box to the server box under construction + fn add_requester(&mut self, response_sender: DynSender) -> DynSender; } -impl Service for T where - T: MessageSink, NoConfig> +impl Service for T +where + T: MessageSink, NoConfig>, { + fn add_requester(&mut self, reply_to: DynSender) -> DynSender { + let request_sender = RequestSender { + sender: self.get_sender(), + reply_to, + }; + request_sender.into() + } } diff --git a/crates/core/tedge_actors/src/test_helpers.rs b/crates/core/tedge_actors/src/test_helpers.rs index be3e166798d..ca36e7b4eda 100644 --- a/crates/core/tedge_actors/src/test_helpers.rs +++ b/crates/core/tedge_actors/src/test_helpers.rs @@ -2,6 +2,8 @@ use crate::mpsc; use crate::Builder; use crate::ChannelError; +use crate::CloneSender; +use crate::DynRequestSender; use crate::DynSender; use crate::Message; use crate::MessageReceiver; @@ -11,10 +13,11 @@ use crate::NoConfig; use crate::NoMessage; use crate::NullSender; use crate::RequestEnvelope; +use crate::RequestSender; use crate::RuntimeRequest; use crate::Sender; +use crate::ServerMessageBoxBuilder; use crate::ServiceConsumer; -use crate::ServiceProvider; use crate::SimpleMessageBox; use crate::SimpleMessageBoxBuilder; use crate::WrappedInput; @@ -651,56 +654,39 @@ impl MessageSink for Probe { } } -pub trait ServiceProviderExt { +pub trait ServiceProviderExt { /// Create a simple message box connected to a box under construction. - fn new_client_box(&mut self, config: C) -> SimpleMessageBox; + fn new_client_box(&mut self) -> SimpleMessageBox; } -impl ServiceProviderExt for T -where - I: Message, - O: Message, - C: Clone, - T: ServiceProvider, -{ - fn new_client_box(&mut self, config: C) -> SimpleMessageBox { +impl ServiceProviderExt for DynRequestSender { + fn new_client_box(&mut self) -> SimpleMessageBox { let name = "client-box"; let capacity = 16; - let mut client_box = ConsumerBoxBuilder::new(name, capacity, config); - self.add_peer(&mut client_box); + let mut client_box = SimpleMessageBoxBuilder::new(name, capacity); + let request_sender = RequestSender { + sender: self.sender_clone(), + reply_to: client_box.get_sender(), + }; + client_box.set_request_sender(request_sender.into()); client_box.build() } } -struct ConsumerBoxBuilder { - config: C, - box_builder: SimpleMessageBoxBuilder, -} - -impl ConsumerBoxBuilder { - fn new(name: &str, capacity: usize, config: C) -> Self { - ConsumerBoxBuilder { - config, - box_builder: SimpleMessageBoxBuilder::new(name, capacity), - } - } - - fn build(self) -> SimpleMessageBox { - self.box_builder.build() +impl ServiceProviderExt for ServerMessageBoxBuilder { + fn new_client_box(&mut self) -> SimpleMessageBox { + self.request_sender().new_client_box() } } -impl ServiceConsumer for ConsumerBoxBuilder { - fn get_config(&self) -> C { - self.config.clone() - } - - fn set_request_sender(&mut self, request_sender: DynSender) { - self.box_builder.set_request_sender(request_sender) - } - - fn get_response_sender(&self) -> DynSender { - self.box_builder.get_response_sender() +impl ServiceProviderExt for SimpleMessageBoxBuilder { + fn new_client_box(&mut self) -> SimpleMessageBox { + let name = "client-box"; + let capacity = 16; + let mut client_box = SimpleMessageBoxBuilder::new(name, capacity); + self.set_request_sender(client_box.get_sender()); + client_box.set_request_sender(self.get_sender()); + client_box.build() } } @@ -735,9 +721,7 @@ pub struct FakeServerBox { impl FakeServerBox { /// Return a fake message box builder pub fn builder() -> FakeServerBoxBuilder { - FakeServerBoxBuilder { - messages: SimpleMessageBoxBuilder::new("Fake Server", 16), - } + FakeServerBoxBuilder::default() } } @@ -799,6 +783,14 @@ pub struct FakeServerBoxBuilder { messages: SimpleMessageBoxBuilder, NoMessage>, } +impl Default for FakeServerBoxBuilder { + fn default() -> Self { + FakeServerBoxBuilder { + messages: SimpleMessageBoxBuilder::new("Fake Server", 16), + } + } +} + impl MessageSink, NoConfig> for FakeServerBoxBuilder { diff --git a/crates/core/tedge_actors/src/tests.rs b/crates/core/tedge_actors/src/tests.rs index 98515c465eb..f1c371cf07d 100644 --- a/crates/core/tedge_actors/src/tests.rs +++ b/crates/core/tedge_actors/src/tests.rs @@ -50,7 +50,7 @@ async fn spawn_concurrent_sleep_service(max_concurrency: usize) -> DynRequestSen #[tokio::test] async fn requests_are_served_in_turn() { let mut service_handle = spawn_sleep_service().await; - let mut client = service_handle.new_client_box(NoConfig); + let mut client = service_handle.new_client_box(); // The requests being sent in some order client.send(1).await.unwrap(); @@ -67,8 +67,8 @@ async fn requests_are_served_in_turn() { async fn clients_can_interleave_request() { let mut service_handle = spawn_sleep_service().await; - let mut client_1 = service_handle.new_client_box(NoConfig); - let mut client_2 = service_handle.new_client_box(NoConfig); + let mut client_1 = service_handle.new_client_box(); + let mut client_2 = service_handle.new_client_box(); // Two clients can independently send requests client_1.send(1).await.unwrap(); @@ -85,8 +85,8 @@ async fn clients_can_interleave_request() { async fn requests_can_be_sent_concurrently() { let mut service_handle = spawn_concurrent_sleep_service(2).await; - let mut client_1 = service_handle.new_client_box(NoConfig); - let mut client_2 = service_handle.new_client_box(NoConfig); + let mut client_1 = service_handle.new_client_box(); + let mut client_2 = service_handle.new_client_box(); // Despite a long running request from client_1 client_1.send(1000).await.unwrap(); diff --git a/crates/core/tedge_agent/src/operation_file_cache/mod.rs b/crates/core/tedge_agent/src/operation_file_cache/mod.rs index 5b2e1a506ab..4bebbacbe07 100644 --- a/crates/core/tedge_agent/src/operation_file_cache/mod.rs +++ b/crates/core/tedge_agent/src/operation_file_cache/mod.rs @@ -30,6 +30,7 @@ use tedge_actors::RuntimeError; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; use tedge_actors::Sender; +use tedge_actors::Service; use tedge_actors::ServiceProvider; use tedge_actors::SimpleMessageBoxBuilder; use tedge_api::messages::ConfigUpdateCmdPayload; @@ -289,13 +290,13 @@ impl FileCacheActorBuilder { mqtt_schema: MqttSchema, tedge_http_host: Arc, data_dir: DataDir, - downloader_actor: &mut impl ServiceProvider, + downloader_actor: &mut impl Service, mqtt_actor: &mut impl ServiceProvider, ) -> Self { let message_box = SimpleMessageBoxBuilder::new("RestartManager", 10); let download_sender = - downloader_actor.connect_consumer(NoConfig, message_box.get_sender().sender_clone()); + downloader_actor.add_requester(message_box.get_sender().sender_clone()); let mqtt_sender = mqtt_actor.connect_consumer( Self::subscriptions(&mqtt_schema), diff --git a/crates/extensions/c8y_mapper_ext/src/actor.rs b/crates/extensions/c8y_mapper_ext/src/actor.rs index b2eec70c57b..c96150224bd 100644 --- a/crates/extensions/c8y_mapper_ext/src/actor.rs +++ b/crates/extensions/c8y_mapper_ext/src/actor.rs @@ -298,8 +298,8 @@ impl C8yMapperBuilder { mqtt: &mut impl ServiceProvider, http: &mut impl Service, timer: &mut impl ServiceProvider, - uploader: &mut impl ServiceProvider, - downloader: &mut impl ServiceProvider, + uploader: &mut impl Service, + downloader: &mut impl Service, fs_watcher: &mut impl MessageSource, service_monitor: &mut impl ServiceProvider, ) -> Result { @@ -314,10 +314,8 @@ impl C8yMapperBuilder { let http_proxy = C8YHttpProxy::new(http); let timer_sender = timer.connect_consumer(NoConfig, box_builder.get_sender().sender_clone()); - let upload_sender = - uploader.connect_consumer(NoConfig, box_builder.get_sender().sender_clone()); - let download_sender = - downloader.connect_consumer(NoConfig, 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()); fs_watcher.register_peer( config.ops_dir.clone(), box_builder.get_sender().sender_clone(), diff --git a/crates/extensions/c8y_mapper_ext/src/tests.rs b/crates/extensions/c8y_mapper_ext/src/tests.rs index a97c14b8c25..7c49def4ecb 100644 --- a/crates/extensions/c8y_mapper_ext/src/tests.rs +++ b/crates/extensions/c8y_mapper_ext/src/tests.rs @@ -2371,8 +2371,8 @@ pub(crate) async fn spawn_c8y_mapper_actor( FakeServerBox, SimpleMessageBox, SimpleMessageBox, - SimpleMessageBox, - SimpleMessageBox, + FakeServerBox, + FakeServerBox, ) { if init { config_dir.dir("operations").dir("c8y"); @@ -2422,13 +2422,13 @@ pub(crate) async fn spawn_c8y_mapper_actor( let mut mqtt_builder: SimpleMessageBoxBuilder = SimpleMessageBoxBuilder::new("MQTT", 10); let mut c8y_proxy_builder: FakeServerBoxBuilder = - FakeServerBox::builder(); + FakeServerBoxBuilder::default(); let mut fs_watcher_builder: SimpleMessageBoxBuilder = SimpleMessageBoxBuilder::new("FS", 5); - let mut uploader_builder: SimpleMessageBoxBuilder = - SimpleMessageBoxBuilder::new("Uploader", 5); - let mut downloader_builder: SimpleMessageBoxBuilder = - SimpleMessageBoxBuilder::new("Downloader", 5); + let mut uploader_builder: FakeServerBoxBuilder = + FakeServerBoxBuilder::default(); + let mut downloader_builder: FakeServerBoxBuilder = + FakeServerBoxBuilder::default(); let mut timer_builder: SimpleMessageBoxBuilder = SimpleMessageBoxBuilder::new("Timer", 5); let mut service_monitor_builder: SimpleMessageBoxBuilder = diff --git a/crates/extensions/tedge_config_manager/src/lib.rs b/crates/extensions/tedge_config_manager/src/lib.rs index 53285965a99..7fc26d20275 100644 --- a/crates/extensions/tedge_config_manager/src/lib.rs +++ b/crates/extensions/tedge_config_manager/src/lib.rs @@ -15,9 +15,9 @@ use tedge_actors::LinkError; use tedge_actors::LoggingReceiver; use tedge_actors::LoggingSender; use tedge_actors::MessageSource; -use tedge_actors::NoConfig; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; +use tedge_actors::Service; use tedge_actors::ServiceProvider; use tedge_file_system_ext::FsWatchEvent; use tedge_mqtt_ext::MqttMessage; @@ -47,12 +47,8 @@ impl ConfigManagerBuilder { config: ConfigManagerConfig, mqtt: &mut impl ServiceProvider, fs_notify: &mut impl MessageSource, - downloader_actor: &mut impl ServiceProvider< - ConfigDownloadRequest, - ConfigDownloadResult, - NoConfig, - >, - uploader_actor: &mut impl ServiceProvider, + downloader_actor: &mut impl Service, + uploader_actor: &mut impl Service, ) -> Result { Self::init(&config).await?; @@ -69,10 +65,9 @@ impl ConfigManagerBuilder { let mqtt_publisher = mqtt.connect_consumer(Self::subscriptions(&config), events_sender.clone().into()); - let download_sender = - downloader_actor.connect_consumer(NoConfig, events_sender.clone().into()); + let download_sender = downloader_actor.add_requester(events_sender.clone().into()); - let upload_sender = uploader_actor.connect_consumer(NoConfig, events_sender.clone().into()); + let upload_sender = uploader_actor.add_requester(events_sender.clone().into()); fs_notify.register_peer( ConfigManagerBuilder::watched_directory(&config), diff --git a/crates/extensions/tedge_config_manager/src/tests.rs b/crates/extensions/tedge_config_manager/src/tests.rs index e00f7658036..14579e3df10 100644 --- a/crates/extensions/tedge_config_manager/src/tests.rs +++ b/crates/extensions/tedge_config_manager/src/tests.rs @@ -3,6 +3,8 @@ use std::fs::read_to_string; use std::path::Path; use std::sync::Arc; use std::time::Duration; +use tedge_actors::test_helpers::FakeServerBox; +use tedge_actors::test_helpers::FakeServerBoxBuilder; use tedge_actors::test_helpers::MessageReceiverExt; use tedge_actors::test_helpers::TimedMessageBox; use tedge_actors::Actor; @@ -34,9 +36,8 @@ const TEST_TIMEOUT_MS: Duration = Duration::from_secs(5); type MqttMessageBox = TimedMessageBox>; type DownloaderMessageBox = - TimedMessageBox>; -type UploaderMessageBox = - TimedMessageBox>; + TimedMessageBox>; +type UploaderMessageBox = TimedMessageBox>; fn prepare() -> Result { let tempdir = TempTedgeDir::new(); @@ -95,12 +96,10 @@ async fn new_config_manager_builder( SimpleMessageBoxBuilder::new("MQTT", 5); let mut fs_watcher_builder: SimpleMessageBoxBuilder = SimpleMessageBoxBuilder::new("FS", 5); - let mut downloader_builder: SimpleMessageBoxBuilder< - ConfigDownloadRequest, - ConfigDownloadResult, - > = SimpleMessageBoxBuilder::new("Downloader", 5); - let mut uploader_builder: SimpleMessageBoxBuilder = - SimpleMessageBoxBuilder::new("Uploader", 5); + let mut downloader_builder: FakeServerBoxBuilder = + FakeServerBoxBuilder::default(); + let mut uploader_builder: FakeServerBoxBuilder = + FakeServerBoxBuilder::default(); let config_builder = ConfigManagerBuilder::try_new( config, diff --git a/crates/extensions/tedge_log_manager/src/lib.rs b/crates/extensions/tedge_log_manager/src/lib.rs index 0e9f573b0bf..3d84421c229 100644 --- a/crates/extensions/tedge_log_manager/src/lib.rs +++ b/crates/extensions/tedge_log_manager/src/lib.rs @@ -16,10 +16,10 @@ use tedge_actors::LinkError; use tedge_actors::LoggingSender; use tedge_actors::MessageSink; use tedge_actors::MessageSource; -use tedge_actors::NoConfig; use tedge_actors::NoMessage; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; +use tedge_actors::Service; use tedge_actors::ServiceProvider; use tedge_actors::SimpleMessageBoxBuilder; use tedge_file_system_ext::FsWatchEvent; @@ -45,7 +45,7 @@ impl LogManagerBuilder { config: LogManagerConfig, mqtt: &mut impl ServiceProvider, fs_notify: &mut impl MessageSource, - uploader_actor: &mut impl ServiceProvider, + uploader_actor: &mut impl Service, ) -> Result { Self::init(&config).await?; let plugin_config = LogPluginConfig::new(&config.plugin_config_path); @@ -60,8 +60,7 @@ impl LogManagerBuilder { box_builder.get_sender().sender_clone(), ); - let upload_sender = - uploader_actor.connect_consumer(NoConfig, box_builder.get_sender().sender_clone()); + let upload_sender = uploader_actor.add_requester(box_builder.get_sender().sender_clone()); Ok(Self { config, diff --git a/crates/extensions/tedge_log_manager/src/tests.rs b/crates/extensions/tedge_log_manager/src/tests.rs index 908f6a0d925..82601555b66 100644 --- a/crates/extensions/tedge_log_manager/src/tests.rs +++ b/crates/extensions/tedge_log_manager/src/tests.rs @@ -8,6 +8,8 @@ use filetime::FileTime; use std::fs::read_to_string; use std::path::Path; use std::time::Duration; +use tedge_actors::test_helpers::FakeServerBox; +use tedge_actors::test_helpers::FakeServerBoxBuilder; use tedge_actors::test_helpers::MessageReceiverExt; use tedge_actors::test_helpers::TimedMessageBox; use tedge_actors::Actor; @@ -27,7 +29,7 @@ use toml::toml; use toml::Table; type MqttMessageBox = TimedMessageBox>; -type UploaderMessageBox = TimedMessageBox>; +type UploaderMessageBox = TimedMessageBox>; const TEST_TIMEOUT_MS: Duration = Duration::from_millis(5000); @@ -105,8 +107,8 @@ async fn new_log_manager_builder( SimpleMessageBoxBuilder::new("MQTT", 5); let mut fs_watcher_builder: SimpleMessageBoxBuilder = SimpleMessageBoxBuilder::new("FS", 5); - let mut uploader_builder: SimpleMessageBoxBuilder = - SimpleMessageBoxBuilder::new("Uploader", 5); + let mut uploader_builder: FakeServerBoxBuilder = + FakeServerBoxBuilder::default(); let log_builder = LogManagerBuilder::try_new( config, From 9e51b3c082ad7368005630042c7c83b29b22446b Mon Sep 17 00:00:00 2001 From: Didier Wenzek Date: Fri, 8 Mar 2024 19:45:57 +0100 Subject: [PATCH 2/6] Deprecate ServiceProvider and ServiceConsumer traits A `ServiceProvider` where there is no request-response relationship between the input and output messages is replaced by a `MessageSink + MessageSource`. A `ServiceProvider` where there is a request-response relationship between the request and response messages is replaced by a `Service. The ServiceConsumer trait has also been deprecated, because closely tight to the ServiceProvider trait. This has some drawbacks. Notably it's a bit less convenient to connect actors. Two method calls are required in many places instead of a single one. Futhermore the method names are not intuitive. The latter point with be addressed in following steps. Signed-off-by: Didier Wenzek --- crates/common/batcher/Cargo.toml | 1 + crates/common/batcher/src/lib.rs | 16 -- crates/core/tedge_actors/src/builders.rs | 192 ++++-------------- crates/core/tedge_actors/src/converter.rs | 21 +- .../src/examples/calculator_server.rs | 3 +- crates/core/tedge_actors/src/examples/mod.rs | 6 +- crates/core/tedge_actors/src/lib.rs | 59 ++---- .../core/tedge_actors/src/servers/builders.rs | 13 -- crates/core/tedge_actors/src/servers/mod.rs | 20 ++ crates/core/tedge_actors/src/test_helpers.rs | 97 +++++---- .../src/operation_file_cache/mod.rs | 8 +- .../src/restart_manager/builder.rs | 23 ++- .../tedge_agent/src/restart_manager/tests.rs | 7 +- .../src/software_manager/builder.rs | 23 ++- .../tedge_agent/src/software_manager/tests.rs | 7 +- .../src/tedge_operation_converter/builder.rs | 22 +- .../src/tedge_to_te_converter/tests.rs | 12 +- .../c8y_firmware_manager/src/lib.rs | 11 +- crates/extensions/c8y_http_proxy/src/lib.rs | 14 -- crates/extensions/c8y_mapper_ext/src/actor.rs | 16 +- crates/extensions/c8y_mapper_ext/src/tests.rs | 107 +++++++--- crates/extensions/collectd_ext/src/actor.rs | 15 -- .../tedge_config_manager/src/lib.rs | 9 +- crates/extensions/tedge_health_ext/src/lib.rs | 12 +- .../extensions/tedge_health_ext/src/tests.rs | 24 ++- .../extensions/tedge_log_manager/src/lib.rs | 7 +- crates/extensions/tedge_mqtt_ext/src/lib.rs | 13 -- crates/extensions/tedge_mqtt_ext/src/tests.rs | 24 +-- .../extensions/tedge_timer_ext/src/builder.rs | 56 ++--- .../extensions/tedge_timer_ext/src/tests.rs | 9 +- 30 files changed, 376 insertions(+), 471 deletions(-) diff --git a/crates/common/batcher/Cargo.toml b/crates/common/batcher/Cargo.toml index 8f97d76ca81..1a20711f61a 100644 --- a/crates/common/batcher/Cargo.toml +++ b/crates/common/batcher/Cargo.toml @@ -15,6 +15,7 @@ time = { workspace = true } tokio = { workspace = true, features = ["time"] } [dev-dependencies] +tedge_actors = { workspace = true, features = ["test-helpers"] } tokio = { workspace = true, features = ["rt", "macros"] } [lints] diff --git a/crates/common/batcher/src/lib.rs b/crates/common/batcher/src/lib.rs index 260c37ea89d..7e132f29bb1 100644 --- a/crates/common/batcher/src/lib.rs +++ b/crates/common/batcher/src/lib.rs @@ -24,7 +24,6 @@ use tedge_actors::MessageSource; use tedge_actors::NoConfig; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; -use tedge_actors::ServiceProvider; use tedge_actors::SimpleMessageBoxBuilder; pub struct BatchingActorBuilder { @@ -68,21 +67,6 @@ impl BatchingActorBuilder { } } -// FIXME: This implementation highlights something new to me. -// For some actor it makes little sense to impl ServiceProvider, -// as the consumer of the outputs is likely a *different* actor as the producer of the inputs -impl ServiceProvider, BatchDriverOutput, NoConfig> - for BatchingActorBuilder -{ - fn connect_consumer( - &mut self, - config: NoConfig, - response_sender: DynSender>, - ) -> DynSender> { - self.message_box.connect_consumer(config, response_sender) - } -} - impl MessageSink, NoConfig> for BatchingActorBuilder { fn get_config(&self) -> NoConfig { NoConfig diff --git a/crates/core/tedge_actors/src/builders.rs b/crates/core/tedge_actors/src/builders.rs index a744ecc9229..c2e1ded5e64 100644 --- a/crates/core/tedge_actors/src/builders.rs +++ b/crates/core/tedge_actors/src/builders.rs @@ -22,12 +22,6 @@ //! - [MessageSource] //! declares that the actor under construction is a source of output messages, //! and tells how to connect a [MessageSink] to which the messages will be directed. -//! - [ServiceProvider] -//! declares that the actor under construction is a service provider, -//! that produces output messages as a reaction to input messages. -//! - [ServiceConsumer]: -//! declares that the actor under construction depends on a service provider, -//! and tells how to connect such a [ServiceProvider] to interact with. //! - [RuntimeRequestSink]: //! defines how the runtime can connect the actor under construction. //! @@ -36,21 +30,11 @@ //! - An actor builder has to implement at least the [Builder] and [RuntimeRequestSink] traits, //! so the runtime can connect itself to the actor and run it, //! using its [spawn](crate::Runtime::spawn) method. -//! - An actor builder that *depends* on some service provided by a [ServiceProvider], -//! *must* implement the [ServiceConsumer] trait for the input, output and config types -//! defined by the provider. -//! - Similarly, if an actor needs to connect a [MessageSource], +//! - In order to define its input and output, an actor builder implements the [MessageSource] and [MessageSink] traits. +//! - If an actor needs to connect a [MessageSource], //! its builder must implement the [MessageSink] trait with the appropriate message and config types. //! - Vice versa, if an actor needs to send messages to some [MessageSink], //! its builder must implement the [MessageSource] trait with the appropriate message and config types. -//! - In order to define its input and output, an actor builder implements *either* the [ServiceProvider] trait -//! or the [MessageSource] and [MessageSink] traits. -//! - An actor builder implements the [MessageSource] and [MessageSink] traits -//! when it makes sense for a peer to *only* send messages to or to *only* receive messages -//! from the actor under construction. -//! - An actor builder implements the [ServiceProvider] trait -//! when there is a strong request-response relationship between the messages sent and received, -//! the responses being meaningful only for the actor sending the triggering requests. //! //! An actor builder can use a [SimpleMessageBoxBuilder] to ease all these implementations. //! @@ -70,7 +54,7 @@ //! under construction needs to send messages to. This is the mirror of the previous responsibility: //! each builder gives to the others clones of its senders and collects senders from others. //! - This is why all the actor building traits -//! ([MessageSource], [MessageSink], [ServiceProvider], [ServiceConsumer] and [RuntimeRequestSink]) +//! ([MessageSource], [MessageSink] and [RuntimeRequestSink]) //! are related to exchanges of Sender. A sink gives to a source a sender attached to its receiver. //! - To be precise, the actor builders exchange [DynSender] and not [Sender]. The difference is that //! a [DynSender] can transform the messages sent by the source to adapt them to the sink expectations, @@ -213,82 +197,6 @@ pub trait RuntimeRequestSink { fn get_signal_sender(&self) -> DynSender; } -/// A trait that defines that an actor provides a service -/// by accepting `Request` messages and sending `Response` from/to its peers. -/// -/// In order to connect to a to `ServiceProvider` and avail its services, -/// the peer must be a `ServiceConsumer`. -/// -/// The config parameter is typically used by the `ServiceConsumer` -/// to register any message filtering criteria to the `ServiceProvider`. -pub trait ServiceProvider { - /// Connect a peer message box to the message box under construction - fn add_peer(&mut self, peer: &mut impl ServiceConsumer) { - let config = peer.get_config(); - let response_sender = peer.get_response_sender(); - let request_sender = self.connect_consumer(config, response_sender); - peer.set_request_sender(request_sender); - } - - /// Connect a consumer to the service provider under construction - /// returning to that service consumer a sender for its requests. - /// - /// The consumer provides: - /// - a config to filter the responses of interest, - /// - a sender where the responses will have to be sent by the service. - /// - /// The consumer is given back: - /// - a sender where its requests will have to be sent to the service. - fn connect_consumer( - &mut self, - config: Config, - response_sender: DynSender, - ) -> DynSender; -} - -/// A trait that defines that the actor under-construction -/// is a consumer of the service provided by another actor that is a `ServiceProvider`. -/// -/// A `ServiceConsumer` actor can be connected to another actor as its peer -/// if that actor is a `ServiceProvider`. -pub trait ServiceConsumer { - /// Return the config used by this actor to connect the service provider - fn get_config(&self) -> Config; - - /// Set the sender to be used by this actor's box to send requests - fn set_request_sender(&mut self, request_sender: DynSender); - - /// Return a sender where the responses to this actor's box have to be sent - fn get_response_sender(&self) -> DynSender; - - /// Connect this client message box to the service message box - fn set_connection( - &mut self, - service: &mut impl ServiceProvider, - ) -> &mut Self - where - Self: Sized, - { - service.add_peer(self); - self - } - - /// Connect this client message box to the service message box - /// - /// Return the updated client message box. - #[must_use] - fn with_connection( - mut self, - service: &mut impl ServiceProvider, - ) -> Self - where - Self: Sized, - { - service.add_peer(&mut self); - self - } -} - /// A [Builder] of [SimpleMessageBox] /// /// This builder can be used as a building block for actor builders @@ -353,42 +261,13 @@ pub trait ServiceConsumer { /// } /// ``` /// -/// Similarly, as a `SimpleMessageBoxBuilder` is a [ServiceProvider], this can be used -/// to implement the [ServiceProvider] trait for an actor using a [SimpleMessageBox] for its main input. -/// -/// ``` -/// # use tedge_actors::{DynSender, NoConfig, ServiceConsumer, ServiceProvider, SimpleMessageBoxBuilder}; -/// # type MyActorConfig = i64; -/// # type MyActorInput = i64; -/// # type MyActorOutput = i64; -/// struct MyActorBuilder { -/// config: MyActorConfig, -/// messages: SimpleMessageBoxBuilder, -/// } -/// -/// impl ServiceProvider for MyActorBuilder { -/// fn connect_consumer( -/// &mut self, -/// config: NoConfig, -/// response_sender: DynSender) -/// -> DynSender { -/// self.messages.connect_consumer(config, response_sender) -/// } -/// } -/// ``` -/// /// A notable use of [SimpleMessageBox] is for testing. -/// As a `SimpleMessageBoxBuilder` is a [ServiceConsumer] -/// one can use such a builder to connect and test an actor that is a [ServiceProvider]. -/// -/// Similarly: -/// - A `SimpleMessageBoxBuilder` is a [ServiceProvider] and can be used to test an actor that is a [ServiceConsumer]. /// - A `SimpleMessageBoxBuilder` is a [MessageSource] and can be used to test an actor that is a [MessageSink]. /// - A `SimpleMessageBoxBuilder` is a [MessageSink] and can be used to test an actor that is a [MessageSource]. /// /// ``` /// # use std::convert::Infallible; -/// # use tedge_actors::{Actor, Builder, DynSender, MessageReceiver, NoConfig, RuntimeError, Sender, ServiceConsumer, ServiceProvider, SimpleMessageBox, SimpleMessageBoxBuilder}; +/// # use tedge_actors::{Actor, Builder, DynSender, MessageReceiver, MessageSource, MessageSink, NoConfig, RuntimeError, Sender, SimpleMessageBox, SimpleMessageBoxBuilder}; /// # struct MyActorState (i64); /// # type MyActorConfig = i64; /// # type MyActorInput = i64; @@ -412,9 +291,17 @@ pub trait ServiceConsumer { /// # MyActorBuilder { config, messages } /// # } /// # } -/// # impl ServiceProvider for MyActorBuilder { -/// # fn connect_consumer(&mut self, config: NoConfig, response_sender: DynSender) -> DynSender { -/// # self.messages.connect_consumer(config, response_sender) +/// # impl MessageSource for MyActorBuilder { +/// # fn register_peer(&mut self, config: NoConfig, sender: DynSender) { +/// # self.messages.register_peer(config, sender) +/// # } +/// # } +/// # impl MessageSink for MyActorBuilder { +/// # fn get_config(&self) -> NoConfig { +/// # NoConfig +/// # } +/// # fn get_sender(&self) -> DynSender { +/// # self.messages.get_sender() /// # } /// # } /// # impl Builder for MyActorBuilder { @@ -448,7 +335,8 @@ pub trait ServiceConsumer { /// // Connect a test box to an actor under test /// let mut my_actor_builder = MyActorBuilder::new(MyActorConfig::default()); /// let mut test_box_builder = SimpleMessageBoxBuilder::new("Test box", 16); -/// my_actor_builder.add_peer(&mut test_box_builder); +/// my_actor_builder.register_peer(NoConfig, test_box_builder.get_sender()); +/// test_box_builder.register_peer(NoConfig, my_actor_builder.get_sender()); /// /// // Build the test box and run the actor /// let mut test_box = test_box_builder.build(); @@ -489,38 +377,28 @@ impl SimpleMessageBoxBuilder { input_receiver, } } -} -/// A `SimpleMessageBoxBuilder` is a [ServiceProvider] -/// accepting `Request` and sending back `Response`, with no specific config. -impl ServiceProvider - for SimpleMessageBoxBuilder -{ - fn connect_consumer( + /// Connect this client message box to the service message box + pub fn set_connection( &mut self, - _config: Config, - response_sender: DynSender, - ) -> DynSender { - self.output_sender = response_sender; - self.input_sender.sender_clone() - } -} - -/// A `SimpleMessageBoxBuilder` is a [ServiceConsumer] -/// sending `Request` and expecting back `Response`, with no specific config. -impl ServiceConsumer - for SimpleMessageBoxBuilder -{ - fn get_config(&self) -> NoConfig { - NoConfig - } - - fn set_request_sender(&mut self, request_sender: DynSender) { - self.output_sender = request_sender; + config: Config, + service: &mut (impl MessageSink + MessageSource), + ) { + service.register_peer(config, self.input_sender.sender_clone()); + self.register_peer(NoConfig, service.get_sender()); } - fn get_response_sender(&self) -> DynSender { - self.input_sender.sender_clone() + /// Connect this client message box to the service message box + /// + /// Return the updated client message box. + #[must_use] + pub fn with_connection( + mut self, + config: Config, + service: &mut (impl MessageSink + MessageSource), + ) -> Self { + self.set_connection(config, service); + self } } diff --git a/crates/core/tedge_actors/src/converter.rs b/crates/core/tedge_actors/src/converter.rs index 88b8acd57bf..7f80f9d9a35 100644 --- a/crates/core/tedge_actors/src/converter.rs +++ b/crates/core/tedge_actors/src/converter.rs @@ -14,7 +14,6 @@ //! # use crate::tedge_actors::ConvertingActor; //! # use crate::tedge_actors::RuntimeError; //! # use crate::tedge_actors::SimpleMessageBoxBuilder; -//! # use crate::tedge_actors::ServiceConsumer; //! struct Repeater; //! //! impl Converter for Repeater { @@ -39,7 +38,7 @@ //! # use tedge_actors::{Actor, Builder, MessageReceiver, MessageSource, NoConfig, Sender}; //! # use tedge_actors::test_helpers::MessageReceiverExt; //! let mut actor = ConvertingActor::builder("Repeater", Repeater, NoConfig); -//! let mut test_box = SimpleMessageBoxBuilder::new("Test", 16).with_connection(&mut actor).build().with_timeout(Duration::from_millis(100)); +//! let mut test_box = SimpleMessageBoxBuilder::new("Test", 16).with_connection(NoConfig, &mut actor).build().with_timeout(Duration::from_millis(100)); //! tokio::spawn(async move { actor.build().run().await }); //! //! test_box.send((3, 42)).await?; @@ -67,7 +66,6 @@ use crate::RuntimeError; use crate::RuntimeRequest; use crate::RuntimeRequestSink; use crate::Sender; -use crate::ServiceProvider; use crate::SimpleMessageBox; use crate::SimpleMessageBoxBuilder; use async_trait::async_trait; @@ -191,7 +189,6 @@ impl ConvertingActor { /// # use tedge_actors::MessageSink; /// # use tedge_actors::MessageSource; /// # use tedge_actors::NoConfig; -/// # use tedge_actors::ServiceProvider; /// # #[derive(Debug)] /// # struct MqttMessage; /// # #[derive(Clone)] @@ -245,6 +242,10 @@ impl ConvertingActorBuilder { message_box: SimpleMessageBoxBuilder::new(name, 16), // FIXME: capacity should not be hardcoded } } + + pub fn get_input_sender(&self) -> DynSender { + self.message_box.get_sender() + } } impl Builder> for ConvertingActorBuilder { @@ -285,18 +286,6 @@ where } } -impl ServiceProvider - for ConvertingActorBuilder -{ - fn connect_consumer( - &mut self, - config: NoConfig, - response_sender: DynSender, - ) -> DynSender { - self.message_box.connect_consumer(config, response_sender) - } -} - impl RuntimeRequestSink for ConvertingActorBuilder { fn get_signal_sender(&self) -> DynSender { self.message_box.get_signal_sender() diff --git a/crates/core/tedge_actors/src/examples/calculator_server.rs b/crates/core/tedge_actors/src/examples/calculator_server.rs index a78b133b44e..21b0a66a799 100644 --- a/crates/core/tedge_actors/src/examples/calculator_server.rs +++ b/crates/core/tedge_actors/src/examples/calculator_server.rs @@ -81,7 +81,6 @@ mod tests { use crate::ChannelError; use crate::ServerActor; use crate::ServerMessageBoxBuilder; - use crate::ServiceConsumer; use crate::SimpleMessageBoxBuilder; #[tokio::test] @@ -94,7 +93,7 @@ mod tests { let mut probe = Probe::new(); player_box_builder .with_probe(&mut probe) - .set_connection(&mut service_box_builder); + .connect_to_server(&mut service_box_builder); // Spawn the actors tokio::spawn(async move { diff --git a/crates/core/tedge_actors/src/examples/mod.rs b/crates/core/tedge_actors/src/examples/mod.rs index 91bf907ec97..ede8321bc5d 100644 --- a/crates/core/tedge_actors/src/examples/mod.rs +++ b/crates/core/tedge_actors/src/examples/mod.rs @@ -43,7 +43,7 @@ //! to establish appropriate connections between the actor message boxes. //! //! ``` -//! # use tedge_actors::{Actor, Builder, ChannelError, MessageReceiver, Sender, ServiceConsumer, NoConfig, ServerActor, ServerMessageBox, ServerMessageBoxBuilder, SimpleMessageBox, SimpleMessageBoxBuilder}; +//! # use tedge_actors::{Actor, Builder, ChannelError, MessageReceiver, Sender, NoConfig, ServerActor, ServerMessageBox, ServerMessageBoxBuilder, SimpleMessageBox, SimpleMessageBoxBuilder, Service, MessageSink}; //! # use crate::tedge_actors::examples::calculator_server::*; //! # #[tokio::main] //! # async fn main_test() -> Result<(),ChannelError> { @@ -60,12 +60,12 @@ //! // 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. -//! player_1_box_builder.set_connection(&mut server_box_builder); +//! server_box_builder.add_client(&mut player_1_box_builder); //! //! // 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); -//! player_2_box_builder.set_connection(&mut server_box_builder); +//! server_box_builder.add_client(&mut player_2_box_builder); //! //! // One can then build the message boxes //! let server_box: ServerMessageBox = server_box_builder.build(); diff --git a/crates/core/tedge_actors/src/lib.rs b/crates/core/tedge_actors/src/lib.rs index e32b2efc103..b00e274fcff 100644 --- a/crates/core/tedge_actors/src/lib.rs +++ b/crates/core/tedge_actors/src/lib.rs @@ -161,12 +161,6 @@ //! - The [MessageReceiverExt](crate::test_helpers::MessageReceiverExt) extension //! extends a message with assertion methods checking that expected messages are actually received //! .i.e sent by the actor under test. -//! - The [ServiceProviderExt](crate::test_helpers::ServiceProviderExt) extension -//! extends the message box builders of any actor that [provide a service](crate::ServiceProvider) -//! - The [ServiceConsumerExt](crate::test_helpers::ServiceConsumerExt) extension -//! extends the message box builders of any actor that [consume a service](crate::ServiceConsumer) -//! - A [Probe](crate::test_helpers::Probe) can be interleaved between two actors -//! to observe their interactions. //! //! ## Connecting actors //! @@ -177,11 +171,9 @@ //! These builders implement connector traits //! that define the services provided and consumed by the actors under construction. //! -//! The connection builder traits work by pairs: -//! - A [MessageSink](crate::MessageSink) connects to a [MessageSource](crate::MessageSource), -//! so the messages sent by the latter will be received by the former. -//! - A [ServiceConsumer](crate::ServiceConsumer) connects a [ServiceProvider](crate::ServiceProvider), -//! to use the service, sending requests to and receiving responses from the service. +//! The connection builder traits work by pairs. +//! A [MessageSink](crate::MessageSink) connects to a [MessageSource](crate::MessageSource), +//! so the messages sent by the latter will be received by the former. //! //! These traits define the types of the messages sent and received. //! - A sink that excepts message of type `M` can only be connected to a source of messages @@ -204,44 +196,37 @@ //! Note that these traits are implemented by the actor builders, not by the actors themselves. //! //! ```no_run -//! # use tedge_actors::{DynSender, NoConfig, ServiceConsumer, ServiceProvider}; +//! # use tedge_actors::{DynSender, MessageSink, MessageSource, NoConfig}; //! # #[derive(Default)] //! # struct SomeActorBuilder; //! # #[derive(Default)] //! # struct SomeOtherActorBuilder; //! # #[derive(Debug)] -//! # struct SomeInput; +//! # struct SomeMessage; //! # #[derive(Debug)] //! # struct SomeOutput; //! # struct SomeConfig; -//! /// An actor builder declares that it provides a service -//! /// by implementing the `ServiceProvider` trait for the appropriate input, output and config types. -//! impl ServiceProvider for SomeActorBuilder { -//! /// Exchange two message senders with the new peer, so each can send messages to the other +//! /// An actor builder declares that it produces messages +//! /// by implementing the `MessageSource` trait for the appropriate output and config types. +//! impl MessageSource for SomeActorBuilder { +//! /// Get a message sender from the new peer, to send messages to. //! /// -//! /// The service registers the new consumer and its sender (i.e. where to send response), -//! /// possibly using the configuration `config` to adapt the service, -//! /// and returns to the consumer a sender where the requests will have to be sent. -//! fn connect_consumer(&mut self, config: SomeConfig, response_sender: DynSender) -//! -> DynSender { -//! todo!() -//! } +//! /// The source registers the new consumer and its sender (i.e. where to send response), +//! /// possibly using the configuration `config` to filter messages. +//! fn register_peer(&mut self, config: SomeConfig, sender: DynSender) { +//! todo!() +//! } //! } //! -//! /// An actor builder also declares that it is a consumer of other services required by it. This is done -//! /// by implementing the `ServiceConsumer` trait for the appropriate input, output and config types. -//! impl ServiceConsumer for SomeOtherActorBuilder { +//! /// An actor builder also declares that it consumes messages +//! /// by implementing the `MessageSink` trait for the appropriate input and config types. +//! impl MessageSink for SomeOtherActorBuilder { //! fn get_config(&self) -> SomeConfig { //! todo!() //! } //! -//! /// Update this actor with the sender where the service expects input messages to be sent -//! fn set_request_sender(&mut self, request_sender: DynSender) { -//! todo!() -//! } -//! -//! /// Tell the service where to send its output messages to this actor -//! fn get_response_sender(&self) -> DynSender { +//! /// Return a sender where to send the input messages. +//! fn get_sender(&self) -> DynSender { //! todo!() //! } //! } @@ -250,7 +235,7 @@ //! // can then be connected to each other. //! let mut producer = SomeActorBuilder::default(); //! let mut consumer = SomeOtherActorBuilder::default(); -//! consumer.set_connection(&mut producer); +//! producer.register_peer(SomeConfig, consumer.get_sender()); //! ``` //! //! ## Running actors @@ -270,7 +255,7 @@ //! an [Actor] implementation. One needs an [actor builder](crate::builders) that implements: //! - `Builder` to let the runtime create the actor instance, //! - `RuntimeRequestSink` so the [Runtime] can be connected to the runtime, -//! - possibly [MessageSink], [MessageSource], [ServiceProvider] or [ServiceConsumer], +//! - possibly [MessageSink] or [MessageSource], //! to be connected to other actors, accordingly to the actor dependencies and services. //! //! ```no_run @@ -286,7 +271,7 @@ //! todo!() //! } //! -//! async fn run(mut self) -> Result<(), RuntimeError> { +//! async fn run(self) -> Result<(), RuntimeError> { //! todo!() //! } //! } diff --git a/crates/core/tedge_actors/src/servers/builders.rs b/crates/core/tedge_actors/src/servers/builders.rs index 66a39b487b0..8fccfff2360 100644 --- a/crates/core/tedge_actors/src/servers/builders.rs +++ b/crates/core/tedge_actors/src/servers/builders.rs @@ -11,14 +11,12 @@ use crate::Message; use crate::MessageSink; use crate::NoConfig; use crate::RequestEnvelope; -use crate::RequestSender; use crate::RuntimeError; use crate::RuntimeRequest; use crate::RuntimeRequestSink; use crate::Server; use crate::ServerActor; use crate::ServerMessageBox; -use crate::ServiceProvider; use std::convert::Infallible; use std::fmt::Debug; @@ -76,17 +74,6 @@ impl RuntimeRequestSink for ServerMessageBoxBuilder< } } -impl ServiceProvider - for ServerMessageBoxBuilder -{ - fn connect_consumer(&mut self, _config: NoConfig, reply_to: DynSender) -> DynSender { - Box::new(RequestSender { - sender: self.request_sender.sender_clone(), - reply_to, - }) - } -} - impl MessageSink, NoConfig> for ServerMessageBoxBuilder { diff --git a/crates/core/tedge_actors/src/servers/mod.rs b/crates/core/tedge_actors/src/servers/mod.rs index 84a2c1ccb87..eee463f04fe 100644 --- a/crates/core/tedge_actors/src/servers/mod.rs +++ b/crates/core/tedge_actors/src/servers/mod.rs @@ -101,6 +101,7 @@ use std::fmt::Debug; use crate::DynSender; use crate::Message; use crate::MessageSink; +use crate::MessageSource; use crate::NoConfig; use crate::Sender; use async_trait::async_trait; @@ -137,6 +138,12 @@ impl Debug for RequestEnvelope { } } +impl AsRef for RequestEnvelope { + fn as_ref(&self) -> &Request { + &self.request + } +} + /// A request sender to some [Server] pub type DynRequestSender = DynSender>; @@ -146,6 +153,11 @@ pub trait Service: { /// Connect a request message box to the server box under construction fn add_requester(&mut self, response_sender: DynSender) -> DynSender; + + fn add_client( + &mut self, + client: &mut (impl MessageSource + MessageSink), + ); } impl Service for T @@ -159,4 +171,12 @@ where }; request_sender.into() } + + fn add_client( + &mut self, + client: &mut (impl MessageSource + MessageSink), + ) { + let request_sender = self.add_requester(client.get_sender()); + client.register_peer(NoConfig, request_sender); + } } diff --git a/crates/core/tedge_actors/src/test_helpers.rs b/crates/core/tedge_actors/src/test_helpers.rs index ca36e7b4eda..4581dcd3c67 100644 --- a/crates/core/tedge_actors/src/test_helpers.rs +++ b/crates/core/tedge_actors/src/test_helpers.rs @@ -1,5 +1,4 @@ //! Testing actors -use crate::mpsc; use crate::Builder; use crate::ChannelError; use crate::CloneSender; @@ -11,21 +10,17 @@ use crate::MessageSink; use crate::MessageSource; use crate::NoConfig; use crate::NoMessage; -use crate::NullSender; use crate::RequestEnvelope; use crate::RequestSender; use crate::RuntimeRequest; use crate::Sender; use crate::ServerMessageBoxBuilder; -use crate::ServiceConsumer; +use crate::Service; use crate::SimpleMessageBox; use crate::SimpleMessageBoxBuilder; use crate::WrappedInput; use async_trait::async_trait; use core::future::Future; -use futures::stream::FusedStream; -use futures::SinkExt; -use futures::StreamExt; use std::collections::VecDeque; use std::convert::Infallible; use std::fmt::Debug; @@ -39,13 +34,13 @@ pub trait MessageReceiverExt: Sized { /// Return a new receiver which returns None if no message is received after the given timeout /// /// ``` - /// # use tedge_actors::{Builder, NoMessage, MessageReceiver, RuntimeError, Sender, ServiceConsumer, SimpleMessageBox, SimpleMessageBoxBuilder}; + /// # use tedge_actors::{Builder, NoConfig, NoMessage, MessageReceiver, RuntimeError, Sender, SimpleMessageBox, SimpleMessageBoxBuilder}; /// # use std::time::Duration; /// # #[tokio::main] /// # async fn main() -> Result<(),RuntimeError> { /// /// let mut receiver_builder = SimpleMessageBoxBuilder::new("Recv", 16); - /// let sender_builder = SimpleMessageBoxBuilder::new("Send", 16).with_connection(&mut receiver_builder); + /// let sender_builder = SimpleMessageBoxBuilder::new("Send", 16).with_connection(NoConfig, &mut receiver_builder); /// let mut sender = sender_builder.build(); /// let receiver: SimpleMessageBox<&str,NoMessage> = receiver_builder.build(); /// @@ -91,13 +86,13 @@ pub trait MessageReceiverExt: Sized { /// Skip the given number of messages /// /// ``` - /// # use tedge_actors::{Builder, NoMessage, MessageReceiver, RuntimeError, Sender, ServiceConsumer, SimpleMessageBox, SimpleMessageBoxBuilder}; + /// # use tedge_actors::{Builder, NoConfig, NoMessage, MessageReceiver, RuntimeError, Sender, SimpleMessageBox, SimpleMessageBoxBuilder}; /// # use std::time::Duration; /// # #[tokio::main] /// # async fn main() -> Result<(),RuntimeError> { /// /// let mut receiver_builder = SimpleMessageBoxBuilder::new("Recv", 16); - /// let sender_builder = SimpleMessageBoxBuilder::new("Send", 16).with_connection(&mut receiver_builder); + /// let sender_builder = SimpleMessageBoxBuilder::new("Send", 16).with_connection(NoConfig, &mut receiver_builder); /// let mut sender = sender_builder.build(); /// let mut receiver: SimpleMessageBox<&str,NoMessage> = receiver_builder.build(); /// @@ -117,7 +112,7 @@ pub trait MessageReceiverExt: Sized { /// Check that all messages are received in the given order without any interleaved messages. /// /// ```rust - /// # use crate::tedge_actors::{Builder, NoMessage, RuntimeError, Sender, ServiceConsumer, SimpleMessageBox, SimpleMessageBoxBuilder, test_helpers}; + /// # use crate::tedge_actors::{Builder, NoConfig, NoMessage, RuntimeError, Sender, SimpleMessageBox, SimpleMessageBoxBuilder, test_helpers}; /// # use std::time::Duration; /// #[derive(Debug,Eq,PartialEq)] /// enum MyMessage { @@ -129,7 +124,7 @@ pub trait MessageReceiverExt: Sized { /// # async fn main() -> Result<(),RuntimeError> { /// /// let mut receiver_builder = SimpleMessageBoxBuilder::new("Recv", 16); - /// let sender_builder = SimpleMessageBoxBuilder::new("Send", 16).with_connection(&mut receiver_builder); + /// let sender_builder = SimpleMessageBoxBuilder::new("Send", 16).with_connection(NoConfig, &mut receiver_builder); /// let mut sender = sender_builder.build(); /// let receiver: SimpleMessageBox = receiver_builder.build(); /// @@ -158,7 +153,7 @@ pub trait MessageReceiverExt: Sized { /// Check that all messages are received possibly in a different order or with interleaved messages. /// /// ```rust - /// use crate::tedge_actors::{Builder, NoMessage, RuntimeError, Sender, ServiceConsumer, SimpleMessageBox, SimpleMessageBoxBuilder, test_helpers}; + /// use crate::tedge_actors::{Builder, NoMessage, RuntimeError, Sender, SimpleMessageBox, SimpleMessageBoxBuilder, test_helpers}; /// /// #[derive(Debug,Eq,PartialEq)] /// enum MyMessage { @@ -170,8 +165,9 @@ pub trait MessageReceiverExt: Sized { /// # async fn main() -> Result<(),RuntimeError> { /// /// # use std::time::Duration; + /// # use tedge_actors::NoConfig; /// let mut receiver_builder = SimpleMessageBoxBuilder::new("Recv", 16); - /// let sender_builder = SimpleMessageBoxBuilder::new("Send", 16).with_connection(&mut receiver_builder); + /// let sender_builder = SimpleMessageBoxBuilder::new("Send", 16).with_connection(NoConfig, &mut receiver_builder); /// let mut sender = sender_builder.build(); /// let receiver: SimpleMessageBox = receiver_builder.build(); /// @@ -201,7 +197,7 @@ pub trait MessageReceiverExt: Sized { /// The messages can possibly be received in a different order or with interleaved messages. /// /// ```rust - /// use crate::tedge_actors::{Builder, NoMessage, RuntimeError, Sender, ServiceConsumer, SimpleMessageBox, SimpleMessageBoxBuilder, test_helpers}; + /// use crate::tedge_actors::{Builder, NoMessage, RuntimeError, Sender, SimpleMessageBox, SimpleMessageBoxBuilder, test_helpers}; /// /// #[derive(Debug,Eq,PartialEq)] /// enum MyMessage { @@ -221,9 +217,10 @@ pub trait MessageReceiverExt: Sized { /// # #[tokio::main] /// # async fn main() -> Result<(),RuntimeError> { /// - /// use std::time::Duration; + /// # use std::time::Duration; + /// # use tedge_actors::NoConfig; /// let mut receiver_builder = SimpleMessageBoxBuilder::new("Recv", 16); - /// let sender_builder = SimpleMessageBoxBuilder::new("Send", 16).with_connection(&mut receiver_builder); + /// let sender_builder = SimpleMessageBoxBuilder::new("Send", 16).with_connection(NoConfig, &mut receiver_builder); /// let mut sender = sender_builder.build(); /// let receiver: SimpleMessageBox = receiver_builder.build(); /// @@ -392,6 +389,12 @@ impl AsMut for TimedMessageBox { pub trait MessagePlus: Message + Clone + Eq {} impl MessagePlus for T {} +use crate::mpsc; +use crate::NullSender; +use futures::stream::FusedStream; +use futures::SinkExt; +use futures::StreamExt; + /// For testing purpose, a `Probe` can be interposed between two actors to observe their interactions. /// /// The two actors under test, as well as their message boxes, are built and launched as usual, @@ -404,7 +407,7 @@ impl MessagePlus for T {} /// or [received](crate::test_helpers::ProbeEvent::Recv) by the actor on which the probe has been set. /// /// ``` -/// # use tedge_actors::{Actor, Builder, ChannelError, ServiceConsumer, NoConfig, ServerActor, ServerMessageBoxBuilder, SimpleMessageBoxBuilder}; +/// # use tedge_actors::{Actor, Builder, ChannelError, NoConfig, ServerActor, ServerMessageBoxBuilder, SimpleMessageBoxBuilder}; /// /// # use tedge_actors::test_helpers::ProbeEvent::{Recv, Send}; /// # use crate::tedge_actors::examples::calculator_server::*; @@ -420,7 +423,7 @@ impl MessagePlus for T {} /// /// // Connect the two actor message boxes interposing a probe. /// let mut probe = Probe::new(); -/// player_box_builder.with_probe(&mut probe).set_connection(&mut server_box_builder); +/// player_box_builder.with_probe(&mut probe).connect_to_server(&mut server_box_builder); /// /// // Spawn the actors /// let calculator = Calculator::default(); @@ -511,6 +514,22 @@ impl Probe { } } + /// Connect this probe to a source and a sink + pub fn connect_to_peers( + &mut self, + config: C, + source: &mut impl MessageSource, + sink: &mut impl MessageSink, + ) { + self.output_forwarder = sink.get_sender(); + source.register_peer(config, self.input_interceptor.clone().into()); + } + + /// Connect this probe to a service provider + pub fn connect_to_server(&mut self, service: &mut impl Service) { + self.output_forwarder = service.add_requester(self.input_interceptor.clone().into()) + } + /// Return the next event observed between the two connected actors. /// /// Note that calling `observe()` is mandatory for the actors to make progress. @@ -581,10 +600,10 @@ impl Probe { /// Extend any [ServiceConsumer] with a `with_probe` method. pub trait ServiceConsumerExt { - /// Add a probe to an actor `self` that is a [ServiceConsumer](crate::ServiceConsumer). + /// Add a probe to an actor `self` that is a [MessageSource](crate::MessageSource) and [MessageSink](crate::MessageSink). /// - /// Return a [ServiceConsumer](crate::ServiceConsumer) - /// that can be plugged into another actor which is a [ServiceProvider](crate::ServiceProvider). + /// Return a [MessageSource](crate::MessageSource) and [MessageSink](crate::MessageSink) + /// that can be plugged into another actor which consumes the source messages and produces messages for the sink. /// /// The added `Probe` is then interposed between the two actors, /// observing all the [ProbeEvent](crate::test_helpers::ProbeEvent) exchanged between them. @@ -593,7 +612,8 @@ pub trait ServiceConsumerExt { /// # use tedge_actors::{NoConfig, ServerMessageBoxBuilder, SimpleMessageBoxBuilder}; /// # use crate::tedge_actors::examples::calculator::*; /// use tedge_actors::test_helpers::Probe; // The probe struct - /// use tedge_actors::ServiceConsumer; // is a `ServiceConsumer` + /// use tedge_actors::MessageSource; // is a `MessageSource` + /// use tedge_actors::MessageSink; // is a `MessageSink` /// use tedge_actors::test_helpers::ServiceConsumerExt; // Adds `.with_probe()` /// /// // Build the actor message boxes @@ -602,7 +622,7 @@ pub trait ServiceConsumerExt { /// /// // Connect the two actor message boxes interposing a probe. /// let mut probe = Probe::new(); - /// client_box_builder.with_probe(&mut probe).set_connection(&mut server_box_builder); + /// client_box_builder.with_probe(&mut probe).connect_to_server(&mut server_box_builder); /// ``` fn with_probe<'a>( &'a mut self, @@ -612,32 +632,19 @@ pub trait ServiceConsumerExt { impl ServiceConsumerExt for T where - T: ServiceConsumer, + T: MessageSource, + T: MessageSink, { fn with_probe<'a>( &'a mut self, probe: &'a mut Probe, ) -> &'a mut Probe { - probe.input_forwarder = self.get_response_sender(); - self.set_request_sender(probe.output_interceptor.clone().into()); + probe.input_forwarder = self.get_sender(); + self.register_peer(NoConfig, probe.output_interceptor.sender_clone()); probe } } -impl ServiceConsumer for Probe { - fn get_config(&self) -> NoConfig { - NoConfig - } - - fn set_request_sender(&mut self, sender: DynSender) { - self.output_forwarder = sender; - } - - fn get_response_sender(&self) -> DynSender { - self.input_interceptor.clone().into() - } -} - impl MessageSource for Probe { fn register_peer(&mut self, _config: NoConfig, sender: DynSender) { self.output_forwarder = sender; @@ -655,7 +662,7 @@ impl MessageSink for Probe { } pub trait ServiceProviderExt { - /// Create a simple message box connected to a box under construction. + /// Create a simple message box connected to a server box under construction. fn new_client_box(&mut self) -> SimpleMessageBox; } @@ -668,7 +675,7 @@ impl ServiceProviderExt for DynRequestSender sender: self.sender_clone(), reply_to: client_box.get_sender(), }; - client_box.set_request_sender(request_sender.into()); + client_box.register_peer(NoConfig, request_sender.into()); client_box.build() } } @@ -684,8 +691,8 @@ impl ServiceProviderExt for SimpleMessageBoxBuilde let name = "client-box"; let capacity = 16; let mut client_box = SimpleMessageBoxBuilder::new(name, capacity); - self.set_request_sender(client_box.get_sender()); - client_box.set_request_sender(self.get_sender()); + self.register_peer(NoConfig, client_box.get_sender()); + client_box.register_peer(NoConfig, self.get_sender()); client_box.build() } } diff --git a/crates/core/tedge_agent/src/operation_file_cache/mod.rs b/crates/core/tedge_agent/src/operation_file_cache/mod.rs index 4bebbacbe07..cb20226af97 100644 --- a/crates/core/tedge_agent/src/operation_file_cache/mod.rs +++ b/crates/core/tedge_agent/src/operation_file_cache/mod.rs @@ -25,13 +25,13 @@ use tedge_actors::LinkError; use tedge_actors::LoggingReceiver; use tedge_actors::MessageReceiver; use tedge_actors::MessageSink; +use tedge_actors::MessageSource; use tedge_actors::NoConfig; use tedge_actors::RuntimeError; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; use tedge_actors::Sender; use tedge_actors::Service; -use tedge_actors::ServiceProvider; use tedge_actors::SimpleMessageBoxBuilder; use tedge_api::messages::ConfigUpdateCmdPayload; use tedge_api::mqtt_topics::Channel; @@ -291,14 +291,16 @@ impl FileCacheActorBuilder { tedge_http_host: Arc, data_dir: DataDir, downloader_actor: &mut impl Service, - mqtt_actor: &mut impl ServiceProvider, + mqtt_actor: &mut (impl MessageSource + + MessageSink), ) -> Self { let message_box = SimpleMessageBoxBuilder::new("RestartManager", 10); let download_sender = downloader_actor.add_requester(message_box.get_sender().sender_clone()); - let mqtt_sender = mqtt_actor.connect_consumer( + let mqtt_sender = mqtt_actor.get_sender(); + mqtt_actor.register_peer( Self::subscriptions(&mqtt_schema), message_box.get_sender().sender_clone(), ); diff --git a/crates/core/tedge_agent/src/restart_manager/builder.rs b/crates/core/tedge_agent/src/restart_manager/builder.rs index ec1be48effb..4f71a6c2163 100644 --- a/crates/core/tedge_agent/src/restart_manager/builder.rs +++ b/crates/core/tedge_agent/src/restart_manager/builder.rs @@ -3,10 +3,11 @@ use crate::restart_manager::config::RestartManagerConfig; use tedge_actors::Builder; use tedge_actors::DynSender; use tedge_actors::LinkError; +use tedge_actors::MessageSink; +use tedge_actors::MessageSource; use tedge_actors::NoConfig; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; -use tedge_actors::ServiceProvider; use tedge_actors::SimpleMessageBoxBuilder; use tedge_api::RestartCommand; @@ -26,13 +27,19 @@ impl RestartManagerBuilder { } } -impl ServiceProvider for RestartManagerBuilder { - fn connect_consumer( - &mut self, - config: NoConfig, - response_sender: DynSender, - ) -> DynSender { - self.message_box.connect_consumer(config, response_sender) +impl MessageSink for RestartManagerBuilder { + fn get_config(&self) -> NoConfig { + NoConfig + } + + fn get_sender(&self) -> DynSender { + self.message_box.get_sender() + } +} + +impl MessageSource for RestartManagerBuilder { + fn register_peer(&mut self, config: NoConfig, sender: DynSender) { + self.message_box.register_peer(config, sender) } } diff --git a/crates/core/tedge_agent/src/restart_manager/tests.rs b/crates/core/tedge_agent/src/restart_manager/tests.rs index 261e7770074..1caf2091afa 100644 --- a/crates/core/tedge_agent/src/restart_manager/tests.rs +++ b/crates/core/tedge_agent/src/restart_manager/tests.rs @@ -8,8 +8,10 @@ use tedge_actors::Actor; use tedge_actors::Builder; use tedge_actors::DynError; use tedge_actors::MessageReceiver; +use tedge_actors::MessageSink; +use tedge_actors::MessageSource; +use tedge_actors::NoConfig; use tedge_actors::Sender; -use tedge_actors::ServiceConsumer; use tedge_actors::SimpleMessageBox; use tedge_actors::SimpleMessageBoxBuilder; use tedge_api::messages::CommandStatus; @@ -118,7 +120,8 @@ async fn spawn_restart_manager( }; let mut restart_actor_builder = RestartManagerBuilder::new(config); - converter_builder.set_connection(&mut restart_actor_builder); + converter_builder.register_peer(NoConfig, restart_actor_builder.get_sender()); + restart_actor_builder.register_peer(NoConfig, converter_builder.get_sender()); let converter_box = converter_builder.build().with_timeout(TEST_TIMEOUT_MS); diff --git a/crates/core/tedge_agent/src/software_manager/builder.rs b/crates/core/tedge_agent/src/software_manager/builder.rs index bfc2c14e432..a9484af3180 100644 --- a/crates/core/tedge_agent/src/software_manager/builder.rs +++ b/crates/core/tedge_agent/src/software_manager/builder.rs @@ -4,10 +4,11 @@ use crate::software_manager::config::SoftwareManagerConfig; use tedge_actors::Builder; use tedge_actors::DynSender; use tedge_actors::LinkError; +use tedge_actors::MessageSink; +use tedge_actors::MessageSource; use tedge_actors::NoConfig; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; -use tedge_actors::ServiceProvider; use tedge_actors::SimpleMessageBoxBuilder; pub struct SoftwareManagerBuilder { @@ -26,13 +27,19 @@ impl SoftwareManagerBuilder { } } -impl ServiceProvider for SoftwareManagerBuilder { - fn connect_consumer( - &mut self, - config: NoConfig, - response_sender: DynSender, - ) -> DynSender { - self.message_box.connect_consumer(config, response_sender) +impl MessageSink for SoftwareManagerBuilder { + fn get_config(&self) -> NoConfig { + NoConfig + } + + fn get_sender(&self) -> DynSender { + self.message_box.get_sender() + } +} + +impl MessageSource for SoftwareManagerBuilder { + fn register_peer(&mut self, config: NoConfig, sender: DynSender) { + self.message_box.register_peer(config, sender) } } diff --git a/crates/core/tedge_agent/src/software_manager/tests.rs b/crates/core/tedge_agent/src/software_manager/tests.rs index cc69aa4ba76..670d0d8eda8 100644 --- a/crates/core/tedge_agent/src/software_manager/tests.rs +++ b/crates/core/tedge_agent/src/software_manager/tests.rs @@ -9,8 +9,10 @@ use tedge_actors::Actor; use tedge_actors::Builder; use tedge_actors::DynError; use tedge_actors::MessageReceiver; +use tedge_actors::MessageSink; +use tedge_actors::MessageSource; +use tedge_actors::NoConfig; use tedge_actors::Sender; -use tedge_actors::ServiceConsumer; use tedge_actors::SimpleMessageBox; use tedge_actors::SimpleMessageBoxBuilder; use tedge_api::messages::CommandStatus; @@ -187,7 +189,8 @@ async fn spawn_software_manager( }; let mut software_actor_builder = SoftwareManagerBuilder::new(config); - converter_builder.set_connection(&mut software_actor_builder); + converter_builder.register_peer(NoConfig, software_actor_builder.get_sender()); + software_actor_builder.register_peer(NoConfig, converter_builder.get_sender()); let converter_box = converter_builder.build().with_timeout(TEST_TIMEOUT_MS); diff --git a/crates/core/tedge_agent/src/tedge_operation_converter/builder.rs b/crates/core/tedge_agent/src/tedge_operation_converter/builder.rs index 0d661a806ae..2e7dde6f868 100644 --- a/crates/core/tedge_agent/src/tedge_operation_converter/builder.rs +++ b/crates/core/tedge_agent/src/tedge_operation_converter/builder.rs @@ -11,11 +11,12 @@ use tedge_actors::ClientMessageBox; use tedge_actors::DynSender; use tedge_actors::LinkError; use tedge_actors::LoggingSender; +use tedge_actors::MessageSink; +use tedge_actors::MessageSource; use tedge_actors::NoConfig; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; use tedge_actors::Service; -use tedge_actors::ServiceProvider; use tedge_actors::UnboundedLoggingReceiver; use tedge_api::mqtt_topics::ChannelFilter::AnyCommand; use tedge_api::mqtt_topics::EntityFilter; @@ -45,9 +46,12 @@ impl TedgeOperationConverterBuilder { pub fn new( config: OperationConfig, mut workflows: WorkflowSupervisor, - software_actor: &mut impl ServiceProvider, - restart_actor: &mut impl ServiceProvider, - mqtt_actor: &mut impl ServiceProvider, + software_actor: &mut (impl MessageSink + + MessageSource), + restart_actor: &mut (impl MessageSink + + MessageSource), + mqtt_actor: &mut (impl MessageSource + + MessageSink), script_runner: &mut impl Service>, ) -> Self { let (input_sender, input_receiver) = mpsc::unbounded(); @@ -59,15 +63,17 @@ impl TedgeOperationConverterBuilder { signal_receiver, ); - let software_sender = - software_actor.connect_consumer(NoConfig, input_sender.clone().into()); + let software_sender = software_actor.get_sender(); + software_actor.register_peer(NoConfig, input_sender.clone().into()); let software_sender = LoggingSender::new("SoftwareSender".into(), software_sender); - let restart_sender = restart_actor.connect_consumer(NoConfig, input_sender.clone().into()); + let restart_sender = restart_actor.get_sender(); + restart_actor.register_peer(NoConfig, input_sender.clone().into()); let restart_sender = LoggingSender::new("RestartSender".into(), restart_sender); let command_sender = input_sender.clone().into(); - let mqtt_publisher = mqtt_actor.connect_consumer( + let mqtt_publisher = mqtt_actor.get_sender(); + mqtt_actor.register_peer( Self::subscriptions(&config.mqtt_schema, &config.device_topic_id), input_sender.into(), ); diff --git a/crates/core/tedge_agent/src/tedge_to_te_converter/tests.rs b/crates/core/tedge_agent/src/tedge_to_te_converter/tests.rs index 51194638686..653e35cfb97 100644 --- a/crates/core/tedge_agent/src/tedge_to_te_converter/tests.rs +++ b/crates/core/tedge_agent/src/tedge_to_te_converter/tests.rs @@ -6,8 +6,10 @@ use tedge_actors::Actor; use tedge_actors::Builder; use tedge_actors::ConvertingActor; use tedge_actors::DynError; +use tedge_actors::MessageSink; +use tedge_actors::MessageSource; +use tedge_actors::NoConfig; use tedge_actors::Sender; -use tedge_actors::ServiceConsumer; use tedge_actors::SimpleMessageBox; use tedge_actors::SimpleMessageBoxBuilder; use tedge_mqtt_ext::MqttMessage; @@ -329,10 +331,10 @@ async fn spawn_tedge_to_te_converter( let mut tedge_converter_actor = ConvertingActor::builder("TedgetoTeConverter", tedge_to_te_converter, subscriptions); - let mqtt_box = SimpleMessageBoxBuilder::new("MQTT", 5) - .with_connection(&mut tedge_converter_actor) - .build() - .with_timeout(Duration::from_millis(100)); + let mut mqtt_box = SimpleMessageBoxBuilder::new("MQTT", 5); + mqtt_box.register_peer(NoConfig, tedge_converter_actor.get_input_sender()); + tedge_converter_actor.register_peer(NoConfig, mqtt_box.get_sender()); + let mqtt_box = mqtt_box.build().with_timeout(Duration::from_millis(100)); tokio::spawn(async move { tedge_converter_actor.build().run().await }); diff --git a/crates/extensions/c8y_firmware_manager/src/lib.rs b/crates/extensions/c8y_firmware_manager/src/lib.rs index f20276f6dc0..1abc83c2b0e 100644 --- a/crates/extensions/c8y_firmware_manager/src/lib.rs +++ b/crates/extensions/c8y_firmware_manager/src/lib.rs @@ -19,10 +19,12 @@ use tedge_actors::ClientMessageBox; use tedge_actors::DynSender; use tedge_actors::LinkError; use tedge_actors::LoggingReceiver; +use tedge_actors::MessageSink; +use tedge_actors::MessageSource; +use tedge_actors::NoConfig; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; use tedge_actors::Service; -use tedge_actors::ServiceProvider; use tedge_api::path::DataDir; use tedge_mqtt_ext::MqttMessage; use tedge_mqtt_ext::TopicFilter; @@ -45,7 +47,8 @@ pub struct FirmwareManagerBuilder { impl FirmwareManagerBuilder { pub fn try_new( config: FirmwareManagerConfig, - mqtt_actor: &mut impl ServiceProvider, + mqtt_actor: &mut (impl MessageSource + + MessageSink), jwt_actor: &mut impl Service<(), JwtResult>, downloader_actor: &mut impl Service, ) -> Result { @@ -59,8 +62,8 @@ impl FirmwareManagerBuilder { signal_receiver, ); - let mqtt_publisher = - mqtt_actor.connect_consumer(Self::subscriptions(), input_sender.clone().into()); + mqtt_actor.register_peer(Self::subscriptions(), input_sender.clone().into()); + let mqtt_publisher = mqtt_actor.get_sender(); let jwt_retriever = JwtRetriever::new(jwt_actor); let download_sender = ClientMessageBox::new(downloader_actor); let progress_sender = input_sender.into(); diff --git a/crates/extensions/c8y_http_proxy/src/lib.rs b/crates/extensions/c8y_http_proxy/src/lib.rs index 060cbc082a9..ddd9f50dced 100644 --- a/crates/extensions/c8y_http_proxy/src/lib.rs +++ b/crates/extensions/c8y_http_proxy/src/lib.rs @@ -18,7 +18,6 @@ use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; use tedge_actors::ServerMessageBoxBuilder; use tedge_actors::Service; -use tedge_actors::ServiceProvider; use tedge_config::ConfigNotSet; use tedge_config::ReadError; use tedge_config::TEdgeConfig; @@ -77,9 +76,6 @@ pub enum C8yHttpConfigBuildError { } /// A proxy to C8Y REST API -/// -/// This is an actor builder. -/// - `impl ServiceProvider` pub struct C8YHttpProxyBuilder { /// Config config: C8YHttpConfig, @@ -130,16 +126,6 @@ impl Builder for C8YHttpProxyBuilder { } } -impl ServiceProvider for C8YHttpProxyBuilder { - fn connect_consumer( - &mut self, - config: NoConfig, - response_sender: DynSender, - ) -> DynSender { - self.clients.connect_consumer(config, response_sender) - } -} - impl MessageSink, NoConfig> for C8YHttpProxyBuilder { fn get_config(&self) -> NoConfig { NoConfig diff --git a/crates/extensions/c8y_mapper_ext/src/actor.rs b/crates/extensions/c8y_mapper_ext/src/actor.rs index c96150224bd..a36efdb799a 100644 --- a/crates/extensions/c8y_mapper_ext/src/actor.rs +++ b/crates/extensions/c8y_mapper_ext/src/actor.rs @@ -30,7 +30,6 @@ use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; use tedge_actors::Sender; use tedge_actors::Service; -use tedge_actors::ServiceProvider; use tedge_actors::SimpleMessageBox; use tedge_actors::SimpleMessageBoxBuilder; use tedge_downloader_ext::DownloadRequest; @@ -295,25 +294,26 @@ impl C8yMapperBuilder { #[allow(clippy::too_many_arguments)] pub fn try_new( config: C8yMapperConfig, - mqtt: &mut impl ServiceProvider, + mqtt: &mut (impl MessageSource + MessageSink), http: &mut impl Service, - timer: &mut impl ServiceProvider, + timer: &mut impl Service, uploader: &mut impl Service, downloader: &mut impl Service, fs_watcher: &mut impl MessageSource, - service_monitor: &mut impl ServiceProvider, + service_monitor: &mut (impl MessageSource + + MessageSink), ) -> Result { Self::init(&config)?; let box_builder = SimpleMessageBoxBuilder::new("CumulocityMapper", 16); - let mqtt_publisher = mqtt.connect_consumer( + let mqtt_publisher = mqtt.get_sender(); + mqtt.register_peer( config.topics.clone(), box_builder.get_sender().sender_clone(), ); let http_proxy = C8YHttpProxy::new(http); - let timer_sender = - timer.connect_consumer(NoConfig, box_builder.get_sender().sender_clone()); + 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()); fs_watcher.register_peer( @@ -328,7 +328,7 @@ impl C8yMapperBuilder { let bridge_monitor_builder: SimpleMessageBoxBuilder = SimpleMessageBoxBuilder::new("ServiceMonitor", 1); - service_monitor.connect_consumer( + service_monitor.register_peer( C8Y_BRIDGE_HEALTH_TOPIC.try_into().unwrap(), bridge_monitor_builder.get_sender(), ); diff --git a/crates/extensions/c8y_mapper_ext/src/tests.rs b/crates/extensions/c8y_mapper_ext/src/tests.rs index 7c49def4ecb..c2899a5f5b3 100644 --- a/crates/extensions/c8y_mapper_ext/src/tests.rs +++ b/crates/extensions/c8y_mapper_ext/src/tests.rs @@ -99,7 +99,9 @@ async fn child_device_registration_mapping() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); // Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -157,7 +159,9 @@ async fn custom_topic_scheme_registration_mapping() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); // Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -214,7 +218,9 @@ async fn service_registration_mapping() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); // Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -498,7 +504,9 @@ async fn c8y_mapper_alarm_mapping_to_smartrest() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -521,7 +529,9 @@ async fn c8y_mapper_child_alarm_mapping_to_smartrest() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -567,7 +577,9 @@ async fn c8y_mapper_alarm_with_custom_fragment_mapping_to_c8y_json() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -616,7 +628,9 @@ async fn c8y_mapper_child_alarm_with_custom_fragment_mapping_to_c8y_json() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -689,7 +703,9 @@ async fn c8y_mapper_alarm_with_message_as_custom_fragment_mapping_to_c8y_json() let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -730,7 +746,9 @@ async fn c8y_mapper_child_alarm_with_message_custom_fragment_mapping_to_c8y_json let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -777,7 +795,9 @@ async fn c8y_mapper_child_alarm_with_custom_message() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -823,7 +843,9 @@ async fn c8y_mapper_alarm_with_custom_message() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -863,7 +885,9 @@ async fn c8y_mapper_child_alarm_empty_payload() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -892,7 +916,9 @@ async fn c8y_mapper_alarm_empty_payload() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -912,7 +938,9 @@ async fn c8y_mapper_alarm_empty_json_payload() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -937,7 +965,9 @@ async fn c8y_mapper_alarm_empty_json_payload() { async fn c8y_mapper_child_event() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -997,7 +1027,9 @@ async fn c8y_mapper_child_event() { async fn c8y_mapper_child_service_event() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -1080,7 +1112,9 @@ async fn c8y_mapper_child_service_event() { async fn c8y_mapper_main_service_event() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -1145,7 +1179,9 @@ async fn c8y_mapper_main_service_event() { async fn c8y_mapper_child_service_alarm() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -1221,7 +1257,9 @@ async fn c8y_mapper_child_service_alarm() { async fn c8y_mapper_main_service_alarm() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -1280,7 +1318,9 @@ async fn c8y_mapper_alarm_complex_text_fragment_in_payload_failed() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -2046,7 +2086,9 @@ async fn c8y_mapper_nested_child_alarm_mapping_to_smartrest() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -2105,7 +2147,9 @@ async fn c8y_mapper_nested_child_event_mapping_to_smartrest() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -2173,7 +2217,9 @@ async fn c8y_mapper_nested_child_service_alarm_mapping_to_smartrest() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -2236,7 +2282,9 @@ async fn c8y_mapper_nested_child_service_event_mapping_to_smartrest() { let cfg_dir = TempTedgeDir::new(); let (mqtt, _http, _fs, mut timer, _ul, _dl) = spawn_c8y_mapper_actor(&cfg_dir, true).await; - timer.send(Timeout::new(())).await.unwrap(); //Complete sync phase so that alarm mapping starts + // Complete sync phase so that alarm mapping starts + trigger_timeout(&mut timer).await; + let mut mqtt = mqtt.with_timeout(TEST_TIMEOUT_MS); skip_init_messages(&mut mqtt).await; @@ -2363,6 +2411,11 @@ fn create_thin_edge_child_operations(cfg_dir: &TempTedgeDir, child_id: &str, ops } } +async fn trigger_timeout(timer: &mut FakeServerBox) { + timer.recv().await.unwrap(); + timer.send(Timeout::new(())).await.unwrap(); +} + pub(crate) async fn spawn_c8y_mapper_actor( config_dir: &TempTedgeDir, init: bool, @@ -2370,7 +2423,7 @@ pub(crate) async fn spawn_c8y_mapper_actor( SimpleMessageBox, FakeServerBox, SimpleMessageBox, - SimpleMessageBox, + FakeServerBox, FakeServerBox, FakeServerBox, ) { @@ -2429,8 +2482,8 @@ pub(crate) async fn spawn_c8y_mapper_actor( FakeServerBoxBuilder::default(); let mut downloader_builder: FakeServerBoxBuilder = FakeServerBoxBuilder::default(); - let mut timer_builder: SimpleMessageBoxBuilder = - SimpleMessageBoxBuilder::new("Timer", 5); + let mut timer_builder: FakeServerBoxBuilder = + FakeServerBoxBuilder::default(); let mut service_monitor_builder: SimpleMessageBoxBuilder = SimpleMessageBoxBuilder::new("ServiceMonitor", 1); diff --git a/crates/extensions/collectd_ext/src/actor.rs b/crates/extensions/collectd_ext/src/actor.rs index 27475e586f8..228193535bd 100644 --- a/crates/extensions/collectd_ext/src/actor.rs +++ b/crates/extensions/collectd_ext/src/actor.rs @@ -13,7 +13,6 @@ use tedge_actors::RuntimeError; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; use tedge_actors::Sender; -use tedge_actors::ServiceConsumer; use tedge_actors::SimpleMessageBox; use tedge_actors::SimpleMessageBoxBuilder; use tedge_mqtt_ext::MqttMessage; @@ -65,20 +64,6 @@ impl CollectdActorBuilder { } } -impl ServiceConsumer for CollectdActorBuilder { - fn get_config(&self) -> TopicFilter { - self.topics.clone() - } - - fn set_request_sender(&mut self, _request_sender: DynSender) { - // this actor publishes no messages over MQTT - } - - fn get_response_sender(&self) -> DynSender { - self.message_box.get_response_sender() - } -} - impl RuntimeRequestSink for CollectdActorBuilder { fn get_signal_sender(&self) -> DynSender { self.message_box.get_signal_sender() diff --git a/crates/extensions/tedge_config_manager/src/lib.rs b/crates/extensions/tedge_config_manager/src/lib.rs index 7fc26d20275..6db0879d77d 100644 --- a/crates/extensions/tedge_config_manager/src/lib.rs +++ b/crates/extensions/tedge_config_manager/src/lib.rs @@ -14,11 +14,12 @@ use tedge_actors::DynSender; use tedge_actors::LinkError; use tedge_actors::LoggingReceiver; use tedge_actors::LoggingSender; +use tedge_actors::MessageSink; use tedge_actors::MessageSource; +use tedge_actors::NoConfig; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; use tedge_actors::Service; -use tedge_actors::ServiceProvider; use tedge_file_system_ext::FsWatchEvent; use tedge_mqtt_ext::MqttMessage; use tedge_mqtt_ext::TopicFilter; @@ -45,7 +46,7 @@ pub struct ConfigManagerBuilder { impl ConfigManagerBuilder { pub async fn try_new( config: ConfigManagerConfig, - mqtt: &mut impl ServiceProvider, + mqtt: &mut (impl MessageSource + MessageSink), fs_notify: &mut impl MessageSource, downloader_actor: &mut impl Service, uploader_actor: &mut impl Service, @@ -62,8 +63,8 @@ impl ConfigManagerBuilder { signal_receiver, ); - let mqtt_publisher = - mqtt.connect_consumer(Self::subscriptions(&config), events_sender.clone().into()); + mqtt.register_peer(Self::subscriptions(&config), events_sender.clone().into()); + let mqtt_publisher = mqtt.get_sender(); let download_sender = downloader_actor.add_requester(events_sender.clone().into()); diff --git a/crates/extensions/tedge_health_ext/src/lib.rs b/crates/extensions/tedge_health_ext/src/lib.rs index dda3406617a..3c7f98f1fcf 100644 --- a/crates/extensions/tedge_health_ext/src/lib.rs +++ b/crates/extensions/tedge_health_ext/src/lib.rs @@ -8,10 +8,10 @@ use tedge_actors::Builder; use tedge_actors::DynSender; use tedge_actors::LinkError; use tedge_actors::MessageSink; +use tedge_actors::MessageSource; +use tedge_actors::NoConfig; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; -use tedge_actors::ServiceConsumer; -use tedge_actors::ServiceProvider; use tedge_actors::SimpleMessageBoxBuilder; use tedge_api::entity_store::EntityRegistrationMessage; use tedge_api::entity_store::EntityType; @@ -37,7 +37,9 @@ impl HealthMonitorBuilder { /// a new topic scheme. pub fn from_service_topic_id( service: Service, - mqtt: &mut (impl ServiceProvider + AsMut), + mqtt: &mut (impl MessageSource + + MessageSink + + AsMut), // TODO: pass it less annoying way mqtt_schema: &MqttSchema, service_config: &TEdgeConfigReaderService, @@ -71,8 +73,8 @@ impl HealthMonitorBuilder { .into_iter() .collect(); - box_builder - .set_request_sender(mqtt.connect_consumer(subscriptions, box_builder.get_sender())); + mqtt.register_peer(subscriptions, box_builder.get_sender()); + box_builder.register_peer(NoConfig, mqtt.get_sender()); if service_type.is_empty() { service_type = "service" diff --git a/crates/extensions/tedge_health_ext/src/tests.rs b/crates/extensions/tedge_health_ext/src/tests.rs index 1a9b19d7044..26960b36fd2 100644 --- a/crates/extensions/tedge_health_ext/src/tests.rs +++ b/crates/extensions/tedge_health_ext/src/tests.rs @@ -6,7 +6,9 @@ use tedge_actors::Actor; use tedge_actors::Builder; use tedge_actors::DynSender; use tedge_actors::MessageReceiver; -use tedge_actors::ServiceProvider; +use tedge_actors::MessageSink; +use tedge_actors::MessageSource; +use tedge_actors::NoConfig; use tedge_actors::SimpleMessageBox; use tedge_actors::SimpleMessageBoxBuilder; use tedge_api::mqtt_topics::EntityTopicId; @@ -128,12 +130,18 @@ impl<'a> AsMut for MqttActorBuilder<'a> { } } -impl<'a> ServiceProvider for MqttActorBuilder<'a> { - fn connect_consumer( - &mut self, - config: TopicFilter, - response_sender: DynSender, - ) -> DynSender { - self.message_box.connect_consumer(config, response_sender) +impl<'a> MessageSource for MqttActorBuilder<'a> { + fn register_peer(&mut self, config: TopicFilter, sender: DynSender) { + self.message_box.register_peer(config, sender) + } +} + +impl<'a> MessageSink for MqttActorBuilder<'a> { + fn get_config(&self) -> NoConfig { + self.message_box.get_config() + } + + fn get_sender(&self) -> DynSender { + self.message_box.get_sender() } } diff --git a/crates/extensions/tedge_log_manager/src/lib.rs b/crates/extensions/tedge_log_manager/src/lib.rs index 3d84421c229..d3f416ae7c1 100644 --- a/crates/extensions/tedge_log_manager/src/lib.rs +++ b/crates/extensions/tedge_log_manager/src/lib.rs @@ -16,11 +16,11 @@ use tedge_actors::LinkError; use tedge_actors::LoggingSender; use tedge_actors::MessageSink; use tedge_actors::MessageSource; +use tedge_actors::NoConfig; use tedge_actors::NoMessage; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; use tedge_actors::Service; -use tedge_actors::ServiceProvider; use tedge_actors::SimpleMessageBoxBuilder; use tedge_file_system_ext::FsWatchEvent; use tedge_mqtt_ext::*; @@ -43,7 +43,7 @@ pub struct LogManagerBuilder { impl LogManagerBuilder { pub async fn try_new( config: LogManagerConfig, - mqtt: &mut impl ServiceProvider, + mqtt: &mut (impl MessageSource + MessageSink), fs_notify: &mut impl MessageSource, uploader_actor: &mut impl Service, ) -> Result { @@ -51,7 +51,8 @@ impl LogManagerBuilder { let plugin_config = LogPluginConfig::new(&config.plugin_config_path); let box_builder = SimpleMessageBoxBuilder::new("Log Manager", 16); - let mqtt_publisher = mqtt.connect_consumer( + let mqtt_publisher = mqtt.get_sender(); + mqtt.register_peer( Self::subscriptions(&config), box_builder.get_sender().sender_clone(), ); diff --git a/crates/extensions/tedge_mqtt_ext/src/lib.rs b/crates/extensions/tedge_mqtt_ext/src/lib.rs index 092ef5f9cc0..ca9c83a24f9 100644 --- a/crates/extensions/tedge_mqtt_ext/src/lib.rs +++ b/crates/extensions/tedge_mqtt_ext/src/lib.rs @@ -22,7 +22,6 @@ use tedge_actors::RuntimeError; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; use tedge_actors::Sender; -use tedge_actors::ServiceProvider; use tedge_actors::WrappedInput; pub type MqttConfig = mqtt_channel::Config; @@ -74,18 +73,6 @@ impl AsMut for MqttActorBuilder { } } -impl ServiceProvider for MqttActorBuilder { - fn connect_consumer( - &mut self, - subscriptions: TopicFilter, - response_sender: DynSender, - ) -> DynSender { - let sender = LoggingSender::new("MQTT".into(), response_sender); - self.subscriber_addresses.push((subscriptions, sender)); - self.publish_sender.clone().into() - } -} - impl MessageSource for MqttActorBuilder { fn register_peer(&mut self, subscriptions: TopicFilter, sender: DynSender) { let sender = LoggingSender::new("MQTT".into(), sender); diff --git a/crates/extensions/tedge_mqtt_ext/src/tests.rs b/crates/extensions/tedge_mqtt_ext/src/tests.rs index 83372d13ccf..81efdad21cb 100644 --- a/crates/extensions/tedge_mqtt_ext/src/tests.rs +++ b/crates/extensions/tedge_mqtt_ext/src/tests.rs @@ -2,7 +2,6 @@ use crate::*; use mqtt_channel::Topic; use std::time::Duration; use tedge_actors::Builder; -use tedge_actors::ServiceConsumer; use tedge_actors::SimpleMessageBox; use tedge_actors::SimpleMessageBoxBuilder; @@ -31,19 +30,18 @@ impl MqttClientBuilder { box_builder: SimpleMessageBoxBuilder::new(name, capacity), } } -} - -impl ServiceConsumer for MqttClientBuilder { - fn get_config(&self) -> TopicFilter { - self.subscriptions.clone() - } - - fn set_request_sender(&mut self, request_sender: DynSender) { - self.box_builder.set_request_sender(request_sender) - } - fn get_response_sender(&self) -> DynSender { - self.box_builder.get_response_sender() + fn with_connection( + self, + mqtt: &mut (impl MessageSink + MessageSource), + ) -> Self { + let box_builder = self + .box_builder + .with_connection(self.subscriptions.clone(), mqtt); + MqttClientBuilder { + subscriptions: self.subscriptions, + box_builder, + } } } diff --git a/crates/extensions/tedge_timer_ext/src/builder.rs b/crates/extensions/tedge_timer_ext/src/builder.rs index ec788dca377..bd1e793a754 100644 --- a/crates/extensions/tedge_timer_ext/src/builder.rs +++ b/crates/extensions/tedge_timer_ext/src/builder.rs @@ -9,12 +9,13 @@ use tedge_actors::ChannelError; use tedge_actors::CloneSender; use tedge_actors::DynSender; use tedge_actors::Message; +use tedge_actors::MessageSink; use tedge_actors::NoConfig; +use tedge_actors::RequestEnvelope; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; use tedge_actors::Sender; use tedge_actors::ServerMessageBoxBuilder; -use tedge_actors::ServiceProvider; pub struct TimerActorBuilder { box_builder: ServerMessageBoxBuilder, Timeout>, @@ -47,18 +48,15 @@ impl RuntimeRequestSink for TimerActorBuilder { } } -impl ServiceProvider, Timeout, NoConfig> for TimerActorBuilder { - fn connect_consumer( - &mut self, - config: NoConfig, - response_sender: DynSender>, - ) -> DynSender> { - let adapted_response_sender = Box::new(TimeoutSender { - inner: response_sender, - }); - let request_sender = self - .box_builder - .connect_consumer(config, adapted_response_sender); +impl MessageSink, Timeout>, NoConfig> + for TimerActorBuilder +{ + fn get_config(&self) -> NoConfig { + NoConfig + } + + fn get_sender(&self) -> DynSender, Timeout>> { + let request_sender = self.box_builder.get_sender(); Box::new(SetTimeoutSender { inner: request_sender, }) @@ -70,15 +68,7 @@ impl ServiceProvider, Timeout, NoConfig> for TimerA /// This sender receives `Timeout` from the `TimerActor`, /// and translates then forwards these messages to an actor expecting `Timeout` struct TimeoutSender { - inner: DynSender>, -} - -impl Clone for TimeoutSender { - fn clone(&self) -> Self { - TimeoutSender { - inner: self.inner.sender_clone(), - } - } + inner: Box>>, } #[async_trait] @@ -93,10 +83,11 @@ impl Sender> for TimeoutSender { /// A Sender that translates timeout requests on the wire /// -/// This sender receives `SetTimeout` requests from some actor, -/// and translates then forwards these messages to the timer actor expecting`Timeout` +/// This sender receives `RequestEnvelope, Timeout>` requests from some actor, +/// and translates then forwards these messages to the timer actor +/// which is expecting`RequestEnvelope, Timeout`. struct SetTimeoutSender { - inner: DynSender>, + inner: DynSender, Timeout>>, } impl Clone for SetTimeoutSender { @@ -108,10 +99,19 @@ impl Clone for SetTimeoutSender { } #[async_trait] -impl Sender> for SetTimeoutSender { - async fn send(&mut self, request: SetTimeout) -> Result<(), ChannelError> { +impl Sender, Timeout>> for SetTimeoutSender { + async fn send( + &mut self, + RequestEnvelope { request, reply_to }: RequestEnvelope, Timeout>, + ) -> Result<(), ChannelError> { let duration = request.duration; let event: AnyPayload = Box::new(request.event); - self.inner.send(SetTimeout { duration, event }).await + let adapted_reply_to = Box::new(TimeoutSender { inner: reply_to }); + self.inner + .send(RequestEnvelope { + request: SetTimeout { duration, event }, + reply_to: adapted_reply_to, + }) + .await } } diff --git a/crates/extensions/tedge_timer_ext/src/tests.rs b/crates/extensions/tedge_timer_ext/src/tests.rs index 32931a04e8f..25c166ef647 100644 --- a/crates/extensions/tedge_timer_ext/src/tests.rs +++ b/crates/extensions/tedge_timer_ext/src/tests.rs @@ -7,13 +7,14 @@ use tedge_actors::Builder; use tedge_actors::DynSender; use tedge_actors::Message; use tedge_actors::MessageReceiver; +use tedge_actors::MessageSink; +use tedge_actors::MessageSource; use tedge_actors::NoConfig; use tedge_actors::RuntimeError; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; use tedge_actors::Sender; -use tedge_actors::ServiceConsumer; -use tedge_actors::ServiceProvider; +use tedge_actors::Service; use tedge_actors::SimpleMessageBoxBuilder; use tokio::task::JoinHandle; @@ -145,13 +146,13 @@ async fn should_process_all_pending_timers_on_end_of_inputs() { } async fn spawn_timer_actor( - peer: &mut impl ServiceConsumer, Timeout, NoConfig>, + peer: &mut (impl MessageSource, NoConfig> + MessageSink, NoConfig>), ) -> ( JoinHandle>, DynSender, ) { let mut actor = TimerActor::builder(); - actor.add_peer(peer); + peer.register_peer(NoConfig, actor.add_requester(peer.get_sender())); let signal_sender = actor.get_signal_sender(); let handle = tokio::spawn(actor.build().run()); From 9f522a6c713851bbffef60a038814ca2b709dc78 Mon Sep 17 00:00:00 2001 From: Didier Wenzek Date: Tue, 12 Mar 2024 09:23:36 +0100 Subject: [PATCH 3/6] Add a config parameter to MessageSink::add_input This is first step toward removing the Source type parameter to MessageSink. Indeed, this type parameter and the get_config method prevents a sink to receive messages from several sources. Signed-off-by: Didier Wenzek --- crates/core/tedge_actors/src/builders.rs | 14 ++++++++------ crates/core/tedge_actors/src/converter.rs | 10 ++++------ crates/core/tedge_agent/src/agent.rs | 10 +++++++--- crates/core/tedge_mapper/src/aws/mapper.rs | 2 +- crates/core/tedge_mapper/src/az/mapper.rs | 2 +- crates/core/tedge_mapper/src/collectd/mapper.rs | 5 +++-- .../c8y_mapper_ext/src/compatibility_adapter.rs | 2 +- 7 files changed, 25 insertions(+), 20 deletions(-) diff --git a/crates/core/tedge_actors/src/builders.rs b/crates/core/tedge_actors/src/builders.rs index c2e1ded5e64..32ebc26724f 100644 --- a/crates/core/tedge_actors/src/builders.rs +++ b/crates/core/tedge_actors/src/builders.rs @@ -109,12 +109,12 @@ pub trait MessageSink { fn get_sender(&self) -> DynSender; /// Add a source of messages to the actor under construction - fn add_input(&mut self, source: &mut impl MessageSource) + fn add_input(&mut self, config: C, source: &mut impl MessageSource) where N: Message, M: From, { - source.register_peer(self.get_config(), self.get_sender().sender_clone()) + source.register_peer(config, self.get_sender().sender_clone()) } /// Add a source of messages to the actor under construction, the messages being translated on the fly. @@ -129,6 +129,7 @@ pub trait MessageSink { /// # use tedge_actors::MessageReceiver; /// # use tedge_actors::MessageSink; /// # use tedge_actors::NoMessage; + /// # use tedge_actors::NoConfig; /// # use tedge_actors::Sender; /// # use tedge_actors::SimpleMessageBox; /// # use tedge_actors::SimpleMessageBoxBuilder; @@ -142,7 +143,7 @@ pub trait MessageSink { /// let mut sender_builder = SimpleMessageBoxBuilder::new("Send", 16); /// /// // Convert the `&str` sent by the source into an iterator of `char` as expected by the receiver. - /// receiver_builder.add_mapped_input(&mut sender_builder, |str: &'static str| str.chars() ); + /// receiver_builder.add_mapped_input(NoConfig, &mut sender_builder, |str: &'static str| str.chars() ); /// /// let mut sender: SimpleMessageBox= sender_builder.build(); /// let receiver: SimpleMessageBox = receiver_builder.build(); @@ -161,9 +162,10 @@ pub trait MessageSink { /// # Ok(()) /// # } /// ``` - fn add_mapped_input( + fn add_mapped_input( &mut self, - source: &mut impl MessageSource, + config: C, + source: &mut impl MessageSource, cast: MessageMapper, ) where N: Message, @@ -172,7 +174,7 @@ pub trait MessageSink { MessageMapper: 'static + Send + Sync, { let sender = MappingSender::new(self.get_sender(), cast); - source.register_peer(self.get_config(), sender.into()) + source.register_peer(config, sender.into()) } } diff --git a/crates/core/tedge_actors/src/converter.rs b/crates/core/tedge_actors/src/converter.rs index 7f80f9d9a35..4bfab0f5ddb 100644 --- a/crates/core/tedge_actors/src/converter.rs +++ b/crates/core/tedge_actors/src/converter.rs @@ -217,7 +217,7 @@ impl ConvertingActor { /// TopicFilter("some/mqtt/topics/#")); /// /// // Connect this actor as a sink of the mqtt actor, to receive input messages from it -/// converter_builder.add_input(&mut mqtt_builder); +/// converter_builder.add_input(converter_builder.get_config(), &mut mqtt_builder); /// /// // Connect the same mqtt actor as a sink of this actor, to send output messages to it /// converter_builder.add_sink(&mut mqtt_builder); @@ -272,13 +272,11 @@ impl MessageSource } } -impl MessageSink +impl MessageSink for ConvertingActorBuilder -where - SourceConfig: From, { - fn get_config(&self) -> SourceConfig { - self.config.clone().into() + fn get_config(&self) -> Config { + self.config.clone() } fn get_sender(&self) -> DynSender { diff --git a/crates/core/tedge_agent/src/agent.rs b/crates/core/tedge_agent/src/agent.rs index 75b5e1ab6fd..53162efacc0 100644 --- a/crates/core/tedge_agent/src/agent.rs +++ b/crates/core/tedge_agent/src/agent.rs @@ -432,10 +432,14 @@ pub fn create_tedge_to_te_converter( .try_into()?; // Tedge to Te converter - let mut tedge_converter_actor = - ConvertingActor::builder("TedgetoTeConverter", tedge_to_te_converter, subscriptions); + let mut tedge_converter_actor: ConvertingActorBuilder = + ConvertingActor::builder( + "TedgetoTeConverter", + tedge_to_te_converter, + subscriptions.clone(), + ); - tedge_converter_actor.add_input(mqtt_actor_builder); + tedge_converter_actor.add_input(subscriptions, mqtt_actor_builder); tedge_converter_actor.add_sink(mqtt_actor_builder); Ok(tedge_converter_actor) diff --git a/crates/core/tedge_mapper/src/aws/mapper.rs b/crates/core/tedge_mapper/src/aws/mapper.rs index 2f207028f33..7dae451d54b 100644 --- a/crates/core/tedge_mapper/src/aws/mapper.rs +++ b/crates/core/tedge_mapper/src/aws/mapper.rs @@ -44,7 +44,7 @@ impl TEdgeComponent for AwsMapper { get_topic_filter(&tedge_config), ); - aws_converting_actor.add_input(&mut mqtt_actor); + aws_converting_actor.add_input(aws_converting_actor.get_config(), &mut mqtt_actor); aws_converting_actor.register_peer(NoConfig, mqtt_actor.get_sender()); runtime.spawn(aws_converting_actor).await?; diff --git a/crates/core/tedge_mapper/src/az/mapper.rs b/crates/core/tedge_mapper/src/az/mapper.rs index 3cfb0aacd1c..512b7e6ef5e 100644 --- a/crates/core/tedge_mapper/src/az/mapper.rs +++ b/crates/core/tedge_mapper/src/az/mapper.rs @@ -39,7 +39,7 @@ impl TEdgeComponent for AzureMapper { ); let mut az_converting_actor = ConvertingActor::builder("AzConverter", az_converter, get_topic_filter(&tedge_config)); - az_converting_actor.add_input(&mut mqtt_actor); + az_converting_actor.add_input(az_converting_actor.get_config(), &mut mqtt_actor); az_converting_actor.register_peer(NoConfig, mqtt_actor.get_sender()); diff --git a/crates/core/tedge_mapper/src/collectd/mapper.rs b/crates/core/tedge_mapper/src/collectd/mapper.rs index b755f5892e4..0d0f2e8f75d 100644 --- a/crates/core/tedge_mapper/src/collectd/mapper.rs +++ b/crates/core/tedge_mapper/src/collectd/mapper.rs @@ -8,6 +8,7 @@ use mqtt_channel::Topic; use mqtt_channel::TopicFilter; use std::path::Path; use tedge_actors::MessageSink; +use tedge_actors::NoConfig; use tedge_config::TEdgeConfig; const COLLECTD_MAPPER_NAME: &str = "tedge-mapper-collectd"; @@ -47,8 +48,8 @@ impl TEdgeComponent for CollectdMapper { let mut collectd_actor = CollectdActorBuilder::new(input_topic); collectd_actor.add_input(&mut mqtt_actor); - batching_actor.add_input(&mut collectd_actor); - mqtt_actor.add_mapped_input(&mut batching_actor, move |batch| { + batching_actor.add_input(NoConfig, &mut collectd_actor); + mqtt_actor.add_mapped_input(NoConfig, &mut batching_actor, move |batch| { collectd_ext::converter::batch_into_mqtt_messages(&output_topic, batch).into_iter() }); diff --git a/crates/extensions/c8y_mapper_ext/src/compatibility_adapter.rs b/crates/extensions/c8y_mapper_ext/src/compatibility_adapter.rs index 0704f90c840..1f27747faf1 100644 --- a/crates/extensions/c8y_mapper_ext/src/compatibility_adapter.rs +++ b/crates/extensions/c8y_mapper_ext/src/compatibility_adapter.rs @@ -46,7 +46,7 @@ impl OldAgentAdapter { OldAgentAdapter, old_and_new_command_topics(), ); - builder.add_input(mqtt); + builder.add_input(builder.get_config(), mqtt); builder.add_sink(mqtt); builder } From 08fbf67673f6ab3285f6daa5490343529e03e4f9 Mon Sep 17 00:00:00 2001 From: Didier Wenzek Date: Tue, 12 Mar 2024 09:40:25 +0100 Subject: [PATCH 4/6] Add a config parameter to MessageSource::add_sink Signed-off-by: Didier Wenzek --- crates/core/tedge_actors/src/builders.rs | 4 ++-- crates/core/tedge_actors/src/converter.rs | 2 +- crates/core/tedge_agent/src/agent.rs | 3 ++- crates/extensions/c8y_mapper_ext/src/compatibility_adapter.rs | 2 +- crates/extensions/tedge_signal_ext/src/lib.rs | 2 +- 5 files changed, 7 insertions(+), 6 deletions(-) diff --git a/crates/core/tedge_actors/src/builders.rs b/crates/core/tedge_actors/src/builders.rs index 32ebc26724f..2717ee8cdc2 100644 --- a/crates/core/tedge_actors/src/builders.rs +++ b/crates/core/tedge_actors/src/builders.rs @@ -187,8 +187,8 @@ pub trait MessageSource { fn register_peer(&mut self, config: Config, sender: DynSender); /// Connect a peer actor that will consume the message produced by this actor - fn add_sink(&mut self, peer: &impl MessageSink) { - self.register_peer(peer.get_config(), peer.get_sender()); + fn add_sink(&mut self, config: Config, peer: &impl MessageSink) { + self.register_peer(config, peer.get_sender()); } } diff --git a/crates/core/tedge_actors/src/converter.rs b/crates/core/tedge_actors/src/converter.rs index 4bfab0f5ddb..649a1133e0b 100644 --- a/crates/core/tedge_actors/src/converter.rs +++ b/crates/core/tedge_actors/src/converter.rs @@ -220,7 +220,7 @@ impl ConvertingActor { /// converter_builder.add_input(converter_builder.get_config(), &mut mqtt_builder); /// /// // Connect the same mqtt actor as a sink of this actor, to send output messages to it -/// converter_builder.add_sink(&mut mqtt_builder); +/// converter_builder.add_sink(NoConfig, &mut mqtt_builder); /// /// // Finally build the actor /// converter_builder.build() diff --git a/crates/core/tedge_agent/src/agent.rs b/crates/core/tedge_agent/src/agent.rs index 53162efacc0..2e9ddc4ad45 100644 --- a/crates/core/tedge_agent/src/agent.rs +++ b/crates/core/tedge_agent/src/agent.rs @@ -29,6 +29,7 @@ use tedge_actors::ConvertingActor; use tedge_actors::ConvertingActorBuilder; use tedge_actors::MessageSink; use tedge_actors::MessageSource; +use tedge_actors::NoConfig; use tedge_actors::Runtime; use tedge_actors::ServerActorBuilder; use tedge_api::mqtt_topics::DeviceTopicId; @@ -440,7 +441,7 @@ pub fn create_tedge_to_te_converter( ); tedge_converter_actor.add_input(subscriptions, mqtt_actor_builder); - tedge_converter_actor.add_sink(mqtt_actor_builder); + tedge_converter_actor.add_sink(NoConfig, mqtt_actor_builder); Ok(tedge_converter_actor) } diff --git a/crates/extensions/c8y_mapper_ext/src/compatibility_adapter.rs b/crates/extensions/c8y_mapper_ext/src/compatibility_adapter.rs index 1f27747faf1..f01df972266 100644 --- a/crates/extensions/c8y_mapper_ext/src/compatibility_adapter.rs +++ b/crates/extensions/c8y_mapper_ext/src/compatibility_adapter.rs @@ -47,7 +47,7 @@ impl OldAgentAdapter { old_and_new_command_topics(), ); builder.add_input(builder.get_config(), mqtt); - builder.add_sink(mqtt); + builder.add_sink(NoConfig, mqtt); builder } } diff --git a/crates/extensions/tedge_signal_ext/src/lib.rs b/crates/extensions/tedge_signal_ext/src/lib.rs index 2a7735ebb50..6d6c83f05ba 100644 --- a/crates/extensions/tedge_signal_ext/src/lib.rs +++ b/crates/extensions/tedge_signal_ext/src/lib.rs @@ -58,7 +58,7 @@ pub struct SignalActor { impl SignalActor { pub fn builder(runtime: &impl MessageSink) -> SignalActorBuilder { let mut box_builder = SimpleMessageBoxBuilder::new("Signal-Handler", 1); - box_builder.add_sink(runtime); + box_builder.add_sink(NoConfig, runtime); SignalActorBuilder { box_builder } } } From 9bbb6c8095e287a83028262f62738de8ad26aa41 Mon Sep 17 00:00:00 2001 From: Didier Wenzek Date: Tue, 12 Mar 2024 10:13:16 +0100 Subject: [PATCH 5/6] Deprecate MessageSink::get_config All the implementations were either returning NoConfig or delegating some inner implementation. Signed-off-by: Didier Wenzek --- crates/common/batcher/src/lib.rs | 3 -- crates/core/tedge_actors/src/builders.rs | 10 ----- crates/core/tedge_actors/src/converter.rs | 38 ++++++------------- crates/core/tedge_actors/src/lib.rs | 4 -- crates/core/tedge_actors/src/runtime.rs | 4 -- .../core/tedge_actors/src/servers/builders.rs | 8 ---- crates/core/tedge_actors/src/test_helpers.rs | 8 ---- crates/core/tedge_agent/src/agent.rs | 10 ++--- .../src/operation_file_cache/mod.rs | 4 -- .../src/restart_manager/builder.rs | 4 -- .../src/software_manager/builder.rs | 4 -- .../src/tedge_to_te_converter/tests.rs | 4 +- crates/core/tedge_mapper/src/aws/mapper.rs | 8 +--- crates/core/tedge_mapper/src/az/mapper.rs | 5 +-- crates/extensions/c8y_http_proxy/src/lib.rs | 4 -- .../src/compatibility_adapter.rs | 10 ++--- .../extensions/tedge_health_ext/src/tests.rs | 4 -- crates/extensions/tedge_mqtt_ext/src/lib.rs | 4 -- .../extensions/tedge_timer_ext/src/builder.rs | 4 -- 19 files changed, 24 insertions(+), 116 deletions(-) diff --git a/crates/common/batcher/src/lib.rs b/crates/common/batcher/src/lib.rs index 7e132f29bb1..a7709650341 100644 --- a/crates/common/batcher/src/lib.rs +++ b/crates/common/batcher/src/lib.rs @@ -68,9 +68,6 @@ impl BatchingActorBuilder { } impl MessageSink, NoConfig> for BatchingActorBuilder { - fn get_config(&self) -> NoConfig { - NoConfig - } fn get_sender(&self) -> DynSender> { self.message_box.get_sender() } diff --git a/crates/core/tedge_actors/src/builders.rs b/crates/core/tedge_actors/src/builders.rs index 2717ee8cdc2..b82f57856c2 100644 --- a/crates/core/tedge_actors/src/builders.rs +++ b/crates/core/tedge_actors/src/builders.rs @@ -102,9 +102,6 @@ pub struct NoConfig; /// For that purpose each source implementation defines a `Config` type parameter, /// and the sink has to provide the configuration value specific to its needs. pub trait MessageSink { - /// Return the config used by this actor to connect the message source - fn get_config(&self) -> Config; - /// Return the sender that can be used by peers to send messages to this actor fn get_sender(&self) -> DynSender; @@ -299,9 +296,6 @@ pub trait RuntimeRequestSink { /// # } /// # } /// # impl MessageSink for MyActorBuilder { -/// # fn get_config(&self) -> NoConfig { -/// # NoConfig -/// # } /// # fn get_sender(&self) -> DynSender { /// # self.messages.get_sender() /// # } @@ -413,10 +407,6 @@ impl MessageSource for SimpleMessageBoxBuilder< /// A `SimpleMessageBoxBuilder` is a [MessageSink] of `Input` messages with no specific config. impl MessageSink for SimpleMessageBoxBuilder { - fn get_config(&self) -> NoConfig { - NoConfig - } - fn get_sender(&self) -> DynSender { self.input_sender.sender_clone() } diff --git a/crates/core/tedge_actors/src/converter.rs b/crates/core/tedge_actors/src/converter.rs index 649a1133e0b..c1a087f6f73 100644 --- a/crates/core/tedge_actors/src/converter.rs +++ b/crates/core/tedge_actors/src/converter.rs @@ -37,7 +37,7 @@ //! # use std::time::Duration; //! # use tedge_actors::{Actor, Builder, MessageReceiver, MessageSource, NoConfig, Sender}; //! # use tedge_actors::test_helpers::MessageReceiverExt; -//! let mut actor = ConvertingActor::builder("Repeater", Repeater, NoConfig); +//! let mut actor = ConvertingActor::builder("Repeater", Repeater); //! let mut test_box = SimpleMessageBoxBuilder::new("Test", 16).with_connection(NoConfig, &mut actor).build().with_timeout(Duration::from_millis(100)); //! tokio::spawn(async move { actor.build().run().await }); //! @@ -114,12 +114,8 @@ pub struct ConvertingActor { } impl ConvertingActor { - pub fn builder( - name: &str, - converter: C, - config: Config, - ) -> ConvertingActorBuilder { - ConvertingActorBuilder::new(name, converter, config) + pub fn builder(name: &str, converter: C) -> ConvertingActorBuilder { + ConvertingActorBuilder::new(name, converter) } } @@ -214,10 +210,10 @@ impl ConvertingActor { /// let mut converter_builder = ConvertingActor::builder( /// "MyConverter", /// MyConverter, -/// TopicFilter("some/mqtt/topics/#")); +/// ); /// /// // Connect this actor as a sink of the mqtt actor, to receive input messages from it -/// converter_builder.add_input(converter_builder.get_config(), &mut mqtt_builder); +/// converter_builder.add_input(TopicFilter("some/mqtt/topics/#"), &mut mqtt_builder); /// /// // Connect the same mqtt actor as a sink of this actor, to send output messages to it /// converter_builder.add_sink(NoConfig, &mut mqtt_builder); @@ -226,19 +222,17 @@ impl ConvertingActor { /// converter_builder.build() /// } /// ``` -pub struct ConvertingActorBuilder { +pub struct ConvertingActorBuilder { name: String, converter: C, - config: Config, message_box: SimpleMessageBoxBuilder, } -impl ConvertingActorBuilder { - fn new(name: &str, converter: C, config: Config) -> Self { +impl ConvertingActorBuilder { + fn new(name: &str, converter: C) -> Self { ConvertingActorBuilder { name: name.to_string(), converter, - config, message_box: SimpleMessageBoxBuilder::new(name, 16), // FIXME: capacity should not be hardcoded } } @@ -248,7 +242,7 @@ impl ConvertingActorBuilder { } } -impl Builder> for ConvertingActorBuilder { +impl Builder> for ConvertingActorBuilder { type Error = Infallible; fn try_build(self) -> Result, Self::Error> { @@ -264,27 +258,19 @@ impl Builder> for ConvertingActorBuilde } } -impl MessageSource - for ConvertingActorBuilder -{ +impl MessageSource for ConvertingActorBuilder { fn register_peer(&mut self, config: NoConfig, sender: DynSender) { self.message_box.register_peer(config, sender) } } -impl MessageSink - for ConvertingActorBuilder -{ - fn get_config(&self) -> Config { - self.config.clone() - } - +impl MessageSink for ConvertingActorBuilder { fn get_sender(&self) -> DynSender { self.message_box.get_sender() } } -impl RuntimeRequestSink for ConvertingActorBuilder { +impl RuntimeRequestSink for ConvertingActorBuilder { fn get_signal_sender(&self) -> DynSender { self.message_box.get_signal_sender() } diff --git a/crates/core/tedge_actors/src/lib.rs b/crates/core/tedge_actors/src/lib.rs index b00e274fcff..518402c857b 100644 --- a/crates/core/tedge_actors/src/lib.rs +++ b/crates/core/tedge_actors/src/lib.rs @@ -221,10 +221,6 @@ //! /// An actor builder also declares that it consumes messages //! /// by implementing the `MessageSink` trait for the appropriate input and config types. //! impl MessageSink for SomeOtherActorBuilder { -//! fn get_config(&self) -> SomeConfig { -//! todo!() -//! } -//! //! /// Return a sender where to send the input messages. //! fn get_sender(&self) -> DynSender { //! todo!() diff --git a/crates/core/tedge_actors/src/runtime.rs b/crates/core/tedge_actors/src/runtime.rs index 2e063d7bf32..b55c1632d57 100644 --- a/crates/core/tedge_actors/src/runtime.rs +++ b/crates/core/tedge_actors/src/runtime.rs @@ -139,10 +139,6 @@ impl RuntimeHandle { } impl MessageSink for RuntimeHandle { - fn get_config(&self) -> NoConfig { - NoConfig - } - fn get_sender(&self) -> DynSender { self.actions_sender.clone().into() } diff --git a/crates/core/tedge_actors/src/servers/builders.rs b/crates/core/tedge_actors/src/servers/builders.rs index 8fccfff2360..33a234a69c2 100644 --- a/crates/core/tedge_actors/src/servers/builders.rs +++ b/crates/core/tedge_actors/src/servers/builders.rs @@ -77,10 +77,6 @@ impl RuntimeRequestSink for ServerMessageBoxBuilder< impl MessageSink, NoConfig> for ServerMessageBoxBuilder { - fn get_config(&self) -> NoConfig { - NoConfig - } - fn get_sender(&self) -> DynSender> { self.request_sender().sender_clone() } @@ -191,10 +187,6 @@ impl Builder> for ServerActorBuilder impl MessageSink, NoConfig> for ServerActorBuilder { - fn get_config(&self) -> NoConfig { - self.box_builder.get_config() - } - fn get_sender(&self) -> DynSender> { self.box_builder.get_sender() } diff --git a/crates/core/tedge_actors/src/test_helpers.rs b/crates/core/tedge_actors/src/test_helpers.rs index 4581dcd3c67..593de4c2a50 100644 --- a/crates/core/tedge_actors/src/test_helpers.rs +++ b/crates/core/tedge_actors/src/test_helpers.rs @@ -652,10 +652,6 @@ impl MessageSource for Probe } impl MessageSink for Probe { - fn get_config(&self) -> NoConfig { - NoConfig - } - fn get_sender(&self) -> DynSender { self.input_interceptor.clone().into() } @@ -801,10 +797,6 @@ impl Default for FakeServerBoxBuilder MessageSink, NoConfig> for FakeServerBoxBuilder { - fn get_config(&self) -> NoConfig { - NoConfig - } - fn get_sender(&self) -> DynSender> { self.messages.get_sender() } diff --git a/crates/core/tedge_agent/src/agent.rs b/crates/core/tedge_agent/src/agent.rs index 2e9ddc4ad45..379964fb1be 100644 --- a/crates/core/tedge_agent/src/agent.rs +++ b/crates/core/tedge_agent/src/agent.rs @@ -419,7 +419,7 @@ fn load_operation_workflow( pub fn create_tedge_to_te_converter( mqtt_actor_builder: &mut MqttActorBuilder, -) -> Result, anyhow::Error> { +) -> Result, anyhow::Error> { let tedge_to_te_converter = TedgetoTeConverter::new(); let subscriptions: TopicFilter = vec![ @@ -433,12 +433,8 @@ pub fn create_tedge_to_te_converter( .try_into()?; // Tedge to Te converter - let mut tedge_converter_actor: ConvertingActorBuilder = - ConvertingActor::builder( - "TedgetoTeConverter", - tedge_to_te_converter, - subscriptions.clone(), - ); + let mut tedge_converter_actor = + ConvertingActor::builder("TedgetoTeConverter", tedge_to_te_converter); tedge_converter_actor.add_input(subscriptions, mqtt_actor_builder); tedge_converter_actor.add_sink(NoConfig, mqtt_actor_builder); diff --git a/crates/core/tedge_agent/src/operation_file_cache/mod.rs b/crates/core/tedge_agent/src/operation_file_cache/mod.rs index cb20226af97..3da7d052e3d 100644 --- a/crates/core/tedge_agent/src/operation_file_cache/mod.rs +++ b/crates/core/tedge_agent/src/operation_file_cache/mod.rs @@ -324,10 +324,6 @@ impl FileCacheActorBuilder { } impl MessageSink for FileCacheActorBuilder { - fn get_config(&self) -> NoConfig { - NoConfig - } - fn get_sender(&self) -> DynSender { self.message_box.get_sender() } diff --git a/crates/core/tedge_agent/src/restart_manager/builder.rs b/crates/core/tedge_agent/src/restart_manager/builder.rs index 4f71a6c2163..05d0749e583 100644 --- a/crates/core/tedge_agent/src/restart_manager/builder.rs +++ b/crates/core/tedge_agent/src/restart_manager/builder.rs @@ -28,10 +28,6 @@ impl RestartManagerBuilder { } impl MessageSink for RestartManagerBuilder { - fn get_config(&self) -> NoConfig { - NoConfig - } - fn get_sender(&self) -> DynSender { self.message_box.get_sender() } diff --git a/crates/core/tedge_agent/src/software_manager/builder.rs b/crates/core/tedge_agent/src/software_manager/builder.rs index a9484af3180..f906647ce0b 100644 --- a/crates/core/tedge_agent/src/software_manager/builder.rs +++ b/crates/core/tedge_agent/src/software_manager/builder.rs @@ -28,10 +28,6 @@ impl SoftwareManagerBuilder { } impl MessageSink for SoftwareManagerBuilder { - fn get_config(&self) -> NoConfig { - NoConfig - } - fn get_sender(&self) -> DynSender { self.message_box.get_sender() } diff --git a/crates/core/tedge_agent/src/tedge_to_te_converter/tests.rs b/crates/core/tedge_agent/src/tedge_to_te_converter/tests.rs index 653e35cfb97..904377aede1 100644 --- a/crates/core/tedge_agent/src/tedge_to_te_converter/tests.rs +++ b/crates/core/tedge_agent/src/tedge_to_te_converter/tests.rs @@ -329,10 +329,10 @@ async fn spawn_tedge_to_te_converter( // Tedge to Te converter let mut tedge_converter_actor = - ConvertingActor::builder("TedgetoTeConverter", tedge_to_te_converter, subscriptions); + ConvertingActor::builder("TedgetoTeConverter", tedge_to_te_converter); let mut mqtt_box = SimpleMessageBoxBuilder::new("MQTT", 5); - mqtt_box.register_peer(NoConfig, tedge_converter_actor.get_input_sender()); + mqtt_box.register_peer(subscriptions, tedge_converter_actor.get_input_sender()); tedge_converter_actor.register_peer(NoConfig, mqtt_box.get_sender()); let mqtt_box = mqtt_box.build().with_timeout(Duration::from_millis(100)); diff --git a/crates/core/tedge_mapper/src/aws/mapper.rs b/crates/core/tedge_mapper/src/aws/mapper.rs index 7dae451d54b..53d1ccb6342 100644 --- a/crates/core/tedge_mapper/src/aws/mapper.rs +++ b/crates/core/tedge_mapper/src/aws/mapper.rs @@ -38,13 +38,9 @@ impl TEdgeComponent for AwsMapper { mqtt_schema, tedge_config.aws.mapper.timestamp_format, ); - let mut aws_converting_actor = ConvertingActor::builder( - "AwsConverter", - aws_converter, - get_topic_filter(&tedge_config), - ); + let mut aws_converting_actor = ConvertingActor::builder("AwsConverter", aws_converter); - aws_converting_actor.add_input(aws_converting_actor.get_config(), &mut mqtt_actor); + aws_converting_actor.add_input(get_topic_filter(&tedge_config), &mut mqtt_actor); aws_converting_actor.register_peer(NoConfig, mqtt_actor.get_sender()); runtime.spawn(aws_converting_actor).await?; diff --git a/crates/core/tedge_mapper/src/az/mapper.rs b/crates/core/tedge_mapper/src/az/mapper.rs index 512b7e6ef5e..c8bc2594774 100644 --- a/crates/core/tedge_mapper/src/az/mapper.rs +++ b/crates/core/tedge_mapper/src/az/mapper.rs @@ -37,9 +37,8 @@ impl TEdgeComponent for AzureMapper { mqtt_schema, tedge_config.az.mapper.timestamp_format, ); - let mut az_converting_actor = - ConvertingActor::builder("AzConverter", az_converter, get_topic_filter(&tedge_config)); - az_converting_actor.add_input(az_converting_actor.get_config(), &mut mqtt_actor); + let mut az_converting_actor = ConvertingActor::builder("AzConverter", az_converter); + az_converting_actor.add_input(get_topic_filter(&tedge_config), &mut mqtt_actor); az_converting_actor.register_peer(NoConfig, mqtt_actor.get_sender()); diff --git a/crates/extensions/c8y_http_proxy/src/lib.rs b/crates/extensions/c8y_http_proxy/src/lib.rs index ddd9f50dced..09661117bbf 100644 --- a/crates/extensions/c8y_http_proxy/src/lib.rs +++ b/crates/extensions/c8y_http_proxy/src/lib.rs @@ -127,10 +127,6 @@ impl Builder for C8YHttpProxyBuilder { } impl MessageSink, NoConfig> for C8YHttpProxyBuilder { - fn get_config(&self) -> NoConfig { - NoConfig - } - fn get_sender(&self) -> DynSender> { self.clients.get_sender() } diff --git a/crates/extensions/c8y_mapper_ext/src/compatibility_adapter.rs b/crates/extensions/c8y_mapper_ext/src/compatibility_adapter.rs index f01df972266..5c3d51d39ae 100644 --- a/crates/extensions/c8y_mapper_ext/src/compatibility_adapter.rs +++ b/crates/extensions/c8y_mapper_ext/src/compatibility_adapter.rs @@ -40,13 +40,9 @@ pub struct OldAgentAdapter; impl OldAgentAdapter { pub fn builder( mqtt: &mut (impl MessageSource + MessageSink), - ) -> ConvertingActorBuilder { - let mut builder = ConvertingActor::builder( - "OldAgentAdapter", - OldAgentAdapter, - old_and_new_command_topics(), - ); - builder.add_input(builder.get_config(), mqtt); + ) -> ConvertingActorBuilder { + let mut builder = ConvertingActor::builder("OldAgentAdapter", OldAgentAdapter); + builder.add_input(old_and_new_command_topics(), mqtt); builder.add_sink(NoConfig, mqtt); builder } diff --git a/crates/extensions/tedge_health_ext/src/tests.rs b/crates/extensions/tedge_health_ext/src/tests.rs index 26960b36fd2..c55a269f882 100644 --- a/crates/extensions/tedge_health_ext/src/tests.rs +++ b/crates/extensions/tedge_health_ext/src/tests.rs @@ -137,10 +137,6 @@ impl<'a> MessageSource for MqttActorBuilder<'a> { } impl<'a> MessageSink for MqttActorBuilder<'a> { - fn get_config(&self) -> NoConfig { - self.message_box.get_config() - } - fn get_sender(&self) -> DynSender { self.message_box.get_sender() } diff --git a/crates/extensions/tedge_mqtt_ext/src/lib.rs b/crates/extensions/tedge_mqtt_ext/src/lib.rs index ca9c83a24f9..a8ef6af9864 100644 --- a/crates/extensions/tedge_mqtt_ext/src/lib.rs +++ b/crates/extensions/tedge_mqtt_ext/src/lib.rs @@ -81,10 +81,6 @@ impl MessageSource for MqttActorBuilder { } impl MessageSink for MqttActorBuilder { - fn get_config(&self) -> NoConfig { - NoConfig - } - fn get_sender(&self) -> DynSender { self.publish_sender.clone().into() } diff --git a/crates/extensions/tedge_timer_ext/src/builder.rs b/crates/extensions/tedge_timer_ext/src/builder.rs index bd1e793a754..232b01bf59c 100644 --- a/crates/extensions/tedge_timer_ext/src/builder.rs +++ b/crates/extensions/tedge_timer_ext/src/builder.rs @@ -51,10 +51,6 @@ impl RuntimeRequestSink for TimerActorBuilder { impl MessageSink, Timeout>, NoConfig> for TimerActorBuilder { - fn get_config(&self) -> NoConfig { - NoConfig - } - fn get_sender(&self) -> DynSender, Timeout>> { let request_sender = self.box_builder.get_sender(); Box::new(SetTimeoutSender { From bf4fac90ae36260b8f023a16e7ea7b4eadd329c1 Mon Sep 17 00:00:00 2001 From: Didier Wenzek Date: Tue, 12 Mar 2024 10:43:22 +0100 Subject: [PATCH 6/6] Remove Config type parameter from MessageSink Signed-off-by: Didier Wenzek --- crates/common/batcher/src/lib.rs | 2 +- crates/core/tedge_actors/src/builders.rs | 21 +++++++++---------- crates/core/tedge_actors/src/converter.rs | 4 ++-- crates/core/tedge_actors/src/lib.rs | 4 ++-- crates/core/tedge_actors/src/runtime.rs | 3 +-- .../core/tedge_actors/src/servers/builders.rs | 5 ++--- .../tedge_actors/src/servers/message_boxes.rs | 5 +---- crates/core/tedge_actors/src/servers/mod.rs | 8 +++---- crates/core/tedge_actors/src/test_helpers.rs | 8 +++---- .../src/operation_file_cache/mod.rs | 6 ++---- .../src/restart_manager/builder.rs | 2 +- .../src/software_manager/builder.rs | 2 +- .../src/tedge_operation_converter/builder.rs | 8 +++---- .../c8y_firmware_manager/src/lib.rs | 4 +--- crates/extensions/c8y_http_proxy/src/lib.rs | 3 +-- crates/extensions/c8y_mapper_ext/src/actor.rs | 6 ++---- .../src/compatibility_adapter.rs | 2 +- .../tedge_config_manager/src/lib.rs | 3 +-- crates/extensions/tedge_health_ext/src/lib.rs | 2 +- .../extensions/tedge_health_ext/src/tests.rs | 3 +-- .../extensions/tedge_log_manager/src/lib.rs | 3 +-- crates/extensions/tedge_mqtt_ext/src/lib.rs | 3 +-- crates/extensions/tedge_mqtt_ext/src/tests.rs | 2 +- crates/extensions/tedge_signal_ext/src/lib.rs | 2 +- .../extensions/tedge_timer_ext/src/builder.rs | 5 +---- .../extensions/tedge_timer_ext/src/tests.rs | 2 +- 26 files changed, 48 insertions(+), 70 deletions(-) diff --git a/crates/common/batcher/src/lib.rs b/crates/common/batcher/src/lib.rs index a7709650341..ffca9797c28 100644 --- a/crates/common/batcher/src/lib.rs +++ b/crates/common/batcher/src/lib.rs @@ -67,7 +67,7 @@ impl BatchingActorBuilder { } } -impl MessageSink, NoConfig> for BatchingActorBuilder { +impl MessageSink> for BatchingActorBuilder { fn get_sender(&self) -> DynSender> { self.message_box.get_sender() } diff --git a/crates/core/tedge_actors/src/builders.rs b/crates/core/tedge_actors/src/builders.rs index b82f57856c2..a923f69da93 100644 --- a/crates/core/tedge_actors/src/builders.rs +++ b/crates/core/tedge_actors/src/builders.rs @@ -97,15 +97,14 @@ pub struct NoConfig; /// /// An actor whose builder is a `MessageSink` can be connected to any other actor /// whose builder is a `MessageSource` so that the sink can receive messages from that source. -/// -/// A sink might be interested only in a subset of the messages emitted by the source. -/// For that purpose each source implementation defines a `Config` type parameter, -/// and the sink has to provide the configuration value specific to its needs. -pub trait MessageSink { +pub trait MessageSink { /// Return the sender that can be used by peers to send messages to this actor fn get_sender(&self) -> DynSender; /// Add a source of messages to the actor under construction + /// + /// A sink might be interested only in a subset of the messages emitted by the source. + /// This subset is defined by the config parameter. fn add_input(&mut self, config: C, source: &mut impl MessageSource) where N: Message, @@ -178,13 +177,13 @@ pub trait MessageSink { /// The [Builder] of an [Actor](crate::Actor) must implement this trait /// for every message type that actor can send to its peers. /// -/// To receive messages from a `MessageSource`, the peer must be a `MessageSink`. +/// To receive messages from a `MessageSource`, the peer must be a `MessageSink`. pub trait MessageSource { /// The message will be sent to the peer using the provided `sender` fn register_peer(&mut self, config: Config, sender: DynSender); /// Connect a peer actor that will consume the message produced by this actor - fn add_sink(&mut self, config: Config, peer: &impl MessageSink) { + fn add_sink(&mut self, config: Config, peer: &impl MessageSink) { self.register_peer(config, peer.get_sender()); } } @@ -295,7 +294,7 @@ pub trait RuntimeRequestSink { /// # self.messages.register_peer(config, sender) /// # } /// # } -/// # impl MessageSink for MyActorBuilder { +/// # impl MessageSink for MyActorBuilder { /// # fn get_sender(&self) -> DynSender { /// # self.messages.get_sender() /// # } @@ -378,7 +377,7 @@ impl SimpleMessageBoxBuilder { pub fn set_connection( &mut self, config: Config, - service: &mut (impl MessageSink + MessageSource), + service: &mut (impl MessageSink + MessageSource), ) { service.register_peer(config, self.input_sender.sender_clone()); self.register_peer(NoConfig, service.get_sender()); @@ -391,7 +390,7 @@ impl SimpleMessageBoxBuilder { pub fn with_connection( mut self, config: Config, - service: &mut (impl MessageSink + MessageSource), + service: &mut (impl MessageSink + MessageSource), ) -> Self { self.set_connection(config, service); self @@ -406,7 +405,7 @@ impl MessageSource for SimpleMessageBoxBuilder< } /// A `SimpleMessageBoxBuilder` is a [MessageSink] of `Input` messages with no specific config. -impl MessageSink for SimpleMessageBoxBuilder { +impl MessageSink for SimpleMessageBoxBuilder { fn get_sender(&self) -> DynSender { self.input_sender.sender_clone() } diff --git a/crates/core/tedge_actors/src/converter.rs b/crates/core/tedge_actors/src/converter.rs index c1a087f6f73..481a4694b10 100644 --- a/crates/core/tedge_actors/src/converter.rs +++ b/crates/core/tedge_actors/src/converter.rs @@ -204,7 +204,7 @@ impl ConvertingActor { /// /// /// Return a converting actor connected to a peer that is both a source and sink of MQTT messages /// fn new_converter( -/// mut mqtt_builder: impl MessageSource + MessageSink +/// mut mqtt_builder: impl MessageSource + MessageSink /// ) -> ConvertingActor { /// // Use a builder to connect and build the actor /// let mut converter_builder = ConvertingActor::builder( @@ -264,7 +264,7 @@ impl MessageSource for ConvertingActorBuilder } } -impl MessageSink for ConvertingActorBuilder { +impl MessageSink for ConvertingActorBuilder { fn get_sender(&self) -> DynSender { self.message_box.get_sender() } diff --git a/crates/core/tedge_actors/src/lib.rs b/crates/core/tedge_actors/src/lib.rs index 518402c857b..040a83f5ef3 100644 --- a/crates/core/tedge_actors/src/lib.rs +++ b/crates/core/tedge_actors/src/lib.rs @@ -219,8 +219,8 @@ //! } //! //! /// An actor builder also declares that it consumes messages -//! /// by implementing the `MessageSink` trait for the appropriate input and config types. -//! impl MessageSink for SomeOtherActorBuilder { +//! /// by implementing the `MessageSink` trait for the appropriate input type. +//! impl MessageSink for SomeOtherActorBuilder { //! /// Return a sender where to send the input messages. //! fn get_sender(&self) -> DynSender { //! todo!() diff --git a/crates/core/tedge_actors/src/runtime.rs b/crates/core/tedge_actors/src/runtime.rs index b55c1632d57..de7a73a940a 100644 --- a/crates/core/tedge_actors/src/runtime.rs +++ b/crates/core/tedge_actors/src/runtime.rs @@ -6,7 +6,6 @@ use crate::Builder; use crate::ChannelError; use crate::DynSender; use crate::MessageSink; -use crate::NoConfig; use crate::RuntimeError; use crate::RuntimeRequestSink; use futures::channel::mpsc; @@ -138,7 +137,7 @@ impl RuntimeHandle { } } -impl MessageSink for RuntimeHandle { +impl MessageSink for RuntimeHandle { fn get_sender(&self) -> DynSender { self.actions_sender.clone().into() } diff --git a/crates/core/tedge_actors/src/servers/builders.rs b/crates/core/tedge_actors/src/servers/builders.rs index 33a234a69c2..11e74d19e8e 100644 --- a/crates/core/tedge_actors/src/servers/builders.rs +++ b/crates/core/tedge_actors/src/servers/builders.rs @@ -9,7 +9,6 @@ use crate::DynSender; use crate::LoggingReceiver; use crate::Message; use crate::MessageSink; -use crate::NoConfig; use crate::RequestEnvelope; use crate::RuntimeError; use crate::RuntimeRequest; @@ -74,7 +73,7 @@ impl RuntimeRequestSink for ServerMessageBoxBuilder< } } -impl MessageSink, NoConfig> +impl MessageSink> for ServerMessageBoxBuilder { fn get_sender(&self) -> DynSender> { @@ -184,7 +183,7 @@ impl Builder> for ServerActorBuilder } } -impl MessageSink, NoConfig> +impl MessageSink> for ServerActorBuilder { fn get_sender(&self) -> DynSender> { diff --git a/crates/core/tedge_actors/src/servers/message_boxes.rs b/crates/core/tedge_actors/src/servers/message_boxes.rs index 509df15e00b..0eafa8001ca 100644 --- a/crates/core/tedge_actors/src/servers/message_boxes.rs +++ b/crates/core/tedge_actors/src/servers/message_boxes.rs @@ -5,7 +5,6 @@ use crate::LoggingReceiver; use crate::Message; use crate::MessageReceiver; use crate::MessageSink; -use crate::NoConfig; use crate::RequestEnvelope; use crate::RuntimeRequest; use crate::Sender; @@ -111,9 +110,7 @@ impl Clone for ClientMessageBox ClientMessageBox { /// Create a [ClientMessageBox] connected to a given [Server] - pub fn new( - server: &mut impl MessageSink, NoConfig>, - ) -> Self { + pub fn new(server: &mut impl MessageSink>) -> Self { ClientMessageBox { sender: server.get_sender(), } diff --git a/crates/core/tedge_actors/src/servers/mod.rs b/crates/core/tedge_actors/src/servers/mod.rs index eee463f04fe..a8f2bf4418a 100644 --- a/crates/core/tedge_actors/src/servers/mod.rs +++ b/crates/core/tedge_actors/src/servers/mod.rs @@ -149,20 +149,20 @@ pub type DynRequestSender = DynSender: - MessageSink, NoConfig> + MessageSink> { /// Connect a request message box to the server box under construction fn add_requester(&mut self, response_sender: DynSender) -> DynSender; fn add_client( &mut self, - client: &mut (impl MessageSource + MessageSink), + client: &mut (impl MessageSource + MessageSink), ); } impl Service for T where - T: MessageSink, NoConfig>, + T: MessageSink>, { fn add_requester(&mut self, reply_to: DynSender) -> DynSender { let request_sender = RequestSender { @@ -174,7 +174,7 @@ where fn add_client( &mut self, - client: &mut (impl MessageSource + MessageSink), + client: &mut (impl MessageSource + MessageSink), ) { let request_sender = self.add_requester(client.get_sender()); client.register_peer(NoConfig, request_sender); diff --git a/crates/core/tedge_actors/src/test_helpers.rs b/crates/core/tedge_actors/src/test_helpers.rs index 593de4c2a50..b08396490de 100644 --- a/crates/core/tedge_actors/src/test_helpers.rs +++ b/crates/core/tedge_actors/src/test_helpers.rs @@ -519,7 +519,7 @@ impl Probe { &mut self, config: C, source: &mut impl MessageSource, - sink: &mut impl MessageSink, + sink: &mut impl MessageSink, ) { self.output_forwarder = sink.get_sender(); source.register_peer(config, self.input_interceptor.clone().into()); @@ -633,7 +633,7 @@ pub trait ServiceConsumerExt { impl ServiceConsumerExt for T where T: MessageSource, - T: MessageSink, + T: MessageSink, { fn with_probe<'a>( &'a mut self, @@ -651,7 +651,7 @@ impl MessageSource for Probe } } -impl MessageSink for Probe { +impl MessageSink for Probe { fn get_sender(&self) -> DynSender { self.input_interceptor.clone().into() } @@ -794,7 +794,7 @@ impl Default for FakeServerBoxBuilder MessageSink, NoConfig> +impl MessageSink> for FakeServerBoxBuilder { fn get_sender(&self) -> DynSender> { diff --git a/crates/core/tedge_agent/src/operation_file_cache/mod.rs b/crates/core/tedge_agent/src/operation_file_cache/mod.rs index 3da7d052e3d..e7b6a3bfaa6 100644 --- a/crates/core/tedge_agent/src/operation_file_cache/mod.rs +++ b/crates/core/tedge_agent/src/operation_file_cache/mod.rs @@ -26,7 +26,6 @@ use tedge_actors::LoggingReceiver; use tedge_actors::MessageReceiver; use tedge_actors::MessageSink; use tedge_actors::MessageSource; -use tedge_actors::NoConfig; use tedge_actors::RuntimeError; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; @@ -291,8 +290,7 @@ impl FileCacheActorBuilder { tedge_http_host: Arc, data_dir: DataDir, downloader_actor: &mut impl Service, - mqtt_actor: &mut (impl MessageSource - + MessageSink), + mqtt_actor: &mut (impl MessageSource + MessageSink), ) -> Self { let message_box = SimpleMessageBoxBuilder::new("RestartManager", 10); @@ -323,7 +321,7 @@ impl FileCacheActorBuilder { } } -impl MessageSink for FileCacheActorBuilder { +impl MessageSink for FileCacheActorBuilder { fn get_sender(&self) -> DynSender { self.message_box.get_sender() } diff --git a/crates/core/tedge_agent/src/restart_manager/builder.rs b/crates/core/tedge_agent/src/restart_manager/builder.rs index 05d0749e583..b2a6b817b01 100644 --- a/crates/core/tedge_agent/src/restart_manager/builder.rs +++ b/crates/core/tedge_agent/src/restart_manager/builder.rs @@ -27,7 +27,7 @@ impl RestartManagerBuilder { } } -impl MessageSink for RestartManagerBuilder { +impl MessageSink for RestartManagerBuilder { fn get_sender(&self) -> DynSender { self.message_box.get_sender() } diff --git a/crates/core/tedge_agent/src/software_manager/builder.rs b/crates/core/tedge_agent/src/software_manager/builder.rs index f906647ce0b..5e72f01c743 100644 --- a/crates/core/tedge_agent/src/software_manager/builder.rs +++ b/crates/core/tedge_agent/src/software_manager/builder.rs @@ -27,7 +27,7 @@ impl SoftwareManagerBuilder { } } -impl MessageSink for SoftwareManagerBuilder { +impl MessageSink for SoftwareManagerBuilder { fn get_sender(&self) -> DynSender { self.message_box.get_sender() } diff --git a/crates/core/tedge_agent/src/tedge_operation_converter/builder.rs b/crates/core/tedge_agent/src/tedge_operation_converter/builder.rs index 2e7dde6f868..992329747d2 100644 --- a/crates/core/tedge_agent/src/tedge_operation_converter/builder.rs +++ b/crates/core/tedge_agent/src/tedge_operation_converter/builder.rs @@ -46,12 +46,10 @@ impl TedgeOperationConverterBuilder { pub fn new( config: OperationConfig, mut workflows: WorkflowSupervisor, - software_actor: &mut (impl MessageSink + software_actor: &mut (impl MessageSink + MessageSource), - restart_actor: &mut (impl MessageSink - + MessageSource), - mqtt_actor: &mut (impl MessageSource - + MessageSink), + restart_actor: &mut (impl MessageSink + MessageSource), + mqtt_actor: &mut (impl MessageSource + MessageSink), script_runner: &mut impl Service>, ) -> Self { let (input_sender, input_receiver) = mpsc::unbounded(); diff --git a/crates/extensions/c8y_firmware_manager/src/lib.rs b/crates/extensions/c8y_firmware_manager/src/lib.rs index 1abc83c2b0e..7001715d851 100644 --- a/crates/extensions/c8y_firmware_manager/src/lib.rs +++ b/crates/extensions/c8y_firmware_manager/src/lib.rs @@ -21,7 +21,6 @@ use tedge_actors::LinkError; use tedge_actors::LoggingReceiver; use tedge_actors::MessageSink; use tedge_actors::MessageSource; -use tedge_actors::NoConfig; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; use tedge_actors::Service; @@ -47,8 +46,7 @@ pub struct FirmwareManagerBuilder { impl FirmwareManagerBuilder { pub fn try_new( config: FirmwareManagerConfig, - mqtt_actor: &mut (impl MessageSource - + MessageSink), + mqtt_actor: &mut (impl MessageSource + MessageSink), jwt_actor: &mut impl Service<(), JwtResult>, downloader_actor: &mut impl Service, ) -> Result { diff --git a/crates/extensions/c8y_http_proxy/src/lib.rs b/crates/extensions/c8y_http_proxy/src/lib.rs index 09661117bbf..b744dc171cd 100644 --- a/crates/extensions/c8y_http_proxy/src/lib.rs +++ b/crates/extensions/c8y_http_proxy/src/lib.rs @@ -12,7 +12,6 @@ use tedge_actors::Builder; use tedge_actors::ClientMessageBox; use tedge_actors::DynSender; use tedge_actors::MessageSink; -use tedge_actors::NoConfig; use tedge_actors::RequestEnvelope; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; @@ -126,7 +125,7 @@ impl Builder for C8YHttpProxyBuilder { } } -impl MessageSink, NoConfig> for C8YHttpProxyBuilder { +impl MessageSink> for C8YHttpProxyBuilder { fn get_sender(&self) -> DynSender> { self.clients.get_sender() } diff --git a/crates/extensions/c8y_mapper_ext/src/actor.rs b/crates/extensions/c8y_mapper_ext/src/actor.rs index a36efdb799a..6db2c6cf436 100644 --- a/crates/extensions/c8y_mapper_ext/src/actor.rs +++ b/crates/extensions/c8y_mapper_ext/src/actor.rs @@ -24,7 +24,6 @@ use tedge_actors::LoggingSender; use tedge_actors::MessageReceiver; use tedge_actors::MessageSink; use tedge_actors::MessageSource; -use tedge_actors::NoConfig; use tedge_actors::RuntimeError; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; @@ -294,14 +293,13 @@ impl C8yMapperBuilder { #[allow(clippy::too_many_arguments)] pub fn try_new( config: C8yMapperConfig, - mqtt: &mut (impl MessageSource + MessageSink), + mqtt: &mut (impl MessageSource + MessageSink), http: &mut impl Service, timer: &mut impl Service, uploader: &mut impl Service, downloader: &mut impl Service, fs_watcher: &mut impl MessageSource, - service_monitor: &mut (impl MessageSource - + MessageSink), + service_monitor: &mut (impl MessageSource + MessageSink), ) -> Result { Self::init(&config)?; diff --git a/crates/extensions/c8y_mapper_ext/src/compatibility_adapter.rs b/crates/extensions/c8y_mapper_ext/src/compatibility_adapter.rs index 5c3d51d39ae..6678bf11ad1 100644 --- a/crates/extensions/c8y_mapper_ext/src/compatibility_adapter.rs +++ b/crates/extensions/c8y_mapper_ext/src/compatibility_adapter.rs @@ -39,7 +39,7 @@ pub struct OldAgentAdapter; impl OldAgentAdapter { pub fn builder( - mqtt: &mut (impl MessageSource + MessageSink), + mqtt: &mut (impl MessageSource + MessageSink), ) -> ConvertingActorBuilder { let mut builder = ConvertingActor::builder("OldAgentAdapter", OldAgentAdapter); builder.add_input(old_and_new_command_topics(), mqtt); diff --git a/crates/extensions/tedge_config_manager/src/lib.rs b/crates/extensions/tedge_config_manager/src/lib.rs index 6db0879d77d..8b90f01afa5 100644 --- a/crates/extensions/tedge_config_manager/src/lib.rs +++ b/crates/extensions/tedge_config_manager/src/lib.rs @@ -16,7 +16,6 @@ use tedge_actors::LoggingReceiver; use tedge_actors::LoggingSender; use tedge_actors::MessageSink; use tedge_actors::MessageSource; -use tedge_actors::NoConfig; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; use tedge_actors::Service; @@ -46,7 +45,7 @@ pub struct ConfigManagerBuilder { impl ConfigManagerBuilder { pub async fn try_new( config: ConfigManagerConfig, - mqtt: &mut (impl MessageSource + MessageSink), + mqtt: &mut (impl MessageSource + MessageSink), fs_notify: &mut impl MessageSource, downloader_actor: &mut impl Service, uploader_actor: &mut impl Service, diff --git a/crates/extensions/tedge_health_ext/src/lib.rs b/crates/extensions/tedge_health_ext/src/lib.rs index 3c7f98f1fcf..3eb694814c2 100644 --- a/crates/extensions/tedge_health_ext/src/lib.rs +++ b/crates/extensions/tedge_health_ext/src/lib.rs @@ -38,7 +38,7 @@ impl HealthMonitorBuilder { pub fn from_service_topic_id( service: Service, mqtt: &mut (impl MessageSource - + MessageSink + + MessageSink + AsMut), // TODO: pass it less annoying way mqtt_schema: &MqttSchema, diff --git a/crates/extensions/tedge_health_ext/src/tests.rs b/crates/extensions/tedge_health_ext/src/tests.rs index c55a269f882..021f8704e82 100644 --- a/crates/extensions/tedge_health_ext/src/tests.rs +++ b/crates/extensions/tedge_health_ext/src/tests.rs @@ -8,7 +8,6 @@ use tedge_actors::DynSender; use tedge_actors::MessageReceiver; use tedge_actors::MessageSink; use tedge_actors::MessageSource; -use tedge_actors::NoConfig; use tedge_actors::SimpleMessageBox; use tedge_actors::SimpleMessageBoxBuilder; use tedge_api::mqtt_topics::EntityTopicId; @@ -136,7 +135,7 @@ impl<'a> MessageSource for MqttActorBuilder<'a> { } } -impl<'a> MessageSink for MqttActorBuilder<'a> { +impl<'a> MessageSink for MqttActorBuilder<'a> { fn get_sender(&self) -> DynSender { self.message_box.get_sender() } diff --git a/crates/extensions/tedge_log_manager/src/lib.rs b/crates/extensions/tedge_log_manager/src/lib.rs index d3f416ae7c1..b687f2a020c 100644 --- a/crates/extensions/tedge_log_manager/src/lib.rs +++ b/crates/extensions/tedge_log_manager/src/lib.rs @@ -16,7 +16,6 @@ use tedge_actors::LinkError; use tedge_actors::LoggingSender; use tedge_actors::MessageSink; use tedge_actors::MessageSource; -use tedge_actors::NoConfig; use tedge_actors::NoMessage; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; @@ -43,7 +42,7 @@ pub struct LogManagerBuilder { impl LogManagerBuilder { pub async fn try_new( config: LogManagerConfig, - mqtt: &mut (impl MessageSource + MessageSink), + mqtt: &mut (impl MessageSource + MessageSink), fs_notify: &mut impl MessageSource, uploader_actor: &mut impl Service, ) -> Result { diff --git a/crates/extensions/tedge_mqtt_ext/src/lib.rs b/crates/extensions/tedge_mqtt_ext/src/lib.rs index a8ef6af9864..bbef7eb2413 100644 --- a/crates/extensions/tedge_mqtt_ext/src/lib.rs +++ b/crates/extensions/tedge_mqtt_ext/src/lib.rs @@ -17,7 +17,6 @@ use tedge_actors::LoggingSender; use tedge_actors::MessageReceiver; use tedge_actors::MessageSink; use tedge_actors::MessageSource; -use tedge_actors::NoConfig; use tedge_actors::RuntimeError; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; @@ -80,7 +79,7 @@ impl MessageSource for MqttActorBuilder { } } -impl MessageSink for MqttActorBuilder { +impl MessageSink for MqttActorBuilder { fn get_sender(&self) -> DynSender { self.publish_sender.clone().into() } diff --git a/crates/extensions/tedge_mqtt_ext/src/tests.rs b/crates/extensions/tedge_mqtt_ext/src/tests.rs index 81efdad21cb..62ce2a7505b 100644 --- a/crates/extensions/tedge_mqtt_ext/src/tests.rs +++ b/crates/extensions/tedge_mqtt_ext/src/tests.rs @@ -33,7 +33,7 @@ impl MqttClientBuilder { fn with_connection( self, - mqtt: &mut (impl MessageSink + MessageSource), + mqtt: &mut (impl MessageSink + MessageSource), ) -> Self { let box_builder = self .box_builder diff --git a/crates/extensions/tedge_signal_ext/src/lib.rs b/crates/extensions/tedge_signal_ext/src/lib.rs index 6d6c83f05ba..a17e76a6d28 100644 --- a/crates/extensions/tedge_signal_ext/src/lib.rs +++ b/crates/extensions/tedge_signal_ext/src/lib.rs @@ -56,7 +56,7 @@ pub struct SignalActor { } impl SignalActor { - pub fn builder(runtime: &impl MessageSink) -> SignalActorBuilder { + pub fn builder(runtime: &impl MessageSink) -> SignalActorBuilder { let mut box_builder = SimpleMessageBoxBuilder::new("Signal-Handler", 1); box_builder.add_sink(NoConfig, runtime); SignalActorBuilder { box_builder } diff --git a/crates/extensions/tedge_timer_ext/src/builder.rs b/crates/extensions/tedge_timer_ext/src/builder.rs index 232b01bf59c..80c4b51ae2f 100644 --- a/crates/extensions/tedge_timer_ext/src/builder.rs +++ b/crates/extensions/tedge_timer_ext/src/builder.rs @@ -10,7 +10,6 @@ use tedge_actors::CloneSender; use tedge_actors::DynSender; use tedge_actors::Message; use tedge_actors::MessageSink; -use tedge_actors::NoConfig; use tedge_actors::RequestEnvelope; use tedge_actors::RuntimeRequest; use tedge_actors::RuntimeRequestSink; @@ -48,9 +47,7 @@ impl RuntimeRequestSink for TimerActorBuilder { } } -impl MessageSink, Timeout>, NoConfig> - for TimerActorBuilder -{ +impl MessageSink, Timeout>> for TimerActorBuilder { fn get_sender(&self) -> DynSender, Timeout>> { let request_sender = self.box_builder.get_sender(); Box::new(SetTimeoutSender { diff --git a/crates/extensions/tedge_timer_ext/src/tests.rs b/crates/extensions/tedge_timer_ext/src/tests.rs index 25c166ef647..45a2e60a0f0 100644 --- a/crates/extensions/tedge_timer_ext/src/tests.rs +++ b/crates/extensions/tedge_timer_ext/src/tests.rs @@ -146,7 +146,7 @@ async fn should_process_all_pending_timers_on_end_of_inputs() { } async fn spawn_timer_actor( - peer: &mut (impl MessageSource, NoConfig> + MessageSink, NoConfig>), + peer: &mut (impl MessageSource, NoConfig> + MessageSink>), ) -> ( JoinHandle>, DynSender,