return channels when call start() on RepProtocol

src/service/gateway.rs

@@ -26,26 +26,23 @@ impl GatewayService {
     }
 
     pub async fn start(self: Arc<Self>, executor: Arc<Executor<'_>>) -> Result<()> {
-        let (send_queue_s, send_queue_r) = async_channel::unbounded::<Reply>();
-        let (recv_queue_s, recv_queue_r) = async_channel::unbounded::<Request>();
 
-        let mut reqrep = RepProtocol::new(
+        let mut socket = RepProtocol::new(
             self.addr.clone(),
-            send_queue_r.clone(),
-            recv_queue_s.clone(),
         );
 
-        reqrep.start().await?;
+        let (send, recv) = socket.start().await?;
         println!("server started");
 
         self.publisher.lock().await.start().await?;
 
         println!("publisher started");
 
+
         let handle_request_task =
-            executor.spawn(self.handle_request(send_queue_s.clone(), recv_queue_r.clone()));
+            executor.spawn(self.handle_request(send.clone(), recv.clone()));
 
-        reqrep.run().await?;
+        socket.run().await?;
 
         handle_request_task.cancel().await;
         Ok(())

src/service/reqrep.rs

@@ -18,25 +18,39 @@ pub struct RepProtocol {
     socket: zeromq::RepSocket,
     recv_queue: async_channel::Receiver<Reply>,
     send_queue: async_channel::Sender<Request>,
+    channels:
+        (async_channel::Sender<Reply>,
+         async_channel::Receiver<Request>)
+
 }
 
 impl RepProtocol {
     pub fn new(
         addr: String,
-        recv_queue: async_channel::Receiver<Reply>,
-        send_queue: async_channel::Sender<Request>,
     ) -> RepProtocol {
         let socket = zeromq::RepSocket::new();
+        let (send_queue, recv_channel) = async_channel::unbounded::<Request>();
+        let (send_channel, recv_queue) = async_channel::unbounded::<Reply>();
+
+        let channels = (send_channel.clone(), recv_channel.clone());
+
         RepProtocol {
             addr,
             socket,
             recv_queue,
             send_queue,
+            channels
         }
     }
-    pub async fn start(&mut self) -> Result<()> {
-        self.socket.bind(self.addr.as_str()).await?;
-        Ok(())
+
+
+    pub async fn start(&mut self) ->
+        Result<
+        (async_channel::Sender<Reply>,
+         async_channel::Receiver<Request>)
+        > {
+            self.socket.bind(self.addr.as_str()).await?;
+            Ok(self.channels.clone())
     }
 
     pub async fn run(&mut self) -> Result<()> {