remove old send code and message type

src/net/channel.rs

@@ -12,7 +12,7 @@ use std::sync::Arc;
 use crate::error;
 use crate::net::error::{NetError, NetResult};
 use crate::net::message_subscriber::{
-    MessageSubsystem, MessageSubscription, Message2
+    MessageSubsystem, MessageSubscription, Message
 };
 use crate::net::messages;
 use crate::net::settings::SettingsPtr;
@@ -90,11 +90,10 @@ impl Channel {
         sub
     }
 
-    pub async fn send(self: Arc<Self>, message: messages::Message) -> NetResult<()> {
-        let packet_type = message.packet_type();
+    pub async fn send<M: Message>(&self, message: M) -> NetResult<()> {
         debug!(target: "net",
-            "Channel::send() [START, pkt_type={:?}, address={}]",
-            packet_type,
+            "Channel::send() [START, command={:?}, address={}]",
+            M::name(),
             self.address()
         );
         if self.stopped.load(Ordering::Relaxed) {
@@ -102,7 +101,7 @@ impl Channel {
         }
 
         // Catch failure and stop channel, return a net error
-        let result = match messages::send_message(&mut *self.writer.lock().await, message).await {
+        let result = match self.send_message(message).await {
             Ok(()) => Ok(()),
             Err(err) => {
                 error!("Channel send error for [{}]: {}", self.address(), err);
@@ -111,15 +110,27 @@ impl Channel {
             }
         };
         debug!(target: "net",
-            "Channel::send() [END, pkt_type={:?}, address={}]",
-            packet_type,
+            "Channel::send() [END, command={:?}, address={}]",
+            M::name(),
             self.address()
         );
         result
     }
 
-    pub async fn subscribe_msg<M: Message2>(
-        self: Arc<Self>
+    async fn send_message<M: Message>(&self, message: M) -> error::Result<()> {
+        let mut payload = Vec::new();
+        message.encode(&mut payload)?;
+        let packet = messages::Packet {
+            command: String::from(M::name()),
+            payload,
+        };
+        
+        let stream = &mut *self.writer.lock().await;
+        messages::send_packet(stream, packet).await
+    }
+
+    pub async fn subscribe_msg<M: Message>(
+        &self
     ) -> NetResult<MessageSubscription<M>> {
         debug!(target: "net",
             "Channel::subscribe_msg() [START, command={:?}, address={}]",
@@ -182,7 +193,7 @@ impl Channel {
             };
 
             // Send result to our subscribers
-            self.message_subsystem.notify(&packet.command2, packet.payload).await;
+            self.message_subsystem.notify(&packet.command, packet.payload).await;
         }
     }
 

src/net/message_subscriber.rs

@@ -10,25 +10,23 @@ use std::sync::Arc;
 
 use crate::error::Result;
 use crate::net::error::{NetError, NetResult};
-use crate::net::messages::{Message, PacketType};
-use crate::serial::Decodable;
-use crate::serial::Encodable;
+use crate::serial::{Decodable, Encodable};
 
 
 pub type MessageSubscriptionID = u64;
 type MessageResult<M> = NetResult<Arc<M>>;
 
-pub trait Message2: 'static + Decodable + Send + Sync {
+pub trait Message: 'static + Encodable + Decodable + Send + Sync {
     fn name() -> &'static str;
 }
 
-pub struct MessageSubscription<M: Message2> {
+pub struct MessageSubscription<M: Message> {
     id: MessageSubscriptionID,
     recv_queue: async_channel::Receiver<MessageResult<M>>,
     parent: Arc<MessageDispatcher<M>>,
 }
 
-impl<M: Message2> MessageSubscription<M> {
+impl<M: Message> MessageSubscription<M> {
     pub async fn receive(&self) -> MessageResult<M> {
         match self.recv_queue.recv().await {
             Ok(message) => message,
@@ -53,11 +51,11 @@ trait MessageDispatcherInterface: Send + Sync {
     fn as_any(self: Arc<Self>) -> Arc<dyn Any + Send + Sync>;
 }
 
-struct MessageDispatcher<M: Message2> {
+struct MessageDispatcher<M: Message> {
     subs: Mutex<HashMap<MessageSubscriptionID, async_channel::Sender<MessageResult<M>>>>,
 }
 
-impl<M: Message2> MessageDispatcher<M> {
+impl<M: Message> MessageDispatcher<M> {
     fn new() -> Self {
         MessageDispatcher {
             subs: Mutex::new(HashMap::new()),
@@ -124,7 +122,7 @@ impl<M: Message2> MessageDispatcher<M> {
 }
 
 #[async_trait]
-impl<M: Message2> MessageDispatcherInterface for MessageDispatcher<M> {
+impl<M: Message> MessageDispatcherInterface for MessageDispatcher<M> {
     async fn trigger(&self, payload: Vec<u8>) {
         // deserialize data into type
         // send down the pipes
@@ -151,37 +149,37 @@ impl<M: Message2> MessageDispatcherInterface for MessageDispatcher<M> {
 
 use crate::net::messages::{PingMessage, PongMessage, GetAddrsMessage, AddrsMessage, VersionMessage, VerackMessage};
 
-impl Message2 for PingMessage {
+impl Message for PingMessage {
     fn name() -> &'static str {
         "ping"
     }
 }
 
-impl Message2 for PongMessage {
+impl Message for PongMessage {
     fn name() -> &'static str {
         "pong"
     }
 }
 
-impl Message2 for GetAddrsMessage {
+impl Message for GetAddrsMessage {
     fn name() -> &'static str {
         "getaddr"
     }
 }
 
-impl Message2 for AddrsMessage {
+impl Message for AddrsMessage {
     fn name() -> &'static str {
         "addr"
     }
 }
 
-impl Message2 for VersionMessage {
+impl Message for VersionMessage {
     fn name() -> &'static str {
         "version"
     }
 }
 
-impl Message2 for VerackMessage {
+impl Message for VerackMessage {
     fn name() -> &'static str {
         "verack"
     }
@@ -191,7 +189,7 @@ struct MyVersionMessage {
     x: u32,
 }
 
-impl Message2 for MyVersionMessage {
+impl Message for MyVersionMessage {
     fn name() -> &'static str {
         "verver"
     }
@@ -224,14 +222,14 @@ impl MessageSubsystem {
         }
     }
 
-    pub async fn add_dispatch<M: Message2>(&self) {
+    pub async fn add_dispatch<M: Message>(&self) {
         self.dispatchers
             .lock()
             .await
             .insert(M::name(), Arc::new(MessageDispatcher::<M>::new()));
     }
 
-    pub async fn subscribe<M: Message2>(&self) -> NetResult<MessageSubscription<M>> {
+    pub async fn subscribe<M: Message>(&self) -> NetResult<MessageSubscription<M>> {
         let dispatcher = self
             .dispatchers
             .lock()

src/net/messages.rs

@@ -17,37 +17,6 @@ use crate::serial::{serialize, Decodable, Encodable, VarInt};
 
 const MAGIC_BYTES: [u8; 4] = [0xd9, 0xef, 0xb6, 0x7d];
 
-pub type Ciphertext = Vec<u8>;
-pub type CiphertextHash = [u8; 32];
-
-// Packets and Message because Rust doesn't allow value
-// aliasing from ADL type enums (which Message uses).
-#[derive(IntoPrimitive, TryFromPrimitive, Copy, Clone, PartialEq, Eq, Hash, Debug)]
-#[repr(u8)]
-pub enum PacketType {
-    Ping = 1,
-    Pong = 2,
-    GetAddrs = 3,
-    Addrs = 4,
-    Inv = 5,
-    GetSlabs = 6,
-    Slab = 7,
-    Version = 8,
-    Verack = 9,
-}
-
-pub enum Message {
-    Ping(PingMessage),
-    Pong(PongMessage),
-    GetAddrs(GetAddrsMessage),
-    Addrs(AddrsMessage),
-    Inv(InvMessage),
-    GetSlabs(GetSlabsMessage),
-    Slab(SlabMessage),
-    Version(VersionMessage),
-    Verack(VerackMessage),
-}
-
 pub struct PingMessage {
     pub nonce: u32,
 }
@@ -58,20 +27,6 @@ pub struct PongMessage {
 
 pub struct GetAddrsMessage {}
 
-pub struct GetSlabsMessage {
-    pub slabs_hash: Vec<[u8; 32]>,
-}
-
-#[derive(Clone)]
-pub struct SlabMessage {
-    pub nonce: [u8; 12],
-    pub ciphertext: Ciphertext,
-}
-
-pub struct InvMessage {
-    pub slabs_hash: Vec<[u8; 32]>,
-}
-
 pub struct AddrsMessage {
     pub addrs: Vec<SocketAddr>,
 }
@@ -112,56 +67,6 @@ impl Decodable for PongMessage {
     }
 }
 
-impl Encodable for GetSlabsMessage {
-    fn encode<S: io::Write>(&self, mut s: S) -> Result<usize> {
-        let mut len = 0;
-        len += self.slabs_hash.encode(&mut s)?;
-        Ok(len)
-    }
-}
-
-impl Decodable for GetSlabsMessage {
-    fn decode<D: io::Read>(mut d: D) -> Result<Self> {
-        Ok(Self {
-            slabs_hash: Decodable::decode(&mut d)?,
-        })
-    }
-}
-
-impl Encodable for SlabMessage {
-    fn encode<S: io::Write>(&self, mut s: S) -> Result<usize> {
-        let mut len = 0;
-        len += self.nonce.encode(&mut s)?;
-        len += self.ciphertext.encode(&mut s)?;
-        Ok(len)
-    }
-}
-
-impl Decodable for SlabMessage {
-    fn decode<D: io::Read>(mut d: D) -> Result<Self> {
-        Ok(Self {
-            nonce: Decodable::decode(&mut d)?,
-            ciphertext: Decodable::decode(&mut d)?,
-        })
-    }
-}
-
-impl Encodable for InvMessage {
-    fn encode<S: io::Write>(&self, mut s: S) -> Result<usize> {
-        let mut len = 0;
-        len += self.slabs_hash.encode(&mut s)?;
-        Ok(len)
-    }
-}
-
-impl Decodable for InvMessage {
-    fn decode<D: io::Read>(mut d: D) -> Result<Self> {
-        Ok(Self {
-            slabs_hash: Decodable::decode(&mut d)?,
-        })
-    }
-}
-
 impl Encodable for GetAddrsMessage {
     fn encode<S: io::Write>(&self, mut _s: S) -> Result<usize> {
         let len = 0;
@@ -215,137 +120,10 @@ impl Decodable for VerackMessage {
     }
 }
 
-impl Message {
-    pub fn packet_type(&self) -> PacketType {
-        match self {
-            Message::Ping(_message) => PacketType::Ping,
-            Message::Pong(_message) => PacketType::Pong,
-            Message::GetAddrs(_message) => PacketType::GetAddrs,
-            Message::Addrs(_message) => PacketType::Addrs,
-            Message::Inv(_message) => PacketType::Inv,
-            Message::GetSlabs(_message) => PacketType::GetSlabs,
-            Message::Slab(_message) => PacketType::Slab,
-            Message::Version(_message) => PacketType::Version,
-            Message::Verack(_message) => PacketType::Verack,
-        }
-    }
-
-    pub fn pack(&self) -> Result<Packet> {
-        match self {
-            Message::Ping(message) => {
-                let mut payload = Vec::new();
-                message.encode(&mut payload)?;
-                Ok(Packet {
-                    command: PacketType::Ping,
-                    command2: String::from(self.name()),
-                    payload,
-                })
-            }
-            Message::Pong(message) => {
-                let mut payload = Vec::new();
-                message.encode(&mut payload)?;
-                Ok(Packet {
-                    command: PacketType::Pong,
-                    command2: String::from(self.name()),
-                    payload,
-                })
-            }
-            Message::GetAddrs(message) => {
-                let mut payload = Vec::new();
-                message.encode(&mut payload)?;
-                Ok(Packet {
-                    command: PacketType::GetAddrs,
-                    command2: String::from(self.name()),
-                    payload,
-                })
-            }
-            Message::Addrs(message) => {
-                let mut payload = Vec::new();
-                message.encode(Cursor::new(&mut payload))?;
-                Ok(Packet {
-                    command: PacketType::Addrs,
-                    command2: String::from(self.name()),
-                    payload,
-                })
-            }
-            Message::Inv(message) => {
-                let payload = serialize(message);
-                Ok(Packet {
-                    command: PacketType::Inv,
-                    command2: String::from(self.name()),
-                    payload,
-                })
-            }
-            Message::GetSlabs(message) => {
-                let payload = serialize(message);
-                Ok(Packet {
-                    command: PacketType::GetSlabs,
-                    command2: String::from(self.name()),
-                    payload,
-                })
-            }
-            Message::Slab(message) => {
-                let payload = serialize(message);
-                Ok(Packet {
-                    command: PacketType::Slab,
-                    command2: String::from(self.name()),
-                    payload,
-                })
-            }
-            Message::Version(message) => {
-                let payload = serialize(message);
-                Ok(Packet {
-                    command: PacketType::Version,
-                    command2: String::from(self.name()),
-                    payload,
-                })
-            }
-            Message::Verack(message) => {
-                let payload = serialize(message);
-                Ok(Packet {
-                    command: PacketType::Verack,
-                    command2: String::from(self.name()),
-                    payload,
-                })
-            }
-        }
-    }
-
-    pub fn unpack(packet: Packet) -> Result<Self> {
-        let cursor = Cursor::new(packet.payload.clone());
-        match packet.command {
-            PacketType::Ping => Ok(Self::Ping(PingMessage::decode(cursor)?)),
-            PacketType::Pong => Ok(Self::Pong(PongMessage::decode(cursor)?)),
-            PacketType::GetAddrs => Ok(Self::GetAddrs(GetAddrsMessage::decode(cursor)?)),
-            PacketType::Addrs => Ok(Self::Addrs(AddrsMessage::decode(cursor)?)),
-            PacketType::Inv => Ok(Self::Inv(InvMessage::decode(cursor)?)),
-            PacketType::GetSlabs => Ok(Self::GetSlabs(GetSlabsMessage::decode(cursor)?)),
-            PacketType::Slab => Ok(Self::Slab(SlabMessage::decode(cursor)?)),
-            PacketType::Version => Ok(Self::Version(VersionMessage::decode(cursor)?)),
-            PacketType::Verack => Ok(Self::Verack(VerackMessage::decode(cursor)?)),
-        }
-    }
-
-    pub fn name(&self) -> &'static str {
-        match self {
-            Message::Ping(_) => "ping",
-            Message::Pong(_) => "pong",
-            Message::GetAddrs(_) => "getaddr",
-            Message::Addrs(_) => "addr",
-            Message::Inv(_) => "inv",
-            Message::GetSlabs(_) => "GetSlabs",
-            Message::Slab(_) => "Slab",
-            Message::Version(_) => "version",
-            Message::Verack(_) => "verack",
-        }
-    }
-}
-
 // Packets are the base type read from the network
 // These are converted to messages and passed to event loop
 pub struct Packet {
-    pub command: PacketType,
-    pub command2: String,
+    pub command: String,
     pub payload: Vec<u8>,
 }
 
@@ -361,9 +139,6 @@ pub async fn read_packet<R: AsyncRead + Unpin>(stream: &mut R) -> Result<Packet>
     }
 
     // The type of the message
-    //let command = AsyncReadExt::read_u8(stream).await?;
-    //debug!(target: "net", "read command: {}", command);
-    //let command = PacketType::try_from(command).map_err(|_| Error::MalformedPacket)?;
     let command_len = VarInt::decode_async(stream).await?.0 as usize;
     let mut command = vec![0u8; command_len];
     if command_len > 0 {
@@ -381,7 +156,7 @@ pub async fn read_packet<R: AsyncRead + Unpin>(stream: &mut R) -> Result<Packet>
     }
     debug!(target: "net", "read payload {} bytes", payload_len);
 
-    Ok(Packet { command: PacketType::Verack, command2: command, payload })
+    Ok(Packet { command: command, payload })
 }
 
 pub async fn send_packet<W: AsyncWrite + Unpin>(stream: &mut W, packet: Packet) -> Result<()> {
@@ -389,15 +164,12 @@ pub async fn send_packet<W: AsyncWrite + Unpin>(stream: &mut W, packet: Packet)
     stream.write_all(&MAGIC_BYTES).await?;
     debug!(target: "net", "sent magic...");
 
-    //AsyncWriteExt::write_u8(stream, packet.command as u8).await?;
-    //debug!(target: "net", "sent command: {}", packet.command as u8);
-
-    VarInt(packet.command2.len() as u64)
+    VarInt(packet.command.len() as u64)
         .encode_async(stream)
         .await?;
-    assert!(!packet.command2.is_empty());
-    stream.write_all(&packet.command2.as_bytes()).await?;
-    debug!(target: "net", "sent command: {}", packet.command2);
+    assert!(!packet.command.is_empty());
+    stream.write_all(&packet.command.as_bytes()).await?;
+    debug!(target: "net", "sent command: {}", packet.command);
 
     assert_eq!(std::mem::size_of::<usize>(), std::mem::size_of::<u64>());
     VarInt(packet.payload.len() as u64)
@@ -412,81 +184,3 @@ pub async fn send_packet<W: AsyncWrite + Unpin>(stream: &mut W, packet: Packet)
     Ok(())
 }
 
-pub async fn receive_message<R: AsyncRead + Unpin>(stream: &mut R) -> Result<Message> {
-    let packet = read_packet(stream).await?;
-    debug!(target: "net", "unpacking packet: {:?}", packet.command);
-    let message = Message::unpack(packet)?;
-    debug!(target: "net", "received Message::{}", message.name());
-    Ok(message)
-}
-
-pub async fn send_message<W: AsyncWrite + Unpin>(stream: &mut W, message: Message) -> Result<()> {
-    debug!(target: "net", "sending Message::{}", message.name());
-    let packet = message.pack()?;
-    send_packet(stream, packet).await
-}
-
-pub async fn sleep(seconds: u64) {
-    Timer::after(Duration::from_secs(seconds)).await;
-}
-
-// Used for ping pong loop timer
-pub struct InactivityTimer {
-    reset_sender: async_channel::Sender<()>,
-    timeout_receiver: async_channel::Receiver<()>,
-    task: smol::Task<()>,
-}
-
-impl InactivityTimer {
-    pub fn new(executor: Arc<Executor<'_>>) -> Self {
-        let (reset_sender, reset_receiver) = async_channel::bounded::<()>(1);
-        let (timeout_sender, timeout_receiver) = async_channel::bounded::<()>(1);
-
-        let task = executor.spawn(async {
-            match Self::_start(reset_receiver, timeout_sender).await {
-                Ok(()) => {}
-                Err(err) => error!("InactivityTimer fatal error {}", err),
-            }
-        });
-
-        Self {
-            reset_sender,
-            timeout_receiver,
-            task,
-        }
-    }
-
-    pub async fn stop(self) {
-        self.task.cancel().await;
-    }
-
-    // This loop basically waits for 10 secs. If it doesn't
-    // receive a signal that something happened then it will
-    // send a timeout signal. This will wakeup the main event loop
-    // and the connection will be dropped.
-    async fn _start(
-        reset_rx: async_channel::Receiver<()>,
-        timeout_sx: async_channel::Sender<()>,
-    ) -> Result<()> {
-        loop {
-            let is_awake = futures::select! {
-                _ = reset_rx.recv().fuse() => true,
-                _ = sleep(10).fuse() => false
-            };
-
-            if !is_awake {
-                warn!("InactivityTimer timeout");
-                timeout_sx.send(()).await?;
-            }
-        }
-    }
-
-    pub async fn reset(&self) -> Result<()> {
-        self.reset_sender.send(()).await?;
-        Ok(())
-    }
-
-    pub async fn wait_for_wakeup(&self) -> Result<()> {
-        Ok(self.timeout_receiver.recv().await?)
-    }
-}

src/net/protocols/protocol_address.rs

@@ -57,7 +57,7 @@ impl ProtocolAddress {
             .await;
 
         // Send get_address message
-        let get_addrs = messages::Message::GetAddrs(messages::GetAddrsMessage {});
+        let get_addrs = messages::GetAddrsMessage {};
         let _ = self.channel.clone().send(get_addrs).await;
         debug!(target: "net", "ProtocolAddress::start() [END]");
     }
@@ -92,7 +92,7 @@ impl ProtocolAddress {
                 "ProtocolAddress::handle_receive_get_addrs() sending {} addrs",
                 addrs.len()
             );
-            let addrs_msg = messages::Message::Addrs(messages::AddrsMessage { addrs });
+            let addrs_msg = messages::AddrsMessage { addrs };
             self.channel.clone().send(addrs_msg).await?;
         }
     }

src/net/protocols/protocol_ping.rs

@@ -57,7 +57,7 @@ impl ProtocolPing {
             let nonce = Self::random_nonce();
 
             // Send ping message
-            let ping = messages::Message::Ping(messages::PingMessage { nonce });
+            let ping = messages::PingMessage { nonce };
             self.channel.clone().send(ping).await?;
             debug!(target: "net", "ProtocolPing::run_ping_pong() send Ping message");
             // Start the timer for ping timer
@@ -90,7 +90,7 @@ impl ProtocolPing {
             debug!(target: "net", "ProtocolPing::reply_to_ping() received Ping message");
 
             // Send ping message
-            let pong = messages::Message::Pong(messages::PongMessage { nonce: ping.nonce });
+            let pong = messages::PongMessage { nonce: ping.nonce };
             self.channel.clone().send(pong).await?;
             debug!(target: "net", "ProtocolPing::reply_to_ping() sent Pong reply");
         }

src/net/protocols/protocol_seed.rs

@@ -34,7 +34,7 @@ impl ProtocolSeed {
         self.send_self_address().await?;
 
         // Send get address message
-        let get_addr = messages::Message::GetAddrs(messages::GetAddrsMessage {});
+        let get_addr = messages::GetAddrsMessage {};
         self.channel.clone().send(get_addr).await?;
 
         // Receive addresses
@@ -50,7 +50,7 @@ impl ProtocolSeed {
         match self.settings.external_addr {
             Some(addr) => {
                 debug!(target: "net", "ProtocolSeed::send_own_address() addr={}", addr);
-                let addr = messages::Message::Addrs(messages::AddrsMessage { addrs: vec![addr] });
+                let addr = messages::AddrsMessage { addrs: vec![addr] };
                 self.channel.clone().send(addr).await?;
             }
             None => {

src/net/protocols/protocol_version.rs

@@ -65,7 +65,7 @@ impl ProtocolVersion {
 
     async fn send_version(self: Arc<Self>) -> NetResult<()> {
         debug!(target: "net", "ProtocolVersion::send_version() [START]");
-        let version = messages::Message::Version(messages::VersionMessage {});
+        let version = messages::VersionMessage {};
         self.channel.clone().send(version).await?;
 
         // Wait for version acknowledgement
@@ -82,7 +82,7 @@ impl ProtocolVersion {
         // Check the message is OK
 
         // Send version acknowledgement
-        let verack = messages::Message::Verack(messages::VerackMessage {});
+        let verack = messages::VerackMessage {};
         self.channel.clone().send(verack).await?;
 
         debug!(target: "net", "ProtocolVersion::recv_version() [END]");

src/utility.rs

@@ -12,10 +12,6 @@ use smol::{Executor, Task};
 //use crate::{net, serial, Channel, ClientProtocol, Result, SlabsManagerSafe};
 use crate::{net::messages as net, serial, Result};
 
-pub type ConnectionsMap = std::sync::Arc<
-    async_std::sync::Mutex<HashMap<SocketAddr, async_channel::Sender<net::Message>>>,
->;
-
 pub type AddrsStorage = std::sync::Arc<async_std::sync::Mutex<Vec<SocketAddr>>>;
 
 pub type Clock = std::sync::Arc<AtomicU64>;
@@ -56,34 +52,3 @@ pub fn load_stored_addrs() -> Result<Vec<SocketAddr>> {
     }
 }
 
-pub async fn start_connections_process(
-    //slabman: SlabsManagerSafe,
-    stored_addrs: Vec<SocketAddr>,
-    connections: ConnectionsMap,
-    _accept_addr: SocketAddr,
-    _channel_secret: [u8; 32],
-    executor: Arc<Executor<'_>>,
-) -> Vec<Task<()>> {
-    let mut tasks: Vec<Task<()>> = vec![];
-    for _ in 0..10 {
-        let connections_cloned = connections.clone();
-        let stored_addrs_cloned = stored_addrs.clone();
-        //let slabman_cloned = slabman.clone();
-        //let channel_secret = channel_secret.clone();
-        let task = executor.spawn(async move {
-            loop {
-                let addr = stored_addrs_cloned.choose(&mut rand::thread_rng()).unwrap();
-                if !connections_cloned.lock().await.contains_key(addr) {
-                    /*let mut protocol =
-                        ClientProtocol::new(connections_cloned.clone(), slabman_cloned.clone());
-                    protocol
-                        .start(addr.clone(), accept_addr.clone(), &channel_secret)
-                        .await;
-                        */
-                }
-            }
-        });
-        tasks.push(task);
-    }
-    tasks
-}