Rename Comms to CoreCommunication

This makes the name clearer and shows that one speaks to the Core that
orchestrates the rest.

Signed-off-by: Marcel Müller <m.mueller@ifm.com>

4 files changed, 34 insertions, 28 deletions

diff --git a/crates/core/tedge_api/examples/heartbeat.rs b/crates/core/tedge_api/examples/heartbeat.rs
index 5c96a0fc..10c1a6c6 100644
--- a/crates/core/tedge_api/examples/heartbeat.rs
+++ b/crates/core/tedge_api/examples/heartbeat.rs
@@ -1,6 +1,6 @@
 use async_trait::async_trait;
 use tedge_api::{
-    address::EndpointKind, Address, Comms, Message, MessageKind, Plugin, PluginBuilder,
+    address::EndpointKind, Address, CoreCommunication, Message, MessageKind, Plugin, PluginBuilder,
     PluginConfiguration, PluginError,
 };
 
@@ -15,14 +15,14 @@ impl PluginBuilder for HeartbeatServiceBuilder {
     async fn verify_configuration(
         &self,
         _config: &PluginConfiguration,
-    ) -> Result<(), tedge_api::errors::PluginError> {
+    ) -> Result<(), tedge_api::error::PluginError> {
         Ok(())
     }
 
     async fn instantiate(
         &self,
         config: PluginConfiguration,
-        tedge_comms: tedge_api::plugins::Comms,
+        tedge_comms: tedge_api::plugin::CoreCommunication,
     ) -> Result<Box<dyn Plugin>, PluginError> {
         let hb_config: HeartbeatConfig = toml::Value::try_into(config.into_inner())?;
         Ok(Box::new(HeartbeatService::new(tedge_comms, hb_config)))
@@ -35,12 +35,12 @@ struct HeartbeatConfig {
 }
 
 struct HeartbeatService {
-    comms: tedge_api::plugins::Comms,
+    comms: tedge_api::plugin::CoreCommunication,
     config: HeartbeatConfig,
 }
 
 impl HeartbeatService {
-    fn new(comms: tedge_api::plugins::Comms, config: HeartbeatConfig) -> Self {
+    fn new(comms: tedge_api::plugin::CoreCommunication, config: HeartbeatConfig) -> Self {
         Self { comms, config }
     }
 }
@@ -61,8 +61,7 @@ impl Plugin for HeartbeatService {
                 let kind = MessageKind::SignalPluginState {
                     state: String::from("Ok"),
                 };
-                let msg = self.comms.new_message(message.origin().clone(), kind);
-                self.comms.send(msg).await?;
+                self.comms.send(kind, message.origin().clone()).await?;
             }
             msg => println!("Does not handle: {:#?}", msg),
         }
@@ -81,7 +80,8 @@ async fn main() {
     let hsb = HeartbeatServiceBuilder;
     let (sender, mut receiver) = tokio::sync::mpsc::channel(10);
 
-    let comms = Comms::new("heartbeat-service".to_string(), sender);
+    let plugin_name = "heartbeat-service".to_string();
+    let comms = CoreCommunication::new(plugin_name.clone(), sender);
 
     let config = toml::from_str(
         r#"
@@ -97,10 +97,9 @@ async fn main() {
     let handle = tokio::task::spawn(async move {
         let hb = heartbeat;
 
-        hb.handle_message(comms.new_message(
-            Address::new(EndpointKind::Plugin {
-                id: "heartbeat-service".to_string(),
-            }),
+        hb.handle_message(Message::new(
+            Address::new(EndpointKind::Plugin { id: plugin_name }),
+            Address::new(EndpointKind::Core),
             MessageKind::CheckReadyness,
         ))
         .await
diff --git a/crates/core/tedge_api/src/lib.rs b/crates/core/tedge_api/src/lib.rs
index e37cb82a..99af771b 100644
--- a/crates/core/tedge_api/src/lib.rs
+++ b/crates/core/tedge_api/src/lib.rs
@@ -1,5 +1,5 @@
 pub mod plugin;
-pub use plugin::{Comms, Plugin, PluginBuilder, PluginConfiguration};
+pub use plugin::{CoreCommunication, Plugin, PluginBuilder, PluginConfiguration};
 
 pub mod address;
 pub use address::Address;
diff --git a/crates/core/tedge_api/src/message.rs b/crates/core/tedge_api/src/message.rs
index 6ae74219..7ebceba5 100644
--- a/crates/core/tedge_api/src/message.rs
+++ b/crates/core/tedge_api/src/message.rs
@@ -10,7 +10,8 @@ pub struct Message {
 }
 
 impl Message {
-    pub(crate) fn new(origin: Address, destination: Address, kind: MessageKind) -> Self {
+    #[doc(hidden)]
+    pub fn new(origin: Address, destination: Address, kind: MessageKind) -> Self {
         Self {
             origin,
             destination,
diff --git a/crates/core/tedge_api/src/plugin.rs b/crates/core/tedge_api/src/plugin.rs
index 6a55c344..fc881498 100644
--- a/crates/core/tedge_api/src/plugin.rs
+++ b/crates/core/tedge_api/src/plugin.rs
@@ -6,23 +6,28 @@
 
 use async_trait::async_trait;
 
-use crate::{error::PluginError, message::Message};
+use crate::{error::PluginError, message::Message, Address, MessageKind};
 
+/// The communication struct to interface with the core of ThinEdge
+///
+/// It's main purpose is the [`send`](CoreCommunication::send) method, through which one plugin
+/// can communicate with another.
 #[derive(Clone)]
-pub struct Comms {
+pub struct CoreCommunication {
     plugin_name: String,
     sender: tokio::sync::mpsc::Sender<Message>,
 }
 
-impl std::fmt::Debug for Comms {
+impl std::fmt::Debug for CoreCommunication {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         f.debug_struct("Comms")
             .field("plugin_name", &self.plugin_name)
-            .finish()
+            .finish_non_exhaustive()
     }
 }
 
-impl Comms {
+impl CoreCommunication {
+    #[doc(hidden)]
     pub fn new(plugin_name: String, sender: tokio::sync::mpsc::Sender<Message>) -> Self {
         Self {
             plugin_name,
@@ -30,14 +35,15 @@ impl Comms {
         }
     }
 
-    pub fn new_message(&self, destination: crate::Address, kind: crate::MessageKind) -> Message {
-        let addr = crate::Address::new(crate::address::EndpointKind::Plugin {
+    pub async fn send(
+        &self,
+        msg_kind: MessageKind,
+        destination: Address,
+    ) -> Result<(), PluginError> {
+        let origin = Address::new(crate::address::EndpointKind::Plugin {
             id: self.plugin_name.clone(),
         });
-        Message::new(addr, destination, kind)
-    }
-
-    pub async fn send<T: Into<Message>>(&self, msg: T) -> Result<(), PluginError> {
+        let msg = Message::new(origin, destination, msg_kind);
         self.sender.send(msg.into()).await?;
 
         Ok(())
@@ -67,7 +73,7 @@ pub trait PluginBuilder: Sync + Send + 'static {
     async fn instantiate(
         &self,
         config: PluginConfiguration,
-        tedge_comms: Comms,
+        core_comms: CoreCommunication,
     ) -> Result<Box<dyn Plugin + 'static>, PluginError>;
 }
 
@@ -86,7 +92,7 @@ pub trait Plugin: Sync + Send {
 
 #[cfg(test)]
 mod tests {
-    use super::{Comms, Plugin, PluginBuilder};
+    use super::{CoreCommunication, Plugin, PluginBuilder};
     use static_assertions::{assert_impl_all, assert_obj_safe};
 
     // Object Safety
@@ -94,5 +100,5 @@ mod tests {
     assert_obj_safe!(Plugin);
 
     // Sync + Send
-    assert_impl_all!(Comms: Send, Clone);
+    assert_impl_all!(CoreCommunication: Send, Clone);
 }