Update to tokio 1.1 (#2172)

## Issue Addressed

resolves #2129
resolves #2099 
addresses some of #1712
unblocks #2076
unblocks #2153 

## Proposed Changes

- Updates all the dependencies mentioned in #2129, except for web3. They haven't merged their tokio 1.0 update because they are waiting on some dependencies of their own. Since we only use web3 in tests, I think updating it in a separate issue is fine. If they are able to merge soon though, I can update in this PR. 

- Updates `tokio_util` to 0.6.2 and `bytes` to 1.0.1.

- We haven't made a discv5 release since merging tokio 1.0 updates so I'm using a commit rather than release atm. **Edit:** I think we should merge an update of `tokio_util` to 0.6.2 into discv5 before this release because it has panic fixes in `DelayQueue`  --> PR in discv5:  https://github.com/sigp/discv5/pull/58

## Additional Info

tokio 1.0 changes that required some changes in lighthouse:

- `interval.next().await.is_some()` -> `interval.tick().await`
- `sleep` future is now `!Unpin` -> https://github.com/tokio-rs/tokio/issues/3028
- `try_recv` has been temporarily removed from `mpsc` -> https://github.com/tokio-rs/tokio/issues/3350
- stream features have moved to `tokio-stream` and `broadcast::Receiver::into_stream()` has been temporarily removed -> `https://github.com/tokio-rs/tokio/issues/2870
- I've copied over the `BroadcastStream` wrapper from this PR, but can update to use `tokio-stream` once it's merged https://github.com/tokio-rs/tokio/pull/3384

Co-authored-by: realbigsean <seananderson33@gmail.com>

beacon_node/eth2_libp2p/src/behaviour/mod.rs

@@ -832,7 +832,7 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
         if let Some((peer_id, reason)) = self.peers_to_dc.pop_front() {
             return Poll::Ready(NBAction::NotifyHandler {
                 peer_id,
-                handler: NotifyHandler::All,
+                handler: NotifyHandler::Any,
                 event: BehaviourHandlerIn::Shutdown(
                     reason.map(|reason| (RequestId::Behaviour, RPCRequest::Goodbye(reason))),
                 ),
@@ -893,7 +893,7 @@ impl<TSpec: EthSpec> Behaviour<TSpec> {
         }
 
         // perform gossipsub score updates when necessary
-        while let Poll::Ready(Some(_)) = self.update_gossipsub_scores.poll_next_unpin(cx) {
+        while let Poll::Ready(_) = self.update_gossipsub_scores.poll_tick(cx) {
             self.peer_manager.update_gossipsub_scores(&self.gossipsub);
         }
 

beacon_node/eth2_libp2p/src/discovery/enr_ext.rs

@@ -221,8 +221,9 @@ impl CombinedKeyExt for CombinedKey {
     fn from_libp2p(key: &libp2p::core::identity::Keypair) -> Result<CombinedKey, &'static str> {
         match key {
             Keypair::Secp256k1(key) => {
-                let secret = discv5::enr::k256::ecdsa::SigningKey::new(&key.secret().to_bytes())
-                    .expect("libp2p key must be valid");
+                let secret =
+                    discv5::enr::k256::ecdsa::SigningKey::from_bytes(&key.secret().to_bytes())
+                        .expect("libp2p key must be valid");
                 Ok(CombinedKey::Secp256k1(secret))
             }
             Keypair::Ed25519(key) => {
@@ -277,7 +278,7 @@ mod tests {
     fn test_secp256k1_peer_id_conversion() {
         let sk_hex = "df94a73d528434ce2309abb19c16aedb535322797dbd59c157b1e04095900f48";
         let sk_bytes = hex::decode(sk_hex).unwrap();
-        let secret_key = discv5::enr::k256::ecdsa::SigningKey::new(&sk_bytes).unwrap();
+        let secret_key = discv5::enr::k256::ecdsa::SigningKey::from_bytes(&sk_bytes).unwrap();
 
         let libp2p_sk = libp2p::identity::secp256k1::SecretKey::from_bytes(sk_bytes).unwrap();
         let secp256k1_kp: libp2p::identity::secp256k1::Keypair = libp2p_sk.into();

beacon_node/eth2_libp2p/src/discovery/mod.rs

@@ -896,7 +896,7 @@ impl<TSpec: EthSpec> Discovery<TSpec> {
             }
             EventStream::InActive => {} // ignore checking the stream
             EventStream::Present(ref mut stream) => {
-                while let Ok(event) = stream.try_recv() {
+                while let Poll::Ready(Some(event)) = stream.poll_recv(cx) {
                     match event {
                         // We filter out unwanted discv5 events here and only propagate useful results to
                         // the peer manager.

beacon_node/eth2_libp2p/src/peer_manager/mod.rs

@@ -972,7 +972,7 @@ impl<TSpec: EthSpec> Stream for PeerManager<TSpec> {
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         // perform the heartbeat when necessary
-        while let Poll::Ready(Some(_)) = self.heartbeat.poll_next_unpin(cx) {
+        while let Poll::Ready(_) = self.heartbeat.poll_tick(cx) {
             self.heartbeat();
         }
 
@@ -1011,8 +1011,10 @@ impl<TSpec: EthSpec> Stream for PeerManager<TSpec> {
             }
         }
 
-        if !matches!(self.network_globals.sync_state(), SyncState::SyncingFinalized{..}|SyncState::SyncingHead{..})
-        {
+        if !matches!(
+            self.network_globals.sync_state(),
+            SyncState::SyncingFinalized { .. } | SyncState::SyncingHead { .. }
+        ) {
             loop {
                 match self.status_peers.poll_next_unpin(cx) {
                     Poll::Ready(Some(Ok(peer_id))) => {

beacon_node/eth2_libp2p/src/peer_manager/peer_info.rs

@@ -156,7 +156,10 @@ impl<T: EthSpec> PeerInfo<T> {
 
     /// Checks if the status is connected.
     pub fn is_connected(&self) -> bool {
-        matches!(self.connection_status, PeerConnectionStatus::Connected { .. })
+        matches!(
+            self.connection_status,
+            PeerConnectionStatus::Connected { .. }
+        )
     }
 
     /// Checks if the status is connected.

beacon_node/eth2_libp2p/src/peer_manager/peer_sync_status.rs

@@ -29,12 +29,20 @@ pub struct SyncInfo {
 
 impl std::cmp::PartialEq for PeerSyncStatus {
     fn eq(&self, other: &Self) -> bool {
-        matches!((self, other),
-            (PeerSyncStatus::Synced { .. }, PeerSyncStatus::Synced { .. }) |
-            (PeerSyncStatus::Advanced { .. }, PeerSyncStatus::Advanced { .. }) |
-            (PeerSyncStatus::Behind { .. }, PeerSyncStatus::Behind { .. }) |
-            (PeerSyncStatus::IrrelevantPeer, PeerSyncStatus::IrrelevantPeer) |
-            (PeerSyncStatus::Unknown, PeerSyncStatus::Unknown))
+        matches!(
+            (self, other),
+            (PeerSyncStatus::Synced { .. }, PeerSyncStatus::Synced { .. })
+                | (
+                    PeerSyncStatus::Advanced { .. },
+                    PeerSyncStatus::Advanced { .. }
+                )
+                | (PeerSyncStatus::Behind { .. }, PeerSyncStatus::Behind { .. })
+                | (
+                    PeerSyncStatus::IrrelevantPeer,
+                    PeerSyncStatus::IrrelevantPeer
+                )
+                | (PeerSyncStatus::Unknown, PeerSyncStatus::Unknown)
+        )
     }
 }
 

beacon_node/eth2_libp2p/src/peer_manager/peerdb.rs

@@ -137,14 +137,20 @@ impl<TSpec: EthSpec> PeerDB<TSpec> {
 
     /// If we are connected or currently dialing the peer returns true.
     pub fn is_connected_or_dialing(&self, peer_id: &PeerId) -> bool {
-        matches!(self.connection_status(peer_id), Some(PeerConnectionStatus::Connected { .. })
-             | Some(PeerConnectionStatus::Dialing { .. }))
+        matches!(
+            self.connection_status(peer_id),
+            Some(PeerConnectionStatus::Connected { .. })
+                | Some(PeerConnectionStatus::Dialing { .. })
+        )
     }
 
     /// If we are connected or in the process of disconnecting
     pub fn is_connected_or_disconnecting(&self, peer_id: &PeerId) -> bool {
-        matches!(self.connection_status(peer_id), Some(PeerConnectionStatus::Connected { .. })
-             | Some(PeerConnectionStatus::Disconnecting { .. }))
+        matches!(
+            self.connection_status(peer_id),
+            Some(PeerConnectionStatus::Connected { .. })
+                | Some(PeerConnectionStatus::Disconnecting { .. })
+        )
     }
 
     /// Returns true if the peer is synced at least to our current head.

beacon_node/eth2_libp2p/src/rpc/handler.rs

@@ -7,6 +7,7 @@ use super::{RPCReceived, RPCSend};
 use crate::rpc::protocol::{InboundFramed, OutboundFramed};
 use fnv::FnvHashMap;
 use futures::prelude::*;
+use futures::{Sink, SinkExt};
 use libp2p::core::upgrade::{
     InboundUpgrade, NegotiationError, OutboundUpgrade, ProtocolError, UpgradeError,
 };
@@ -133,7 +134,7 @@ enum HandlerState {
     ///
     /// While in this state the handler rejects new requests but tries to finish existing ones.
     /// Once the timer expires, all messages are killed.
-    ShuttingDown(Sleep),
+    ShuttingDown(Box<Sleep>),
     /// The handler is deactivated. A goodbye has been sent and no more messages are sent or
     /// received.
     Deactivated,
@@ -239,9 +240,9 @@ where
                 self.dial_queue.push((id, req));
             }
 
-            self.state = HandlerState::ShuttingDown(sleep_until(
+            self.state = HandlerState::ShuttingDown(Box::new(sleep_until(
                 TInstant::now() + Duration::from_secs(SHUTDOWN_TIMEOUT_SECS as u64),
-            ));
+            )));
         }
     }
 

beacon_node/eth2_libp2p/src/rpc/protocol.rs

@@ -9,8 +9,8 @@ use crate::rpc::{
     MaxRequestBlocks, MAX_REQUEST_BLOCKS,
 };
 use futures::future::BoxFuture;
-use futures::prelude::*;
 use futures::prelude::{AsyncRead, AsyncWrite};
+use futures::{FutureExt, SinkExt, StreamExt};
 use libp2p::core::{InboundUpgrade, OutboundUpgrade, ProtocolName, UpgradeInfo};
 use ssz::Encode;
 use ssz_types::VariableList;
@@ -278,7 +278,7 @@ impl ProtocolName for ProtocolId {
 
 pub type InboundOutput<TSocket, TSpec> = (RPCRequest<TSpec>, InboundFramed<TSocket, TSpec>);
 pub type InboundFramed<TSocket, TSpec> =
-    Framed<TimeoutStream<Compat<TSocket>>, InboundCodec<TSpec>>;
+    Framed<std::pin::Pin<Box<TimeoutStream<Compat<TSocket>>>>, InboundCodec<TSpec>>;
 
 impl<TSocket, TSpec> InboundUpgrade<TSocket> for RPCProtocol<TSpec>
 where
@@ -304,7 +304,7 @@ where
             let mut timed_socket = TimeoutStream::new(socket);
             timed_socket.set_read_timeout(Some(Duration::from_secs(TTFB_TIMEOUT)));
 
-            let socket = Framed::new(timed_socket, codec);
+            let socket = Framed::new(Box::pin(timed_socket), codec);
 
             // MetaData requests should be empty, return the stream
             match protocol_name {

beacon_node/eth2_libp2p/src/rpc/rate_limiter.rs

@@ -1,6 +1,5 @@
 use crate::rpc::{Protocol, RPCRequest};
 use fnv::FnvHashMap;
-use futures::StreamExt;
 use libp2p::PeerId;
 use std::convert::TryInto;
 use std::future::Future;
@@ -241,7 +240,7 @@ impl Future for RPCRateLimiter {
     type Output = ();
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-        while let Poll::Ready(Some(_)) = self.prune_interval.poll_next_unpin(cx) {
+        while let Poll::Ready(_) = self.prune_interval.poll_tick(cx) {
             self.prune();
         }
 

beacon_node/eth2_libp2p/src/types/sync_state.rs

@@ -23,12 +23,16 @@ pub enum SyncState {
 
 impl PartialEq for SyncState {
     fn eq(&self, other: &Self) -> bool {
-        matches!((self, other),
-            (SyncState::SyncingFinalized { .. }, SyncState::SyncingFinalized { .. }) |
-            (SyncState::SyncingHead { .. }, SyncState::SyncingHead { .. }) |
-            (SyncState::Synced, SyncState::Synced) |
-            (SyncState::Stalled, SyncState::Stalled) |
-            (SyncState::SyncTransition, SyncState::SyncTransition))
+        matches!(
+            (self, other),
+            (
+                SyncState::SyncingFinalized { .. },
+                SyncState::SyncingFinalized { .. }
+            ) | (SyncState::SyncingHead { .. }, SyncState::SyncingHead { .. })
+                | (SyncState::Synced, SyncState::Synced)
+                | (SyncState::Stalled, SyncState::Stalled)
+                | (SyncState::SyncTransition, SyncState::SyncTransition)
+        )
     }
 }