From 64905563d121333c6add3fb63e8d66f09f7841fc Mon Sep 17 00:00:00 2001
From: Henry de Valence <hdevalence@hdevalence.ca>
Date: Sat, 19 Sep 2020 10:33:02 -0700
Subject: [PATCH] network: remove glob import in message-handling

This clarifies which parts are the handler state and which parts are the
incoming message.
---
 zebra-network/src/peer/connection.rs | 39 ++++++++++++++--------------
 1 file changed, 19 insertions(+), 20 deletions(-)

diff --git a/zebra-network/src/peer/connection.rs b/zebra-network/src/peer/connection.rs
index a9ab7b8a..abe17f11 100644
--- a/zebra-network/src/peer/connection.rs
+++ b/zebra-network/src/peer/connection.rs
@@ -74,21 +74,20 @@ impl Handler {
         // into responses to messages in the internal request/response protocol.
         // This conversion is done by a sequence of (request, message) match arms,
         // each of which contains the conversion logic for that pair.
-        use Handler::*;
         let mut ignored_msg = None;
         // XXX can this be avoided?
-        let tmp_state = std::mem::replace(self, Finished(Ok(Response::Nil)));
+        let tmp_state = std::mem::replace(self, Handler::Finished(Ok(Response::Nil)));
         *self = match (tmp_state, msg) {
-            (Ping(req_nonce), Message::Pong(rsp_nonce)) => {
+            (Handler::Ping(req_nonce), Message::Pong(rsp_nonce)) => {
                 if req_nonce == rsp_nonce {
-                    Finished(Ok(Response::Nil))
+                    Handler::Finished(Ok(Response::Nil))
                 } else {
-                    Ping(req_nonce)
+                    Handler::Ping(req_nonce)
                 }
             }
-            (Peers, Message::Addr(addrs)) => Finished(Ok(Response::Peers(addrs))),
+            (Handler::Peers, Message::Addr(addrs)) => Handler::Finished(Ok(Response::Peers(addrs))),
             (
-                TransactionsByHash {
+                Handler::TransactionsByHash {
                     mut hashes,
                     mut transactions,
                 },
@@ -97,9 +96,9 @@ impl Handler {
                 if hashes.remove(&transaction.hash()) {
                     transactions.push(transaction);
                     if hashes.is_empty() {
-                        Finished(Ok(Response::Transactions(transactions)))
+                        Handler::Finished(Ok(Response::Transactions(transactions)))
                     } else {
-                        TransactionsByHash {
+                        Handler::TransactionsByHash {
                             hashes,
                             transactions,
                         }
@@ -109,14 +108,14 @@ impl Handler {
                     // but unsolicited transactions are OK, so leave
                     // for future handling.
                     ignored_msg = Some(Message::Tx(transaction));
-                    TransactionsByHash {
+                    Handler::TransactionsByHash {
                         hashes,
                         transactions,
                     }
                 }
             }
             (
-                BlocksByHash {
+                Handler::BlocksByHash {
                     mut hashes,
                     mut blocks,
                 },
@@ -125,36 +124,36 @@ impl Handler {
                 if hashes.remove(&block.hash()) {
                     blocks.push(block);
                     if hashes.is_empty() {
-                        Finished(Ok(Response::Blocks(blocks)))
+                        Handler::Finished(Ok(Response::Blocks(blocks)))
                     } else {
-                        BlocksByHash { hashes, blocks }
+                        Handler::BlocksByHash { hashes, blocks }
                     }
                 } else {
                     // Blocks shouldn't be sent unsolicited,
                     // so fail the request if we got the wrong one.
-                    Finished(Err(PeerError::WrongBlock.into()))
+                    Handler::Finished(Err(PeerError::WrongBlock.into()))
                 }
             }
-            (FindBlocks, Message::Inv(items))
+            (Handler::FindBlocks, Message::Inv(items))
                 if items
                     .iter()
                     .all(|item| matches!(item, InventoryHash::Block(_))) =>
             {
-                Finished(Ok(Response::BlockHashes(
+                Handler::Finished(Ok(Response::BlockHashes(
                     block_hashes(&items[..]).collect(),
                 )))
             }
-            (MempoolTransactions, Message::Inv(items))
+            (Handler::MempoolTransactions, Message::Inv(items))
                 if items
                     .iter()
                     .all(|item| matches!(item, InventoryHash::Tx(_))) =>
             {
-                Finished(Ok(Response::TransactionHashes(
+                Handler::Finished(Ok(Response::TransactionHashes(
                     transaction_hashes(&items[..]).collect(),
                 )))
             }
-            (FindHeaders, Message::Headers(headers)) => {
-                Finished(Ok(Response::BlockHeaders(headers)))
+            (Handler::FindHeaders, Message::Headers(headers)) => {
+                Handler::Finished(Ok(Response::BlockHeaders(headers)))
             }
             // By default, messages are not responses.
             (state, msg) => {