Merge pull request #6 from libp2p/master

update

Author: jkcomment

CHANGELOG.md

@@ -1,5 +1,6 @@
 - [`libp2p-core` CHANGELOG](core/CHANGELOG.md)
 - [`libp2p-deflate` CHANGELOG](protocols/deflate/CHANGELOG.md)
+- [`libp2p-dns` CHANGELOG](transports/dns/CHANGELOG.md)
 - [`libp2p-floodsub` CHANGELOG](protocols/floodsub/CHANGELOG.md)
 - [`libp2p-gossipsub` CHANGELOG](protocols/gossipsub/CHANGELOG.md)
 - [`libp2p-identify` CHANGELOG](protocols/identify/CHANGELOG.md)
@@ -10,14 +11,43 @@
 - [`libp2p-ping` CHANGELOG](protocols/ping/CHANGELOG.md)
 - [`libp2p-plaintext` CHANGELOG](protocols/plaintext/CHANGELOG.md)
 - [`libp2p-pnet` CHANGELOG](protocols/pnet/CHANGELOG.md)
+- [`libp2p-request-response` CHANGELOG](protocols/request-response/CHANGELOG.md)
 - [`libp2p-secio` CHANGELOG](protocols/secio/CHANGELOG.md)
 - [`libp2p-swarm` CHANGELOG](swarm/CHANGELOG.md)
 - [`libp2p-tcp` CHANGELOG](transports/tcp/CHANGELOG.md)
 - [`libp2p-uds` CHANGELOG](transports/uds/CHANGELOG.md)
+- [`libp2p-wasm-ext` CHANGELOG](transports/wasm-ext/CHANGELOG.md)
 - [`libp2p-websocket` CHANGELOG](transports/websocket/CHANGELOG.md)
 - [`libp2p-yamux` CHANGELOG](muxers/yamux/CHANGELOG.md)
 - [`multistream-select` CHANGELOG](misc/multistream-select/CHANGELOG.md)
 - [`parity-multiaddr` CHANGELOG](misc/multiaddr/CHANGELOG.md)
