refactor: async fn

tox-rs · Sep 7, 2020 · 79cc5ff · 79cc5ff
1 parent 87c435d
commit 79cc5ff
Show file tree

Hide file tree

Showing 2 changed files with 139 additions and 158 deletions.
diff --git a/tox_core/src/dht/server/mod.rs b/tox_core/src/dht/server/mod.rs
@@ -763,50 +763,50 @@ impl Server {
     }
 
     /// Function to handle incoming packets and send responses if necessary.
-    pub fn handle_packet(&self, packet: Packet, addr: SocketAddr) -> impl Future<Output = Result<(), HandlePacketError>> + Send {
+    pub async fn handle_packet(&self, packet: Packet, addr: SocketAddr) -> Result<(), HandlePacketError> {
         match packet {
             Packet::PingRequest(packet) =>
-                self.handle_ping_req(packet, addr).boxed(),
+                self.handle_ping_req(packet, addr).await,
             Packet::PingResponse(packet) =>
-                self.handle_ping_resp(packet, addr).boxed(),
+                self.handle_ping_resp(packet, addr).await,
             Packet::NodesRequest(packet) =>
-                self.handle_nodes_req(packet, addr).boxed(),
+                self.handle_nodes_req(packet, addr).await,
             Packet::NodesResponse(packet) =>
-                self.handle_nodes_resp(packet, addr).boxed(),
+                self.handle_nodes_resp(packet, addr).await,
             Packet::CookieRequest(packet) =>
-                self.handle_cookie_request(packet, addr).boxed(),
+                self.handle_cookie_request(packet, addr).await,
             Packet::CookieResponse(packet) =>
-                self.handle_cookie_response(&packet, addr).boxed(),
+                self.handle_cookie_response(&packet, addr).await,
             Packet::CryptoHandshake(packet) =>
-                self.handle_crypto_handshake(&packet, addr).boxed(),
+                self.handle_crypto_handshake(&packet, addr).await,
             Packet::DhtRequest(packet) =>
-                self.handle_dht_req(packet, addr).boxed(),
+                self.handle_dht_req(packet, addr).await,
             Packet::LanDiscovery(packet) =>
-                self.handle_lan_discovery(&packet, addr).boxed(),
+                self.handle_lan_discovery(&packet, addr).await,
             Packet::OnionRequest0(packet) =>
-                self.handle_onion_request_0(packet, addr).boxed(),
+                self.handle_onion_request_0(packet, addr).await,
             Packet::OnionRequest1(packet) =>
-                self.handle_onion_request_1(packet, addr).boxed(),
+                self.handle_onion_request_1(packet, addr).await,
             Packet::OnionRequest2(packet) =>
-                self.handle_onion_request_2(packet, addr).boxed(),
+                self.handle_onion_request_2(packet, addr).await,
             Packet::OnionAnnounceRequest(packet) =>
-                self.handle_onion_announce_request(packet, addr).boxed(),
+                self.handle_onion_announce_request(packet, addr).await,
             Packet::OnionDataRequest(packet) =>
-                self.handle_onion_data_request(packet).boxed(),
+                self.handle_onion_data_request(packet).await,
             Packet::OnionResponse3(packet) =>
-                self.handle_onion_response_3(packet).boxed(),
+                self.handle_onion_response_3(packet).await,
             Packet::OnionResponse2(packet) =>
-                self.handle_onion_response_2(packet).boxed(),
+                self.handle_onion_response_2(packet).await,
             Packet::OnionResponse1(packet) =>
-                self.handle_onion_response_1(packet).boxed(),
+                self.handle_onion_response_1(packet).await,
             Packet::BootstrapInfo(packet) =>
-                self.handle_bootstrap_info(&packet, addr).boxed(),
+                self.handle_bootstrap_info(&packet, addr).await,
             Packet::CryptoData(packet) =>
-                self.handle_crypto_data(&packet, addr).boxed(),
+                self.handle_crypto_data(&packet, addr).await,
             Packet::OnionDataResponse(packet) =>
-                self.handle_onion_data_response(&packet).boxed(),
+                self.handle_onion_data_response(&packet).await,
             Packet::OnionAnnounceResponse(packet) =>
-                self.handle_onion_announce_response(&packet, addr).boxed(),
+                self.handle_onion_announce_response(&packet, addr).await,
         }
     }
 
@@ -1020,43 +1020,40 @@ impl Server {
 
     /// Handle received `CookieRequest` packet and pass it to `net_crypto`
     /// module.
-    fn handle_cookie_request(&self, packet: CookieRequest, addr: SocketAddr)
-        -> impl Future<Output = Result<(), HandlePacketError>> + Send {
+    async fn handle_cookie_request(&self, packet: CookieRequest, addr: SocketAddr)
+        -> Result<(), HandlePacketError> {
         if let Some(ref net_crypto) = self.net_crypto {
-            Either::Left(net_crypto.handle_udp_cookie_request(packet, addr)
-                .map_err(|e| e.context(HandlePacketErrorKind::HandleNetCrypto).into()))
+            net_crypto.handle_udp_cookie_request(packet, addr)
+                .map_err(|e| e.context(HandlePacketErrorKind::HandleNetCrypto).into())
+                .await
         } else {
-            Either::Right(future::err(
-                HandlePacketError::from(HandlePacketErrorKind::NetCrypto)
-            ))
+            Err(HandlePacketError::from(HandlePacketErrorKind::NetCrypto))
         }
     }
 
     /// Handle received `CookieResponse` packet and pass it to `net_crypto`
     /// module.
-    fn handle_cookie_response(&self, packet: &CookieResponse, addr: SocketAddr)
-        -> impl Future<Output = Result<(), HandlePacketError>> + Send {
+    async fn handle_cookie_response(&self, packet: &CookieResponse, addr: SocketAddr)
+        -> Result<(), HandlePacketError> {
         if let Some(ref net_crypto) = self.net_crypto {
-            Either::Left(net_crypto.handle_udp_cookie_response(packet, addr)
-                .map_err(|e| e.context(HandlePacketErrorKind::HandleNetCrypto).into()))
+            net_crypto.handle_udp_cookie_response(packet, addr)
+                .map_err(|e| e.context(HandlePacketErrorKind::HandleNetCrypto).into())
+                .await
         } else {
-            Either::Right( future::err(
-                HandlePacketError::from(HandlePacketErrorKind::NetCrypto)
-            ))
+            Err(HandlePacketError::from(HandlePacketErrorKind::NetCrypto))
         }
     }
 
     /// Handle received `CryptoHandshake` packet and pass it to `net_crypto`
     /// module.
-    fn handle_crypto_handshake(&self, packet: &CryptoHandshake, addr: SocketAddr)
-        -> impl Future<Output = Result<(), HandlePacketError>> + Send {
+    async fn handle_crypto_handshake(&self, packet: &CryptoHandshake, addr: SocketAddr)
+        -> Result<(), HandlePacketError> {
         if let Some(ref net_crypto) = self.net_crypto {
-            Either::Left(net_crypto.handle_udp_crypto_handshake(packet, addr)
-                .map_err(|e| e.context(HandlePacketErrorKind::HandleNetCrypto).into()))
+            net_crypto.handle_udp_crypto_handshake(packet, addr)
+                .map_err(|e| e.context(HandlePacketErrorKind::HandleNetCrypto).into())
+                .await
         } else {
-            Either::Right( future::err(
-                HandlePacketError::from(HandlePacketErrorKind::NetCrypto)
-            ))
+            Err(HandlePacketError::from(HandlePacketErrorKind::NetCrypto))
         }
     }