Only keep close_receiver behind a lock

When creating ClientInner I moved all of the attributes from Client
there, but senders can be cloned without a an Arc<RwLock<...>>

coordinator/src/main.rs

@@ -88,6 +88,7 @@ impl Coordinator for CoordinatorService {
         let scenarios = self.scenarios.lock().await;
         let scenario = scenarios.get(&name).ok_or(CoordinatorError::NoSuchModule(name.clone()))?.to_owned();
         drop(scenarios);
+
         let runtime = crows_wasm::Runtime::new(&scenario).map_err(|err| CoordinatorError::FailedToCreateRuntime(err.to_string()))?;
         let (instance, _, mut store) = Instance::new(&runtime.environment, &runtime.module).await.map_err(|_| CoordinatorError::FailedToCompileModule)?;
         let config = fetch_config(instance, &mut store).await.map_err(|err| CoordinatorError::CouldNotFetchConfig(err.to_string()))?.split(workers_number);

utils/src/lib.rs

@@ -159,11 +159,11 @@ enum InternalMessage {
 #[derive(Clone)]
 pub struct Client {
     inner: Arc<RwLock<ClientInner>>,
+    sender: UnboundedSender<Message>,
+    internal_sender: UnboundedSender<InternalMessage>,
 }
 
 struct ClientInner {
-    sender: UnboundedSender<Message>,
-    internal_sender: UnboundedSender<InternalMessage>,
     close_receiver: Option<oneshot::Receiver<()>>,
 }
 
@@ -187,7 +187,8 @@ impl Client {
             respond_to: tx,
             message_id: message.id,
         };
-        self.send_internal(InternalMessage::RegisterListener(register_listener)).await?;
+        self.send_internal(InternalMessage::RegisterListener(register_listener))
+            .await?;
         self.send(message).await?;
 
         // TODO: rewrite to map
@@ -197,22 +198,12 @@ impl Client {
         }
     }
 
-    async fn send(
-        &self,
-        message: Message,
-    ) -> anyhow::Result<()> {
-        let inner = self.inner.read().await;
-
-        Ok(inner.sender.send(message)?)
+    async fn send(&self, message: Message) -> anyhow::Result<()> {
+        Ok(self.sender.send(message)?)
     }
 
-    async fn send_internal(
-        &self,
-        message: InternalMessage,
-    ) -> anyhow::Result<()> {
-        let inner = self.inner.read().await;
-
-        Ok(inner.internal_sender.send(message)?)
+    async fn send_internal(&self, message: InternalMessage) -> anyhow::Result<()> {
+        Ok(self.internal_sender.send(message)?)
     }
 
     pub fn new<T, DummyType>(
@@ -229,11 +220,9 @@ impl Client {
     {
         let (internal_sender, mut internal_receiver) = unbounded_channel();
         let client = T::Client::new(Self {
-            inner: Arc::new(RwLock::new(ClientInner {
-                sender: sender.clone(),
-                internal_sender,
-                close_receiver,
-            })),
+            inner: Arc::new(RwLock::new(ClientInner { close_receiver })),
+            sender: sender.clone(),
+            internal_sender,
         });
 
         let client_clone = client.clone();