+- [`libp2p-core-derive` CHANGELOG](misc/core-derive/CHANGELOG.md)
+
+# Version 0.23.0 (2020-??-??)
+
+- Refactored bandwidth logging ([PR 1670](https://github.com/libp2p/rust-libp2p/pull/1670)).
+
+# Version 0.22.0 (2020-07-17)
+
+**NOTE**: For a smooth upgrade path from `0.21` to `> 0.22`
+on an existing deployment using `libp2p-noise`, this version
+must not be skipped!
+
+- Bump `libp2p-noise` dependency to `0.21`.
+
+# Version 0.21.1 (2020-07-02)
+
+- Bump `libp2p-websockets` lower bound.
+
+# Version 0.21.0 (2020-07-01)
+
+- Conditional compilation fixes for the `wasm32-wasi` target
+  ([PR 1633](https://github.com/libp2p/rust-libp2p/pull/1633)).
+
+- New `libp2p-request-response` crate
+  ([PR 1596](https://github.com/libp2p/rust-libp2p/pull/1596)).
+
+- Updated libp2p dependencies.
 
 # Version 0.19.1 (2020-05-25)
 

Cargo.toml

@@ -2,7 +2,7 @@
 name = "libp2p"
 edition = "2018"
 description = "Peer-to-peer networking library"
-version = "0.20.1"
+version = "0.22.0"
 authors = ["Parity Technologies <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"
@@ -23,6 +23,7 @@ default = [
     "ping",
     "plaintext",
     "pnet",
+    "request-response",
     "secio",
     "secp256k1",
     "tcp-async-std",
@@ -43,6 +44,7 @@ noise = ["libp2p-noise"]
 ping = ["libp2p-ping"]
 plaintext = ["libp2p-plaintext"]
 pnet = ["libp2p-pnet"]
+request-response = ["libp2p-request-response"]
 secio = ["libp2p-secio"]
 tcp-async-std = ["libp2p-tcp", "libp2p-tcp/async-std"]
 tcp-tokio = ["libp2p-tcp", "libp2p-tcp/tokio"]
@@ -52,42 +54,47 @@ websocket = ["libp2p-websocket"]
 yamux = ["libp2p-yamux"]
 secp256k1 = ["libp2p-core/secp256k1", "libp2p-secio/secp256k1"]
 
+[package.metadata.docs.rs]
+all-features = true
+
 [dependencies]
+atomic = "0.4.6"
 bytes = "0.5"
 futures = "0.3.1"
 lazy_static = "1.2"
-libp2p-core = { version = "0.19.2", path = "core" }
-libp2p-core-derive = { version = "0.19.1", path = "misc/core-derive" }
-libp2p-floodsub = { version = "0.19.1", path = "protocols/floodsub", optional = true }
-libp2p-gossipsub = { version = "0.19.3", path = "./protocols/gossipsub", optional = true }
-libp2p-identify = { version = "0.19.2", path = "protocols/identify", optional = true }
-libp2p-kad = { version = "0.20.1", path = "protocols/kad", optional = true }
-libp2p-mplex = { version = "0.19.2", path = "muxers/mplex", optional = true }
-libp2p-noise = { version = "0.19.1", path = "protocols/noise", optional = true }
-libp2p-ping = { version = "0.19.3", path = "protocols/ping", optional = true }
-libp2p-plaintext = { version = "0.19.1", path = "protocols/plaintext", optional = true }
+libp2p-core = { version = "0.20.0", path = "core" }
+libp2p-core-derive = { version = "0.20.0", path = "misc/core-derive" }
+libp2p-floodsub = { version = "0.20.0", path = "protocols/floodsub", optional = true }
+libp2p-gossipsub = { version = "0.20.0", path = "./protocols/gossipsub", optional = true }
+libp2p-identify = { version = "0.20.0", path = "protocols/identify", optional = true }
+libp2p-kad = { version = "0.21.0", path = "protocols/kad", optional = true }
+libp2p-mplex = { version = "0.20.0", path = "muxers/mplex", optional = true }
+libp2p-noise = { version = "0.21.0", path = "protocols/noise", optional = true }
+libp2p-ping = { version = "0.20.0", path = "protocols/ping", optional = true }
+libp2p-plaintext = { version = "0.20.0", path = "protocols/plaintext", optional = true }
 libp2p-pnet = { version = "0.19.1", path = "protocols/pnet", optional = true }
-libp2p-secio = { version = "0.19.2", path = "protocols/secio", default-features = false, optional = true }
-libp2p-swarm = { version = "0.19.1", path = "swarm" }
-libp2p-uds = { version = "0.19.2", path = "transports/uds", optional = true }
-libp2p-wasm-ext = { version = "0.19.0", path = "transports/wasm-ext", optional = true }
-libp2p-yamux = { version = "0.19.1", path = "muxers/yamux", optional = true }
+libp2p-request-response = { version = "0.1.0", path = "protocols/request-response", optional = true }
+libp2p-secio = { version = "0.20.0", path = "protocols/secio", default-features = false, optional = true }
+libp2p-swarm = { version = "0.20.0", path = "swarm" }
+libp2p-uds = { version = "0.20.0", path = "transports/uds", optional = true }
+libp2p-wasm-ext = { version = "0.20.0", path = "transports/wasm-ext", optional = true }
+libp2p-yamux = { version = "0.20.0", path = "muxers/yamux", optional = true }
 multiaddr = { package = "parity-multiaddr", version = "0.9.1", path = "misc/multiaddr" }
 multihash = "0.11.0"
 parking_lot = "0.10.0"
 pin-project = "0.4.17"
 smallvec = "1.0"
 wasm-timer = "0.2.4"
 
-[target.'cfg(not(any(target_os = "emscripten", target_os = "unknown")))'.dependencies]
-libp2p-deflate = { version = "0.19.2", path = "protocols/deflate", optional = true }
-libp2p-dns = { version = "0.19.0", path = "transports/dns", optional = true }
-libp2p-mdns = { version = "0.19.2", path = "protocols/mdns", optional = true }
-libp2p-tcp = { version = "0.19.2", path = "transports/tcp", optional = true }
-libp2p-websocket = { version = "0.20.0", path = "transports/websocket", optional = true }
+[target.'cfg(not(any(target_os = "emscripten", target_os = "wasi", target_os = "unknown")))'.dependencies]
+libp2p-deflate = { version = "0.20.0", path = "protocols/deflate", optional = true }
+libp2p-dns = { version = "0.20.0", path = "transports/dns", optional = true }
+libp2p-mdns = { version = "0.20.0", path = "protocols/mdns", optional = true }
+libp2p-tcp = { version = "0.20.0", path = "transports/tcp", optional = true }
+libp2p-websocket = { version = "0.21.0", path = "transports/websocket", optional = true }
 
 [dev-dependencies]
-async-std = "1.5.0"
+async-std = "1.6.2"
 env_logger = "0.7.1"
 
 [workspace]
@@ -107,6 +114,7 @@ members = [
     "protocols/noise",
     "protocols/ping",
     "protocols/plaintext",
+    "protocols/request-response",
     "protocols/secio",
     "swarm",
     "transports/dns",

core/CHANGELOG.md

@@ -1,3 +1,19 @@
+# 0.20.1 [2020-17-17]
+
+- Update ed25519-dalek dependency.
+
+# 0.20.0 [2020-07-01]
+
+- Conditional compilation fixes for the `wasm32-wasi` target
+  ([PR 1633](https://github.com/libp2p/rust-libp2p/pull/1633)).
+
+- Rename `StreamMuxer::poll_inbound` to `poll_event` and change the
+return value to `StreamMuxerEvent`. This new `StreamMuxerEvent` makes
+it possible for the multiplexing layer to notify the upper layers of
+a change in the address of the underlying connection.
+
+- Add `ConnectionHandler::inject_address_change`.
+
 # 0.19.2 [2020-06-22]
 
 - Add PartialOrd and Ord for PeerId

core/Cargo.toml

@@ -2,7 +2,7 @@
 name = "libp2p-core"
 edition = "2018"
 description = "Core traits and structs of libp2p"
-version = "0.19.2"
+version = "0.20.1"
 authors = ["Parity Technologies <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/libp2p/rust-libp2p"
@@ -12,7 +12,7 @@ categories = ["network-programming", "asynchronous"]
 [dependencies]
 asn1_der = "0.6.1"
 bs58 = "0.3.0"
-ed25519-dalek = "1.0.0-pre.3"
+ed25519-dalek = "1.0.0-pre.4"
 either = "1.5"
 fnv = "1.0"
 futures = { version = "0.3.1", features = ["executor", "thread-pool"] }
@@ -35,11 +35,11 @@ unsigned-varint = "0.4"
 void = "1"
 zeroize = "1"
 
-[target.'cfg(not(any(target_os = "emscripten", target_os = "unknown")))'.dependencies]
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 ring = { version = "0.16.9", features = ["alloc", "std"], default-features = false }
 
 [dev-dependencies]
-async-std = "1.5.0"
+async-std = "1.6.2"
 libp2p-mplex = { path = "../muxers/mplex" }
 libp2p-secio = { path = "../protocols/secio" }
 libp2p-tcp = { path = "../transports/tcp", features = ["async-std"] }

core/src/connection.rs

@@ -132,6 +132,16 @@ impl ConnectedPoint {
             ConnectedPoint::Listener { .. } => true
         }
     }
+
+    /// Modifies the address of the remote stored in this struct.
+    ///
+    /// For `Dialer`, this modifies `address`. For `Listener`, this modifies `send_back_addr`.
+    pub fn set_remote_address(&mut self, new_address: Multiaddr) {
+        match self {
+            ConnectedPoint::Dialer { address } => *address = new_address,
+            ConnectedPoint::Listener { send_back_addr, .. } => *send_back_addr = new_address,
+        }
+    }
 }
 
 /// Information about a successfully established connection.
@@ -169,6 +179,15 @@ impl ConnectionInfo for PeerId {
     }
 }
 
+/// Event generated by a [`Connection`].
+#[derive(Debug, Clone)]
+pub enum Event<T> {
+    /// Event generated by the [`ConnectionHandler`].
+    Handler(T),
+    /// Address of the remote has changed.
+    AddressChange(Multiaddr),
+}
+
 /// A multiplexed connection to a peer with an associated `ConnectionHandler`.
 pub struct Connection<TMuxer, THandler>
 where
@@ -238,8 +257,8 @@ where
 
     /// Polls the connection for events produced by the associated handler
     /// as a result of I/O activity on the substream multiplexer.
-    pub fn poll(mut self: Pin<&mut Self>, cx: &mut Context)
-        -> Poll<Result<THandler::OutEvent, ConnectionError<THandler::Error>>>
+    pub fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>)
+        -> Poll<Result<Event<THandler::OutEvent>, ConnectionError<THandler::Error>>>
     {
         loop {
             let mut io_pending = false;
@@ -255,6 +274,10 @@ where
                     let endpoint = SubstreamEndpoint::Dialer(user_data);
                     self.handler.inject_substream(substream, endpoint)
                 }
+                Poll::Ready(Ok(SubstreamEvent::AddressChange(address))) => {
+                    self.handler.inject_address_change(&address);
+                    return Poll::Ready(Ok(Event::AddressChange(address)));
+                }
                 Poll::Ready(Err(err)) => return Poll::Ready(Err(ConnectionError::IO(err))),
             }
 
@@ -269,7 +292,7 @@ where
                     self.muxing.open_substream(user_data);
                 }
                 Poll::Ready(Ok(ConnectionHandlerEvent::Custom(event))) => {
-                    return Poll::Ready(Ok(event));
+                    return Poll::Ready(Ok(Event::Handler(event)));
                 }
                 Poll::Ready(Err(err)) => return Poll::Ready(Err(ConnectionError::Handler(err))),
             }

core/src/connection/handler.rs

@@ -18,7 +18,7 @@
 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 // DEALINGS IN THE SOFTWARE.
 
-use crate::PeerId;
+use crate::{Multiaddr, PeerId};
 use std::{task::Context, task::Poll};
 use super::{Connected, SubstreamEndpoint};
 
@@ -58,10 +58,13 @@ pub trait ConnectionHandler {
     /// Notifies the handler of an event.
     fn inject_event(&mut self, event: Self::InEvent);
 
+    /// Notifies the handler of a change in the address of the remote.
+    fn inject_address_change(&mut self, new_address: &Multiaddr);
+
     /// Polls the handler for events.
     ///
     /// Returning an error will close the connection to the remote.
-    fn poll(&mut self, cx: &mut Context)
+    fn poll(&mut self, cx: &mut Context<'_>)
         -> Poll<Result<ConnectionHandlerEvent<Self::OutboundOpenInfo, Self::OutEvent>, Self::Error>>;
 }
 

core/src/connection/listeners.rs

@@ -230,7 +230,7 @@ where
     }
 
     /// Provides an API similar to `Stream`, except that it cannot end.
-    pub fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<ListenersEvent<TTrans>> {
+    pub fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<ListenersEvent<TTrans>> {
         // We remove each element from `listeners` one by one and add them back.
         let mut remaining = self.listeners.len();
         while let Some(mut listener) = self.listeners.pop_back() {
@@ -310,7 +310,7 @@ where
 {
     type Item = ListenersEvent<TTrans>;
 
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         ListenersStream::poll(self, cx).map(Option::Some)
     }
 }

core/src/connection/manager.rs

@@ -32,11 +32,13 @@ use std::{
     collections::hash_map,
     error,
     fmt,
+    mem,
     pin::Pin,
     task::{Context, Poll},
 };
 use super::{
     Connected,
+    ConnectedPoint,
     Connection,
     ConnectionError,
     ConnectionHandler,
@@ -123,7 +125,7 @@ impl<I, O, H, E, HE, C> fmt::Debug for Manager<I, O, H, E, HE, C>
 where
     C: fmt::Debug,
 {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_map()
             .entries(self.tasks.iter().map(|(id, task)| (id, &task.state)))
             .finish()
@@ -220,7 +222,17 @@ pub enum Event<'a, I, O, H, TE, HE, C> {
         entry: EstablishedEntry<'a, I, C>,
         /// The produced event.
         event: O
-    }
+    },
+
+    /// A connection to a node has changed its address.
+    AddressChange {
+        /// The entry associated with the connection that changed address.
+        entry: EstablishedEntry<'a, I, C>,
+        /// The former [`ConnectedPoint`].
+        old_endpoint: ConnectedPoint,
+        /// The new [`ConnectedPoint`].
+        new_endpoint: ConnectedPoint,
+    },
 }
 
 impl<I, O, H, TE, HE, C> Manager<I, O, H, TE, HE, C> {
@@ -334,7 +346,7 @@ impl<I, O, H, TE, HE, C> Manager<I, O, H, TE, HE, C> {
     }
 
     /// Polls the manager for events relating to the managed connections.
-    pub fn poll<'a>(&'a mut self, cx: &mut Context) -> Poll<Event<'a, I, O, H, TE, HE, C>> {
+    pub fn poll<'a>(&'a mut self, cx: &mut Context<'_>) -> Poll<Event<'a, I, O, H, TE, HE, C>> {
         // Advance the content of `local_spawns`.
         while let Poll::Ready(Some(_)) = Stream::poll_next(Pin::new(&mut self.local_spawns), cx) {}
 
@@ -369,6 +381,23 @@ impl<I, O, H, TE, HE, C> Manager<I, O, H, TE, HE, C> {
                     let _ = task.remove();
                     Event::PendingConnectionError { id, error, handler }
                 }
+                task::Event::AddressChange { id: _, new_address } => {
+                    let (new, old) = if let TaskState::Established(c) = &mut task.get_mut().state {
+                        let mut new_endpoint = c.endpoint.clone();
+                        new_endpoint.set_remote_address(new_address);
+                        let old_endpoint = mem::replace(&mut c.endpoint, new_endpoint.clone());
+                        (new_endpoint, old_endpoint)
+                    } else {
+                        unreachable!(
+                            "`Event::AddressChange` implies (2) occurred on that task and thus (3)."
+                        )
+                    };
+                    Event::AddressChange {
+                        entry: EstablishedEntry { task },
+                        old_endpoint: old,
+                        new_endpoint: new,
+                    }
+                },
                 task::Event::Error { id, error } => {
                     let id = ConnectionId(id);
                     let task = task.remove();
@@ -439,7 +468,7 @@ impl<'a, I, C> EstablishedEntry<'a, I, C> {
     ///
     /// Returns `Err(())` if the background task associated with the connection
     /// is terminating and the connection is about to close.
-    pub fn poll_ready_notify_handler(&mut self, cx: &mut Context) -> Poll<Result<(),()>> {
+    pub fn poll_ready_notify_handler(&mut self, cx: &mut Context<'_>) -> Poll<Result<(),()>> {
         self.task.get_mut().sender.poll_ready(cx).map_err(|_| ())
     }