fluencelabs/rust-libp2p
1
0
Fork 0
mirror of https://github.com/fluencelabs/rust-libp2p synced 2025-06-28 17:21:34 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #1328 from libp2p/stable-futures

Browse Source 
Refactor the crate to use stable futures
This commit is contained in:
Pierre Krieger
2020-01-06 19:20:30 +01:00
committed by GitHub
parent b7146f4918 ced66a319c
commit 56ca671376
139 changed files with 6145 additions and 8175 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG.md
View File

@ -1,3 +1,7 @@
# Next Version
- Use varints instead of fixed sized (4 byte) integers to delimit plaintext 2.0 messages to align implementation with the specification.
# Version 0.13.2 (2020-01-02)
- Fixed the `libp2p-noise` handshake not flushing the underlying stream before waiting for a response.

15
Cargo.toml
View File

@ -14,8 +14,8 @@ default = ["secp256k1", "libp2p-websocket"]
secp256k1 = ["libp2p-core/secp256k1", "libp2p-secio/secp256k1"]
[dependencies]
bytes = "0.4"
futures = "0.1"
bytes = "0.5"
futures = "0.3.1"
multiaddr = { package = "parity-multiaddr", version = "0.6.0", path = "misc/multiaddr" }
multihash = { package = "parity-multihash", version = "0.2.0", path = "misc/multihash" }
lazy_static = "1.2"
@ -33,11 +33,8 @@ libp2p-uds = { version = "0.13.0", path = "transports/uds" }
libp2p-wasm-ext = { version = "0.6.0", path = "transports/wasm-ext" }
libp2p-yamux = { version = "0.13.0", path = "muxers/yamux" }
parking_lot = "0.9.0"
smallvec = "0.6"
tokio-codec = "0.1"
tokio-executor = "0.1"
tokio-io = "0.1"
wasm-timer = "0.1"
smallvec = "1.0"
wasm-timer = "0.2.4"
[target.'cfg(not(any(target_os = "emscripten", target_os = "unknown")))'.dependencies]
libp2p-deflate = { version = "0.5.0", path = "protocols/deflate" }
@ -48,9 +45,8 @@ libp2p-tcp = { version = "0.13.0", path = "transports/tcp" }
libp2p-websocket = { version = "0.13.0", path = "transports/websocket", optional = true }
[dev-dependencies]
async-std = "1.0"
env_logger = "0.7.1"
tokio = "0.1"
tokio-stdin-stdout = "0.1"
[workspace]
members = [
@ -78,3 +74,4 @@ members = [
"transports/websocket",
"transports/wasm-ext"
]

27
core/Cargo.toml
View File

@ -12,28 +12,27 @@ categories = ["network-programming", "asynchronous"]
[dependencies]
asn1_der = "0.6.1"
bs58 = "0.3.0"
bytes = "0.4"
bytes = "0.5"
ed25519-dalek = "1.0.0-pre.3"
failure = "0.1"
fnv = "1.0"
futures = { version = "0.3.1", features = ["compat", "io-compat", "executor", "thread-pool"] }
futures-timer = "2"
lazy_static = "1.2"
libsecp256k1 = { version = "0.3.1", optional = true }
log = "0.4"
multiaddr = { package = "parity-multiaddr", version = "0.6.0", path = "../misc/multiaddr" }
multihash = { package = "parity-multihash", version = "0.2.0", path = "../misc/multihash" }
multistream-select = { version = "0.6.0", path = "../misc/multistream-select" }
futures = "0.1"
parking_lot = "0.9.0"
pin-project = "0.4.6"
protobuf = "=2.8.1" # note: see https://github.com/libp2p/rust-libp2p/issues/1363
quick-error = "1.2"
rand = "0.7"
rw-stream-sink = { version = "0.1.1", path = "../misc/rw-stream-sink" }
libsecp256k1 = { version = "0.3.1", optional = true }
sha2 = "0.8.0"
smallvec = "0.6"
tokio-executor = "0.1.4"
tokio-io = "0.1"
wasm-timer = "0.1"
unsigned-varint = "0.2"
smallvec = "1.0"
unsigned-varint = "0.3"
void = "1"
zeroize = "1"
@ -42,16 +41,14 @@ ring = { version = "0.16.9", features = ["alloc", "std"], default-features = fal
untrusted = "0.7.0"
[dev-dependencies]
libp2p-swarm = { version = "0.3.0", path = "../swarm" }
libp2p-tcp = { version = "0.13.0", path = "../transports/tcp" }
assert_matches = "1.3"
async-std = "1.0"
libp2p-mplex = { version = "0.13.0", path = "../muxers/mplex" }
libp2p-secio = { version = "0.13.0", path = "../protocols/secio" }
rand = "0.7.2"
libp2p-swarm = { version = "0.3.0", path = "../swarm" }
libp2p-tcp = { version = "0.13.0", path = "../transports/tcp" }
quickcheck = "0.9.0"
tokio = "0.1"
wasm-timer = "0.1"
assert_matches = "1.3"
tokio-mock-task = "0.1"
wasm-timer = "0.2"
[features]
default = ["secp256k1"]

308
core/src/either.rs
View File

@ -19,9 +19,9 @@
// DEALINGS IN THE SOFTWARE.
use crate::{muxing::StreamMuxer, ProtocolName, transport::ListenerEvent};
use futures::prelude::*;
use std::{fmt, io::{Error as IoError, Read, Write}};
use tokio_io::{AsyncRead, AsyncWrite};
use futures::{prelude::*, io::{IoSlice, IoSliceMut}};
use pin_project::{pin_project, project};
use std::{fmt, io::{Error as IoError}, pin::Pin, task::Context, task::Poll};
#[derive(Debug, Copy, Clone)]
pub enum EitherError<A, B> {
@ -57,10 +57,11 @@ where
/// Implements `AsyncRead` and `AsyncWrite` and dispatches all method calls to
/// either `First` or `Second`.
#[pin_project]
#[derive(Debug, Copy, Clone)]
pub enum EitherOutput<A, B> {
First(A),
Second(B),
First(#[pin] A),
Second(#[pin] B),
}
impl<A, B> AsyncRead for EitherOutput<A, B>
@ -68,30 +69,23 @@ where
A: AsyncRead,
B: AsyncRead,
{
unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
match self {
EitherOutput::First(a) => a.prepare_uninitialized_buffer(buf),
EitherOutput::Second(b) => b.prepare_uninitialized_buffer(buf),
#[project]
fn poll_read(self: Pin<&mut Self>, cx: &mut Context, buf: &mut [u8]) -> Poll<Result<usize, IoError>> {
#[project]
match self.project() {
EitherOutput::First(a) => AsyncRead::poll_read(a, cx, buf),
EitherOutput::Second(b) => AsyncRead::poll_read(b, cx, buf),
}
}
fn read_buf<Bu: bytes::BufMut>(&mut self, buf: &mut Bu) -> Poll<usize, IoError> {
match self {
EitherOutput::First(a) => a.read_buf(buf),
EitherOutput::Second(b) => b.read_buf(buf),
}
}
}
impl<A, B> Read for EitherOutput<A, B>
where
A: Read,
B: Read,
{
fn read(&mut self, buf: &mut [u8]) -> Result<usize, IoError> {
match self {
EitherOutput::First(a) => a.read(buf),
EitherOutput::Second(b) => b.read(buf),
#[project]
fn poll_read_vectored(self: Pin<&mut Self>, cx: &mut Context, bufs: &mut [IoSliceMut])
-> Poll<Result<usize, IoError>>
{
#[project]
match self.project() {
EitherOutput::First(a) => AsyncRead::poll_read_vectored(a, cx, bufs),
EitherOutput::Second(b) => AsyncRead::poll_read_vectored(b, cx, bufs),
}
}
}
@ -101,76 +95,104 @@ where
A: AsyncWrite,
B: AsyncWrite,
{
fn shutdown(&mut self) -> Poll<(), IoError> {
match self {
EitherOutput::First(a) => a.shutdown(),
EitherOutput::Second(b) => b.shutdown(),
}
}
}
impl<A, B> Write for EitherOutput<A, B>
where
A: Write,
B: Write,
{
fn write(&mut self, buf: &[u8]) -> Result<usize, IoError> {
match self {
EitherOutput::First(a) => a.write(buf),
EitherOutput::Second(b) => b.write(buf),
#[project]
fn poll_write(self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) -> Poll<Result<usize, IoError>> {
#[project]
match self.project() {
EitherOutput::First(a) => AsyncWrite::poll_write(a, cx, buf),
EitherOutput::Second(b) => AsyncWrite::poll_write(b, cx, buf),
}
}
fn flush(&mut self) -> Result<(), IoError> {
match self {
EitherOutput::First(a) => a.flush(),
EitherOutput::Second(b) => b.flush(),
#[project]
fn poll_write_vectored(self: Pin<&mut Self>, cx: &mut Context, bufs: &[IoSlice])
-> Poll<Result<usize, IoError>>
{
#[project]
match self.project() {
EitherOutput::First(a) => AsyncWrite::poll_write_vectored(a, cx, bufs),
EitherOutput::Second(b) => AsyncWrite::poll_write_vectored(b, cx, bufs),
}
}
#[project]
fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), IoError>> {
#[project]
match self.project() {
EitherOutput::First(a) => AsyncWrite::poll_flush(a, cx),
EitherOutput::Second(b) => AsyncWrite::poll_flush(b, cx),
}
}
#[project]
fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), IoError>> {
#[project]
match self.project() {
EitherOutput::First(a) => AsyncWrite::poll_close(a, cx),
EitherOutput::Second(b) => AsyncWrite::poll_close(b, cx),
}
}
}
impl<A, B, I> Stream for EitherOutput<A, B>
where
A: Stream<Item = I>,
B: Stream<Item = I>,
A: TryStream<Ok = I>,
B: TryStream<Ok = I>,
{
type Item = I;
type Error = EitherError<A::Error, B::Error>;
type Item = Result<I, EitherError<A::Error, B::Error>>;
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
match self {
EitherOutput::First(a) => a.poll().map_err(EitherError::A),
EitherOutput::Second(b) => b.poll().map_err(EitherError::B),
#[project]
fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
#[project]
match self.project() {
EitherOutput::First(a) => TryStream::try_poll_next(a, cx)
.map(|v| v.map(|r| r.map_err(EitherError::A))),
EitherOutput::Second(b) => TryStream::try_poll_next(b, cx)
.map(|v| v.map(|r| r.map_err(EitherError::B))),
}
}
}
impl<A, B, I> Sink for EitherOutput<A, B>
impl<A, B, I> Sink<I> for EitherOutput<A, B>
where
A: Sink<SinkItem = I>,
B: Sink<SinkItem = I>,
A: Sink<I> + Unpin,
B: Sink<I> + Unpin,
{
type SinkItem = I;
type SinkError = EitherError<A::SinkError, B::SinkError>;
type Error = EitherError<A::Error, B::Error>;
fn start_send(&mut self, item: Self::SinkItem) -> StartSend<Self::SinkItem, Self::SinkError> {
match self {
EitherOutput::First(a) => a.start_send(item).map_err(EitherError::A),
EitherOutput::Second(b) => b.start_send(item).map_err(EitherError::B),
#[project]
fn poll_ready(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
#[project]
match self.project() {
EitherOutput::First(a) => Sink::poll_ready(a, cx).map_err(EitherError::A),
EitherOutput::Second(b) => Sink::poll_ready(b, cx).map_err(EitherError::B),
}
}
fn poll_complete(&mut self) -> Poll<(), Self::SinkError> {
match self {
EitherOutput::First(a) => a.poll_complete().map_err(EitherError::A),
EitherOutput::Second(b) => b.poll_complete().map_err(EitherError::B),
#[project]
fn start_send(self: Pin<&mut Self>, item: I) -> Result<(), Self::Error> {
#[project]
match self.project() {
EitherOutput::First(a) => Sink::start_send(a, item).map_err(EitherError::A),
EitherOutput::Second(b) => Sink::start_send(b, item).map_err(EitherError::B),
}
}
fn close(&mut self) -> Poll<(), Self::SinkError> {
match self {
EitherOutput::First(a) => a.close().map_err(EitherError::A),
EitherOutput::Second(b) => b.close().map_err(EitherError::B),
#[project]
fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
#[project]
match self.project() {
EitherOutput::First(a) => Sink::poll_flush(a, cx).map_err(EitherError::A),
EitherOutput::Second(b) => Sink::poll_flush(b, cx).map_err(EitherError::B),
}
}
#[project]
fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
#[project]
match self.project() {
EitherOutput::First(a) => Sink::poll_close(a, cx).map_err(EitherError::A),
EitherOutput::Second(b) => Sink::poll_close(b, cx).map_err(EitherError::B),
}
}
}
@ -184,10 +206,10 @@ where
type OutboundSubstream = EitherOutbound<A, B>;
type Error = IoError;
fn poll_inbound(&self) -> Poll<Self::Substream, Self::Error> {
fn poll_inbound(&self, cx: &mut Context) -> Poll<Result<Self::Substream, Self::Error>> {
match self {
EitherOutput::First(inner) => inner.poll_inbound().map(|p| p.map(EitherOutput::First)).map_err(|e| e.into()),
EitherOutput::Second(inner) => inner.poll_inbound().map(|p| p.map(EitherOutput::Second)).map_err(|e| e.into()),
EitherOutput::First(inner) => inner.poll_inbound(cx).map(|p| p.map(EitherOutput::First)).map_err(|e| e.into()),
EitherOutput::Second(inner) => inner.poll_inbound(cx).map(|p| p.map(EitherOutput::Second)).map_err(|e| e.into()),
}
}
@ -198,13 +220,13 @@ where
}
}
fn poll_outbound(&self, substream: &mut Self::OutboundSubstream) -> Poll<Self::Substream, Self::Error> {
fn poll_outbound(&self, cx: &mut Context, substream: &mut Self::OutboundSubstream) -> Poll<Result<Self::Substream, Self::Error>> {
match (self, substream) {
(EitherOutput::First(ref inner), EitherOutbound::A(ref mut substream)) => {
inner.poll_outbound(substream).map(|p| p.map(EitherOutput::First)).map_err(|e| e.into())
inner.poll_outbound(cx, substream).map(|p| p.map(EitherOutput::First)).map_err(|e| e.into())
},
(EitherOutput::Second(ref inner), EitherOutbound::B(ref mut substream)) => {
inner.poll_outbound(substream).map(|p| p.map(EitherOutput::Second)).map_err(|e| e.into())
inner.poll_outbound(cx, substream).map(|p| p.map(EitherOutput::Second)).map_err(|e| e.into())
},
_ => panic!("Wrong API usage")
}
@ -227,56 +249,49 @@ where
}
}
unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
match self {
EitherOutput::First(ref inner) => inner.prepare_uninitialized_buffer(buf),
EitherOutput::Second(ref inner) => inner.prepare_uninitialized_buffer(buf),
}
}
fn read_substream(&self, sub: &mut Self::Substream, buf: &mut [u8]) -> Poll<usize, Self::Error> {
fn read_substream(&self, cx: &mut Context, sub: &mut Self::Substream, buf: &mut [u8]) -> Poll<Result<usize, Self::Error>> {
match (self, sub) {
(EitherOutput::First(ref inner), EitherOutput::First(ref mut sub)) => {
inner.read_substream(sub, buf).map_err(|e| e.into())
inner.read_substream(cx, sub, buf).map_err(|e| e.into())
},
(EitherOutput::Second(ref inner), EitherOutput::Second(ref mut sub)) => {
inner.read_substream(sub, buf).map_err(|e| e.into())
inner.read_substream(cx, sub, buf).map_err(|e| e.into())
},
_ => panic!("Wrong API usage")
}
}
fn write_substream(&self, sub: &mut Self::Substream, buf: &[u8]) -> Poll<usize, Self::Error> {
fn write_substream(&self, cx: &mut Context, sub: &mut Self::Substream, buf: &[u8]) -> Poll<Result<usize, Self::Error>> {
match (self, sub) {
(EitherOutput::First(ref inner), EitherOutput::First(ref mut sub)) => {
inner.write_substream(sub, buf).map_err(|e| e.into())
inner.write_substream(cx, sub, buf).map_err(|e| e.into())
},
(EitherOutput::Second(ref inner), EitherOutput::Second(ref mut sub)) => {
inner.write_substream(sub, buf).map_err(|e| e.into())
inner.write_substream(cx, sub, buf).map_err(|e| e.into())
},
_ => panic!("Wrong API usage")
}
}
fn flush_substream(&self, sub: &mut Self::Substream) -> Poll<(), Self::Error> {
fn flush_substream(&self, cx: &mut Context, sub: &mut Self::Substream) -> Poll<Result<(), Self::Error>> {
match (self, sub) {
(EitherOutput::First(ref inner), EitherOutput::First(ref mut sub)) => {
inner.flush_substream(sub).map_err(|e| e.into())
inner.flush_substream(cx, sub).map_err(|e| e.into())
},
(EitherOutput::Second(ref inner), EitherOutput::Second(ref mut sub)) => {
inner.flush_substream(sub).map_err(|e| e.into())
inner.flush_substream(cx, sub).map_err(|e| e.into())
},
_ => panic!("Wrong API usage")
}
}
fn shutdown_substream(&self, sub: &mut Self::Substream) -> Poll<(), Self::Error> {
fn shutdown_substream(&self, cx: &mut Context, sub: &mut Self::Substream) -> Poll<Result<(), Self::Error>> {
match (self, sub) {
(EitherOutput::First(ref inner), EitherOutput::First(ref mut sub)) => {
inner.shutdown_substream(sub).map_err(|e| e.into())
inner.shutdown_substream(cx, sub).map_err(|e| e.into())
},
(EitherOutput::Second(ref inner), EitherOutput::Second(ref mut sub)) => {
inner.shutdown_substream(sub).map_err(|e| e.into())
inner.shutdown_substream(cx, sub).map_err(|e| e.into())
},
_ => panic!("Wrong API usage")
}
@ -306,17 +321,17 @@ where
}
}
fn close(&self) -> Poll<(), Self::Error> {
fn close(&self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
match self {
EitherOutput::First(inner) => inner.close().map_err(|e| e.into()),
EitherOutput::Second(inner) => inner.close().map_err(|e| e.into()),
EitherOutput::First(inner) => inner.close(cx).map_err(|e| e.into()),
EitherOutput::Second(inner) => inner.close(cx).map_err(|e| e.into()),
}
}
fn flush_all(&self) -> Poll<(), Self::Error> {
fn flush_all(&self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
match self {
EitherOutput::First(inner) => inner.flush_all().map_err(|e| e.into()),
EitherOutput::Second(inner) => inner.flush_all().map_err(|e| e.into()),
EitherOutput::First(inner) => inner.flush_all(cx).map_err(|e| e.into()),
EitherOutput::Second(inner) => inner.flush_all(cx).map_err(|e| e.into()),
}
}
}
@ -329,78 +344,89 @@ pub enum EitherOutbound<A: StreamMuxer, B: StreamMuxer> {
}
/// Implements `Stream` and dispatches all method calls to either `First` or `Second`.
#[pin_project]
#[derive(Debug, Copy, Clone)]
#[must_use = "futures do nothing unless polled"]
pub enum EitherListenStream<A, B> {
First(A),
Second(B),
First(#[pin] A),
Second(#[pin] B),
}
impl<AStream, BStream, AInner, BInner> Stream for EitherListenStream<AStream, BStream>
where
AStream: Stream<Item = ListenerEvent<AInner>>,
BStream: Stream<Item = ListenerEvent<BInner>>,
AStream: TryStream<Ok = ListenerEvent<AInner>>,
BStream: TryStream<Ok = ListenerEvent<BInner>>,
{
type Item = ListenerEvent<EitherFuture<AInner, BInner>>;
type Error = EitherError<AStream::Error, BStream::Error>;
type Item = Result<ListenerEvent<EitherFuture<AInner, BInner>>, EitherError<AStream::Error, BStream::Error>>;
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
match self {
EitherListenStream::First(a) => a.poll()
.map(|i| (i.map(|v| (v.map(|e| e.map(EitherFuture::First))))))
.map_err(EitherError::A),
EitherListenStream::Second(a) => a.poll()
.map(|i| (i.map(|v| (v.map(|e| e.map(EitherFuture::Second))))))
.map_err(EitherError::B),
#[project]
fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
#[project]
match self.project() {
EitherListenStream::First(a) => match TryStream::try_poll_next(a, cx) {
Poll::Pending => Poll::Pending,
Poll::Ready(None) => Poll::Ready(None),
Poll::Ready(Some(Ok(le))) => Poll::Ready(Some(Ok(le.map(EitherFuture::First)))),
Poll::Ready(Some(Err(err))) => Poll::Ready(Some(Err(EitherError::A(err)))),
},
EitherListenStream::Second(a) => match TryStream::try_poll_next(a, cx) {
Poll::Pending => Poll::Pending,
Poll::Ready(None) => Poll::Ready(None),
Poll::Ready(Some(Ok(le))) => Poll::Ready(Some(Ok(le.map(EitherFuture::Second)))),
Poll::Ready(Some(Err(err))) => Poll::Ready(Some(Err(EitherError::B(err)))),
},
}
}
}
/// Implements `Future` and dispatches all method calls to either `First` or `Second`.
#[pin_project]
#[derive(Debug, Copy, Clone)]
#[must_use = "futures do nothing unless polled"]
pub enum EitherFuture<A, B> {
First(A),
Second(B),
First(#[pin] A),
Second(#[pin] B),
}
impl<AFuture, BFuture, AInner, BInner> Future for EitherFuture<AFuture, BFuture>
where
AFuture: Future<Item = AInner>,
BFuture: Future<Item = BInner>,
AFuture: TryFuture<Ok = AInner>,
BFuture: TryFuture<Ok = BInner>,
{
type Item = EitherOutput<AInner, BInner>;
type Error = EitherError<AFuture::Error, BFuture::Error>;
type Output = Result<EitherOutput<AInner, BInner>, EitherError<AFuture::Error, BFuture::Error>>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
match self {
EitherFuture::First(a) => a.poll().map(|v| v.map(EitherOutput::First)).map_err(EitherError::A),
EitherFuture::Second(a) => a.poll().map(|v| v.map(EitherOutput::Second)).map_err(EitherError::B),
#[project]
fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
#[project]
match self.project() {
EitherFuture::First(a) => TryFuture::try_poll(a, cx)
.map_ok(EitherOutput::First).map_err(EitherError::A),
EitherFuture::Second(a) => TryFuture::try_poll(a, cx)
.map_ok(EitherOutput::Second).map_err(EitherError::B),
}
}
}
#[pin_project]
#[derive(Debug, Copy, Clone)]
#[must_use = "futures do nothing unless polled"]
pub enum EitherFuture2<A, B> { A(A), B(B) }
pub enum EitherFuture2<A, B> { A(#[pin] A), B(#[pin] B) }
impl<AFut, BFut, AItem, BItem, AError, BError> Future for EitherFuture2<AFut, BFut>
where
AFut: Future<Item = AItem, Error = AError>,
BFut: Future<Item = BItem, Error = BError>
AFut: TryFuture<Ok = AItem, Error = AError> + Unpin,
BFut: TryFuture<Ok = BItem, Error = BError> + Unpin,
{
type Item = EitherOutput<AItem, BItem>;
type Error = EitherError<AError, BError>;
type Output = Result<EitherOutput<AItem, BItem>, EitherError<AError, BError>>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
match self {
EitherFuture2::A(a) => a.poll()
.map(|v| v.map(EitherOutput::First))
.map_err(EitherError::A),
EitherFuture2::B(b) => b.poll()
.map(|v| v.map(EitherOutput::Second))
.map_err(EitherError::B)
#[project]
fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
#[project]
match self.project() {
EitherFuture2::A(a) => TryFuture::try_poll(a, cx)
.map_ok(EitherOutput::First).map_err(EitherError::A),
EitherFuture2::B(a) => TryFuture::try_poll(a, cx)
.map_ok(EitherOutput::Second).map_err(EitherError::B),
}
}
}

5
core/src/lib.rs
View File

@ -37,15 +37,12 @@
/// Multi-address re-export.
pub use multiaddr;
pub use multistream_select::Negotiated;
pub type Negotiated<T> = futures::compat::Compat01As03<multistream_select::Negotiated<futures::compat::Compat<T>>>;
mod keys_proto;
mod peer_id;
mod translation;
#[cfg(test)]
mod tests;
pub mod either;
pub mod identity;
pub mod muxing;

292
core/src/muxing.rs
View File

@ -52,13 +52,9 @@
//! implementation of `StreamMuxer` to control everything that happens on the wire.
use fnv::FnvHashMap;
use futures::{future, prelude::*, try_ready};
use futures::{future, prelude::*, task::Context, task::Poll};
use parking_lot::Mutex;
use std::io::{self, Read, Write};
use std::ops::Deref;
use std::fmt;
use std::sync::atomic::{AtomicUsize, Ordering};
use tokio_io::{AsyncRead, AsyncWrite};
use std::{io, ops::Deref, fmt, pin::Pin, sync::atomic::{AtomicUsize, Ordering}};
pub use self::singleton::SingletonMuxer;
@ -90,12 +86,12 @@ pub trait StreamMuxer {
///
/// This function behaves the same as a `Stream`.
///
/// If `NotReady` is returned, then the current task will be notified once the muxer
/// If `Pending` is returned, then the current task will be notified once the muxer
/// is ready to be polled, similar to the API of `Stream::poll()`.
/// Only the latest task that was used to call this method may be notified.
///
/// An error can be generated if the connection has been closed.
fn poll_inbound(&self) -> Poll<Self::Substream, Self::Error>;
fn poll_inbound(&self, cx: &mut Context) -> Poll<Result<Self::Substream, Self::Error>>;
/// Opens a new outgoing substream, and produces the equivalent to a future that will be
/// resolved when it becomes available.
@ -106,22 +102,23 @@ pub trait StreamMuxer {
/// Polls the outbound substream.
///
/// If `NotReady` is returned, then the current task will be notified once the substream
/// If `Pending` is returned, then the current task will be notified once the substream
/// is ready to be polled, similar to the API of `Future::poll()`.
/// However, for each individual outbound substream, only the latest task that was used to
/// call this method may be notified.
///
/// May panic or produce an undefined result if an earlier polling of the same substream
/// returned `Ready` or `Err`.
fn poll_outbound(&self, s: &mut Self::OutboundSubstream) -> Poll<Self::Substream, Self::Error>;
fn poll_outbound(&self, cx: &mut Context, s: &mut Self::OutboundSubstream)
-> Poll<Result<Self::Substream, Self::Error>>;
/// Destroys an outbound substream future. Use this after the outbound substream has finished,
/// or if you want to interrupt it.
fn destroy_outbound(&self, s: Self::OutboundSubstream);
/// Reads data from a substream. The behaviour is the same as `tokio_io::AsyncRead::poll_read`.
/// Reads data from a substream. The behaviour is the same as `futures::AsyncRead::poll_read`.
///
/// If `NotReady` is returned, then the current task will be notified once the substream
/// If `Pending` is returned, then the current task will be notified once the substream
/// is ready to be read. However, for each individual substream, only the latest task that
/// was used to call this method may be notified.
///
@ -130,25 +127,12 @@ pub trait StreamMuxer {
///
/// An error can be generated if the connection has been closed, or if a protocol misbehaviour
/// happened.
fn read_substream(&self, s: &mut Self::Substream, buf: &mut [u8]) -> Poll<usize, Self::Error>;
fn read_substream(&self, cx: &mut Context, s: &mut Self::Substream, buf: &mut [u8])
-> Poll<Result<usize, Self::Error>>;
/// Mimics the `prepare_uninitialized_buffer` method of the `AsyncRead` trait.
/// Write data to a substream. The behaviour is the same as `futures::AsyncWrite::poll_write`.
///
/// This function isn't actually unsafe to call but unsafe to implement. The implementer must
/// ensure that either the whole buf has been zeroed or that `read_substream` overwrites the
/// buffer without reading it and returns correct value.
///
/// If this function returns true, then the memory has been zeroed out. This allows
/// implementations of `AsyncRead` which are composed of multiple subimplementations to
/// efficiently implement `prepare_uninitialized_buffer`.
unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
for b in buf.iter_mut() { *b = 0; }
true
}
/// Write data to a substream. The behaviour is the same as `tokio_io::AsyncWrite::poll_write`.
///
/// If `NotReady` is returned, then the current task will be notified once the substream
/// If `Pending` is returned, then the current task will be notified once the substream
/// is ready to be read. For each individual substream, only the latest task that was used to
/// call this method may be notified.
///
@ -157,24 +141,26 @@ pub trait StreamMuxer {
///
/// It is incorrect to call this method on a substream if you called `shutdown_substream` on
/// this substream earlier.
fn write_substream(&self, s: &mut Self::Substream, buf: &[u8]) -> Poll<usize, Self::Error>;
fn write_substream(&self, cx: &mut Context, s: &mut Self::Substream, buf: &[u8])
-> Poll<Result<usize, Self::Error>>;
/// Flushes a substream. The behaviour is the same as `tokio_io::AsyncWrite::poll_flush`.
/// Flushes a substream. The behaviour is the same as `futures::AsyncWrite::poll_flush`.
///
/// After this method has been called, data written earlier on the substream is guaranteed to
/// be received by the remote.
///
/// If `NotReady` is returned, then the current task will be notified once the substream
/// If `Pending` is returned, then the current task will be notified once the substream
/// is ready to be read. For each individual substream, only the latest task that was used to
/// call this method may be notified.
///
/// > **Note**: This method may be implemented as a call to `flush_all`.
fn flush_substream(&self, s: &mut Self::Substream) -> Poll<(), Self::Error>;
fn flush_substream(&self, cx: &mut Context, s: &mut Self::Substream)
-> Poll<Result<(), Self::Error>>;
/// Attempts to shut down the writing side of a substream. The behaviour is similar to
/// `tokio_io::AsyncWrite::shutdown`.
/// `AsyncWrite::poll_close`.
///
/// Contrary to `AsyncWrite::shutdown`, shutting down a substream does not imply
/// Contrary to `AsyncWrite::poll_close`, shutting down a substream does not imply
/// `flush_substream`. If you want to make sure that the remote is immediately informed about
/// the shutdown, use `flush_substream` or `flush_all`.
///
@ -182,7 +168,8 @@ pub trait StreamMuxer {
///
/// An error can be generated if the connection has been closed, or if a protocol misbehaviour
/// happened.
fn shutdown_substream(&self, s: &mut Self::Substream) -> Poll<(), Self::Error>;
fn shutdown_substream(&self, cx: &mut Context, s: &mut Self::Substream)
-> Poll<Result<(), Self::Error>>;
/// Destroys a substream.
fn destroy_substream(&self, s: Self::Substream);
@ -197,7 +184,7 @@ pub trait StreamMuxer {
/// Closes this `StreamMuxer`.
///
/// After this has returned `Ok(Async::Ready(()))`, the muxer has become useless. All
/// After this has returned `Poll::Ready(Ok(()))`, the muxer has become useless. All
/// subsequent reads must return either `EOF` or an error. All subsequent writes, shutdowns,
/// or polls must generate an error or be ignored.
///
@ -207,14 +194,14 @@ pub trait StreamMuxer {
/// > that the remote is properly informed of the shutdown. However, apart from
/// > properly informing the remote, there is no difference between this and
/// > immediately dropping the muxer.
fn close(&self) -> Poll<(), Self::Error>;
fn close(&self, cx: &mut Context) -> Poll<Result<(), Self::Error>>;
/// Flush this `StreamMuxer`.
///
/// This drains any write buffers of substreams and delivers any pending shutdown notifications
/// due to `shutdown_substream` or `close`. One may thus shutdown groups of substreams
/// followed by a final `flush_all` instead of having to do `flush_substream` for each.
fn flush_all(&self) -> Poll<(), Self::Error>;
fn flush_all(&self, cx: &mut Context) -> Poll<Result<(), Self::Error>>;
}
/// Polls for an inbound from the muxer but wraps the output in an object that
@ -222,14 +209,14 @@ pub trait StreamMuxer {
#[inline]
pub fn inbound_from_ref_and_wrap<P>(
muxer: P,
) -> impl Future<Item = SubstreamRef<P>, Error = <P::Target as StreamMuxer>::Error>
) -> impl Future<Output = Result<SubstreamRef<P>, <P::Target as StreamMuxer>::Error>>
where
P: Deref + Clone,
P::Target: StreamMuxer,
{
let muxer2 = muxer.clone();
future::poll_fn(move || muxer.poll_inbound())
.map(|substream| substream_from_ref(muxer2, substream))
future::poll_fn(move |cx| muxer.poll_inbound(cx))
.map_ok(|substream| substream_from_ref(muxer2, substream))
}
/// Same as `outbound_from_ref`, but wraps the output in an object that
@ -258,17 +245,16 @@ where
P: Deref + Clone,
P::Target: StreamMuxer,
{
type Item = SubstreamRef<P>;
type Error = <P::Target as StreamMuxer>::Error;
type Output = Result<SubstreamRef<P>, <P::Target as StreamMuxer>::Error>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
match self.inner.poll() {
Ok(Async::Ready(substream)) => {
fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
match Future::poll(Pin::new(&mut self.inner), cx) {
Poll::Ready(Ok(substream)) => {
let out = substream_from_ref(self.inner.muxer.clone(), substream);
Ok(Async::Ready(out))
Poll::Ready(Ok(out))
}
Ok(Async::NotReady) => Ok(Async::NotReady),
Err(err) => Err(err),
Poll::Pending => Poll::Pending,
Poll::Ready(Err(err)) => Poll::Ready(Err(err)),
}
}
}
@ -297,18 +283,26 @@ where
outbound: Option<<P::Target as StreamMuxer>::OutboundSubstream>,
}
impl<P> Unpin for OutboundSubstreamRefFuture<P>
where
P: Deref,
P::Target: StreamMuxer,
{
}
impl<P> Future for OutboundSubstreamRefFuture<P>
where
P: Deref,
P::Target: StreamMuxer,
{
type Item = <P::Target as StreamMuxer>::Substream;
type Error = <P::Target as StreamMuxer>::Error;
type Output = Result<<P::Target as StreamMuxer>::Substream, <P::Target as StreamMuxer>::Error>;
#[inline]
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
self.muxer
.poll_outbound(self.outbound.as_mut().expect("outbound was empty"))
fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
// We use a `this` because the compiler isn't smart enough to allow mutably borrowing
// multiple different fields from the `Pin` at the same time.
let this = &mut *self;
this.muxer.poll_outbound(cx, this.outbound.as_mut().expect("outbound was empty"))
}
}
@ -370,20 +364,11 @@ where
}
}
impl<P> Read for SubstreamRef<P>
impl<P> Unpin for SubstreamRef<P>
where
P: Deref,
P::Target: StreamMuxer,
{
#[inline]
fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
let s = self.substream.as_mut().expect("substream was empty");
match self.muxer.read_substream(s, buf).map_err(|e| e.into())? {
Async::Ready(n) => Ok(n),
Async::NotReady => Err(io::ErrorKind::WouldBlock.into())
}
}
}
impl<P> AsyncRead for SubstreamRef<P>
@ -391,37 +376,13 @@ where
P: Deref,
P::Target: StreamMuxer,
{
unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
self.muxer.prepare_uninitialized_buffer(buf)
}
fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context, buf: &mut [u8]) -> Poll<Result<usize, io::Error>> {
// We use a `this` because the compiler isn't smart enough to allow mutably borrowing
// multiple different fields from the `Pin` at the same time.
let this = &mut *self;
fn poll_read(&mut self, buf: &mut [u8]) -> Poll<usize, io::Error> {
let s = self.substream.as_mut().expect("substream was empty");
self.muxer.read_substream(s, buf).map_err(|e| e.into())
}
}
impl<P> Write for SubstreamRef<P>
where
P: Deref,
P::Target: StreamMuxer,
{
#[inline]
fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
let s = self.substream.as_mut().expect("substream was empty");
match self.muxer.write_substream(s, buf).map_err(|e| e.into())? {
Async::Ready(n) => Ok(n),
Async::NotReady => Err(io::ErrorKind::WouldBlock.into())
}
}
#[inline]
fn flush(&mut self) -> Result<(), io::Error> {
let s = self.substream.as_mut().expect("substream was empty");
match self.muxer.flush_substream(s).map_err(|e| e.into())? {
Async::Ready(()) => Ok(()),
Async::NotReady => Err(io::ErrorKind::WouldBlock.into())
}
let s = this.substream.as_mut().expect("substream was empty");
this.muxer.read_substream(cx, s, buf).map_err(|e| e.into())
}
}
@ -430,36 +391,51 @@ where
P: Deref,
P::Target: StreamMuxer,
{
#[inline]
fn poll_write(&mut self, buf: &[u8]) -> Poll<usize, io::Error> {
let s = self.substream.as_mut().expect("substream was empty");
self.muxer.write_substream(s, buf).map_err(|e| e.into())
fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) -> Poll<Result<usize, io::Error>> {
// We use a `this` because the compiler isn't smart enough to allow mutably borrowing
// multiple different fields from the `Pin` at the same time.
let this = &mut *self;
let s = this.substream.as_mut().expect("substream was empty");
this.muxer.write_substream(cx, s, buf).map_err(|e| e.into())
}
#[inline]
fn shutdown(&mut self) -> Poll<(), io::Error> {
let s = self.substream.as_mut().expect("substream was empty");
fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), io::Error>> {
// We use a `this` because the compiler isn't smart enough to allow mutably borrowing
// multiple different fields from the `Pin` at the same time.
let this = &mut *self;
let s = this.substream.as_mut().expect("substream was empty");
loop {
match self.shutdown_state {
match this.shutdown_state {
ShutdownState::Shutdown => {
try_ready!(self.muxer.shutdown_substream(s).map_err(|e| e.into()));
self.shutdown_state = ShutdownState::Flush;
match this.muxer.shutdown_substream(cx, s) {
Poll::Ready(Ok(())) => this.shutdown_state = ShutdownState::Flush,
Poll::Ready(Err(err)) => return Poll::Ready(Err(err.into())),
Poll::Pending => return Poll::Pending,
}
}
ShutdownState::Flush => {
try_ready!(self.muxer.flush_substream(s).map_err(|e| e.into()));
self.shutdown_state = ShutdownState::Done;
match this.muxer.flush_substream(cx, s) {
Poll::Ready(Ok(())) => this.shutdown_state = ShutdownState::Done,
Poll::Ready(Err(err)) => return Poll::Ready(Err(err.into())),
Poll::Pending => return Poll::Pending,
}
}
ShutdownState::Done => {
return Ok(Async::Ready(()));
return Poll::Ready(Ok(()));
}
}
}
}
#[inline]
fn poll_flush(&mut self) -> Poll<(), io::Error> {
let s = self.substream.as_mut().expect("substream was empty");
self.muxer.flush_substream(s).map_err(|e| e.into())
fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), io::Error>> {
// We use a `this` because the compiler isn't smart enough to allow mutably borrowing
// multiple different fields from the `Pin` at the same time.
let this = &mut *self;
let s = this.substream.as_mut().expect("substream was empty");
this.muxer.flush_substream(cx, s).map_err(|e| e.into())
}
}
@ -507,8 +483,8 @@ impl StreamMuxer for StreamMuxerBox {
type Error = io::Error;
#[inline]
fn poll_inbound(&self) -> Poll<Self::Substream, Self::Error> {
self.inner.poll_inbound()
fn poll_inbound(&self, cx: &mut Context) -> Poll<Result<Self::Substream, Self::Error>> {
self.inner.poll_inbound(cx)
}
#[inline]
@ -517,8 +493,8 @@ impl StreamMuxer for StreamMuxerBox {
}
#[inline]
fn poll_outbound(&self, s: &mut Self::OutboundSubstream) -> Poll<Self::Substream, Self::Error> {
self.inner.poll_outbound(s)
fn poll_outbound(&self, cx: &mut Context, s: &mut Self::OutboundSubstream) -> Poll<Result<Self::Substream, Self::Error>> {
self.inner.poll_outbound(cx, s)
}
#[inline]
@ -526,28 +502,24 @@ impl StreamMuxer for StreamMuxerBox {
self.inner.destroy_outbound(substream)
}
unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
self.inner.prepare_uninitialized_buffer(buf)
#[inline]
fn read_substream(&self, cx: &mut Context, s: &mut Self::Substream, buf: &mut [u8]) -> Poll<Result<usize, Self::Error>> {
self.inner.read_substream(cx, s, buf)
}
#[inline]
fn read_substream(&self, s: &mut Self::Substream, buf: &mut [u8]) -> Poll<usize, Self::Error> {
self.inner.read_substream(s, buf)
fn write_substream(&self, cx: &mut Context, s: &mut Self::Substream, buf: &[u8]) -> Poll<Result<usize, Self::Error>> {
self.inner.write_substream(cx, s, buf)
}
#[inline]
fn write_substream(&self, s: &mut Self::Substream, buf: &[u8]) -> Poll<usize, Self::Error> {
self.inner.write_substream(s, buf)
fn flush_substream(&self, cx: &mut Context, s: &mut Self::Substream) -> Poll<Result<(), Self::Error>> {
self.inner.flush_substream(cx, s)
}
#[inline]
fn flush_substream(&self, s: &mut Self::Substream) -> Poll<(), Self::Error> {
self.inner.flush_substream(s)
}
#[inline]
fn shutdown_substream(&self, s: &mut Self::Substream) -> Poll<(), Self::Error> {
self.inner.shutdown_substream(s)
fn shutdown_substream(&self, cx: &mut Context, s: &mut Self::Substream) -> Poll<Result<(), Self::Error>> {
self.inner.shutdown_substream(cx, s)
}
#[inline]
@ -556,8 +528,8 @@ impl StreamMuxer for StreamMuxerBox {
}
#[inline]
fn close(&self) -> Poll<(), Self::Error> {
self.inner.close()
fn close(&self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
self.inner.close(cx)
}
#[inline]
@ -566,8 +538,8 @@ impl StreamMuxer for StreamMuxerBox {
}
#[inline]
fn flush_all(&self) -> Poll<(), Self::Error> {
self.inner.flush_all()
fn flush_all(&self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
self.inner.flush_all(cx)
}
}
@ -588,11 +560,16 @@ where
type Error = io::Error;
#[inline]
fn poll_inbound(&self) -> Poll<Self::Substream, Self::Error> {
let substream = try_ready!(self.inner.poll_inbound().map_err(|e| e.into()));
fn poll_inbound(&self, cx: &mut Context) -> Poll<Result<Self::Substream, Self::Error>> {
let substream = match self.inner.poll_inbound(cx) {
Poll::Pending => return Poll::Pending,
Poll::Ready(Ok(s)) => s,
Poll::Ready(Err(err)) => return Poll::Ready(Err(err.into())),
};
let id = self.next_substream.fetch_add(1, Ordering::Relaxed);
self.substreams.lock().insert(id, substream);
Ok(Async::Ready(id))
Poll::Ready(Ok(id))
}
#[inline]
@ -606,13 +583,18 @@ where
#[inline]
fn poll_outbound(
&self,
cx: &mut Context,
substream: &mut Self::OutboundSubstream,
) -> Poll<Self::Substream, Self::Error> {
) -> Poll<Result<Self::Substream, Self::Error>> {
let mut list = self.outbound.lock();
let substream = try_ready!(self.inner.poll_outbound(list.get_mut(substream).unwrap()).map_err(|e| e.into()));
let substream = match self.inner.poll_outbound(cx, list.get_mut(substream).unwrap()) {
Poll::Pending => return Poll::Pending,
Poll::Ready(Ok(s)) => s,
Poll::Ready(Err(err)) => return Poll::Ready(Err(err.into())),
};
let id = self.next_substream.fetch_add(1, Ordering::Relaxed);
self.substreams.lock().insert(id, substream);
Ok(Async::Ready(id))
Poll::Ready(Ok(id))
}
#[inline]
@ -621,32 +603,28 @@ where
self.inner.destroy_outbound(list.remove(&substream).unwrap())
}
unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
self.inner.prepare_uninitialized_buffer(buf)
#[inline]
fn read_substream(&self, cx: &mut Context, s: &mut Self::Substream, buf: &mut [u8]) -> Poll<Result<usize, Self::Error>> {
let mut list = self.substreams.lock();
self.inner.read_substream(cx, list.get_mut(s).unwrap(), buf).map_err(|e| e.into())
}
#[inline]
fn read_substream(&self, s: &mut Self::Substream, buf: &mut [u8]) -> Poll<usize, Self::Error> {
fn write_substream(&self, cx: &mut Context, s: &mut Self::Substream, buf: &[u8]) -> Poll<Result<usize, Self::Error>> {
let mut list = self.substreams.lock();
self.inner.read_substream(list.get_mut(s).unwrap(), buf).map_err(|e| e.into())
self.inner.write_substream(cx, list.get_mut(s).unwrap(), buf).map_err(|e| e.into())
}
#[inline]
fn write_substream(&self, s: &mut Self::Substream, buf: &[u8]) -> Poll<usize, Self::Error> {
fn flush_substream(&self, cx: &mut Context, s: &mut Self::Substream) -> Poll<Result<(), Self::Error>> {
let mut list = self.substreams.lock();
self.inner.write_substream(list.get_mut(s).unwrap(), buf).map_err(|e| e.into())
self.inner.flush_substream(cx, list.get_mut(s).unwrap()).map_err(|e| e.into())
}
#[inline]
fn flush_substream(&self, s: &mut Self::Substream) -> Poll<(), Self::Error> {
fn shutdown_substream(&self, cx: &mut Context, s: &mut Self::Substream) -> Poll<Result<(), Self::Error>> {
let mut list = self.substreams.lock();
self.inner.flush_substream(list.get_mut(s).unwrap()).map_err(|e| e.into())
}
#[inline]
fn shutdown_substream(&self, s: &mut Self::Substream) -> Poll<(), Self::Error> {
let mut list = self.substreams.lock();
self.inner.shutdown_substream(list.get_mut(s).unwrap()).map_err(|e| e.into())
self.inner.shutdown_substream(cx, list.get_mut(s).unwrap()).map_err(|e| e.into())
}
#[inline]
@ -656,8 +634,8 @@ where
}
#[inline]
fn close(&self) -> Poll<(), Self::Error> {
self.inner.close().map_err(|e| e.into())
fn close(&self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
self.inner.close(cx).map_err(|e| e.into())
}
#[inline]
@ -666,7 +644,7 @@ where
}
#[inline]
fn flush_all(&self) -> Poll<(), Self::Error> {
self.inner.flush_all().map_err(|e| e.into())
fn flush_all(&self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
self.inner.flush_all(cx).map_err(|e| e.into())
}
}

51
core/src/muxing/singleton.rs
View File

@ -21,8 +21,7 @@
use crate::{Endpoint, muxing::StreamMuxer};
use futures::prelude::*;
use parking_lot::Mutex;
use std::{io, sync::atomic::{AtomicBool, Ordering}};
use tokio_io::{AsyncRead, AsyncWrite};
use std::{io, pin::Pin, sync::atomic::{AtomicBool, Ordering}, task::Context, task::Poll};
/// Implementation of `StreamMuxer` that allows only one substream on top of a connection,
/// yielding the connection itself.
@ -62,22 +61,22 @@ pub struct OutboundSubstream {}
impl<TSocket> StreamMuxer for SingletonMuxer<TSocket>
where
TSocket: AsyncRead + AsyncWrite,
TSocket: AsyncRead + AsyncWrite + Unpin,
{
type Substream = Substream;
type OutboundSubstream = OutboundSubstream;
type Error = io::Error;
fn poll_inbound(&self) -> Poll<Self::Substream, io::Error> {
fn poll_inbound(&self, _: &mut Context) -> Poll<Result<Self::Substream, io::Error>> {
match self.endpoint {
Endpoint::Dialer => return Ok(Async::NotReady),
Endpoint::Dialer => return Poll::Pending,
Endpoint::Listener => {}
}
if !self.substream_extracted.swap(true, Ordering::Relaxed) {
Ok(Async::Ready(Substream {}))
Poll::Ready(Ok(Substream {}))
} else {
Ok(Async::NotReady)
Poll::Pending
}
}
@ -85,44 +84,40 @@ where
OutboundSubstream {}
}
fn poll_outbound(&self, _: &mut Self::OutboundSubstream) -> Poll<Self::Substream, io::Error> {
fn poll_outbound(&self, _: &mut Context, _: &mut Self::OutboundSubstream) -> Poll<Result<Self::Substream, io::Error>> {
match self.endpoint {
Endpoint::Listener => return Ok(Async::NotReady),
Endpoint::Listener => return Poll::Pending,
Endpoint::Dialer => {}
}
if !self.substream_extracted.swap(true, Ordering::Relaxed) {
Ok(Async::Ready(Substream {}))
Poll::Ready(Ok(Substream {}))
} else {
Ok(Async::NotReady)
Poll::Pending
}
}
fn destroy_outbound(&self, _: Self::OutboundSubstream) {
}
unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
self.inner.lock().prepare_uninitialized_buffer(buf)
}
fn read_substream(&self, _: &mut Self::Substream, buf: &mut [u8]) -> Poll<usize, io::Error> {
let res = self.inner.lock().poll_read(buf);
if let Ok(Async::Ready(_)) = res {
fn read_substream(&self, cx: &mut Context, _: &mut Self::Substream, buf: &mut [u8]) -> Poll<Result<usize, io::Error>> {
let res = AsyncRead::poll_read(Pin::new(&mut *self.inner.lock()), cx, buf);
if let Poll::Ready(Ok(_)) = res {
self.remote_acknowledged.store(true, Ordering::Release);
}
res
}
fn write_substream(&self, _: &mut Self::Substream, buf: &[u8]) -> Poll<usize, io::Error> {
self.inner.lock().poll_write(buf)
fn write_substream(&self, cx: &mut Context, _: &mut Self::Substream, buf: &[u8]) -> Poll<Result<usize, io::Error>> {
AsyncWrite::poll_write(Pin::new(&mut *self.inner.lock()), cx, buf)
}
fn flush_substream(&self, _: &mut Self::Substream) -> Poll<(), io::Error> {
self.inner.lock().poll_flush()
fn flush_substream(&self, cx: &mut Context, _: &mut Self::Substream) -> Poll<Result<(), io::Error>> {
AsyncWrite::poll_flush(Pin::new(&mut *self.inner.lock()), cx)
}
fn shutdown_substream(&self, _: &mut Self::Substream) -> Poll<(), io::Error> {
self.inner.lock().shutdown()
fn shutdown_substream(&self, cx: &mut Context, _: &mut Self::Substream) -> Poll<Result<(), io::Error>> {
AsyncWrite::poll_close(Pin::new(&mut *self.inner.lock()), cx)
}
fn destroy_substream(&self, _: Self::Substream) {
@ -132,12 +127,12 @@ where
self.remote_acknowledged.load(Ordering::Acquire)
}
fn close(&self) -> Poll<(), io::Error> {
fn close(&self, cx: &mut Context) -> Poll<Result<(), io::Error>> {
// The `StreamMuxer` trait requires that `close()` implies `flush_all()`.
self.flush_all()
self.flush_all(cx)
}
fn flush_all(&self) -> Poll<(), io::Error> {
self.inner.lock().poll_flush()
fn flush_all(&self, cx: &mut Context) -> Poll<Result<(), io::Error>> {
AsyncWrite::poll_flush(Pin::new(&mut *self.inner.lock()), cx)
}
}

74
core/src/nodes/collection.rs
View File

@ -29,11 +29,7 @@ use crate::{
};
use fnv::FnvHashMap;
use futures::prelude::*;
use std::{error, fmt, hash::Hash, mem};
pub use crate::nodes::tasks::StartTakeOver;
mod tests;
use std::{error, fmt, hash::Hash, mem, task::Context, task::Poll};
/// Implementation of `Stream` that handles a collection of nodes.
pub struct CollectionStream<TInEvent, TOutEvent, THandler, TReachErr, THandlerErr, TUserData, TConnInfo = PeerId, TPeerId = PeerId> {
@ -58,6 +54,9 @@ where
}
}
impl<TInEvent, TOutEvent, THandler, TReachErr, THandlerErr, TUserData, TConnInfo, TPeerId> Unpin for
CollectionStream<TInEvent, TOutEvent, THandler, TReachErr, THandlerErr, TUserData, TConnInfo, TPeerId> { }
/// State of a task.
#[derive(Debug, Clone, PartialEq, Eq)]
enum TaskState<TConnInfo, TUserData> {
@ -323,7 +322,7 @@ where
pub fn add_reach_attempt<TFut, TMuxer>(&mut self, future: TFut, handler: THandler)
-> ReachAttemptId
where
TFut: Future<Item = (TConnInfo, TMuxer), Error = TReachErr> + Send + 'static,
TFut: Future<Output = Result<(TConnInfo, TMuxer), TReachErr>> + Unpin + Send + 'static,
THandler: IntoNodeHandler<TConnInfo> + Send + 'static,
THandler::Handler: NodeHandler<Substream = Substream<TMuxer>, InEvent = TInEvent, OutEvent = TOutEvent, Error = THandlerErr> + Send + 'static,
<THandler::Handler as NodeHandler>::OutboundOpenInfo: Send + 'static,
@ -358,17 +357,15 @@ where
}
/// Sends an event to all nodes.
///
/// This function is "atomic", in the sense that if `Poll::Pending` is returned then no event
/// has been sent to any node yet.
#[must_use]
pub fn start_broadcast(&mut self, event: &TInEvent) -> AsyncSink<()>
pub fn poll_broadcast(&mut self, event: &TInEvent, cx: &mut Context) -> Poll<()>
where
TInEvent: Clone
{
self.inner.start_broadcast(event)
}
#[must_use]
pub fn complete_broadcast(&mut self) -> Async<()> {
self.inner.complete_broadcast()
self.inner.poll_broadcast(event, cx)
}
/// Adds an existing connection to a node to the collection.
@ -447,13 +444,13 @@ where
/// > **Note**: we use a regular `poll` method instead of implementing `Stream` in order to
/// > remove the `Err` variant, but also because we want the `CollectionStream` to stay
/// > borrowed if necessary.
pub fn poll(&mut self) -> Async<CollectionEvent<'_, TInEvent, TOutEvent, THandler, TReachErr, THandlerErr, TUserData, TConnInfo, TPeerId>>
pub fn poll(&mut self, cx: &mut Context) -> Poll<CollectionEvent<'_, TInEvent, TOutEvent, THandler, TReachErr, THandlerErr, TUserData, TConnInfo, TPeerId>>
where
TConnInfo: Clone, // TODO: Clone shouldn't be necessary
{
let item = match self.inner.poll() {
Async::Ready(item) => item,
Async::NotReady => return Async::NotReady,
let item = match self.inner.poll(cx) {
Poll::Ready(item) => item,
Poll::Pending => return Poll::Pending,
};
match item {
@ -463,7 +460,7 @@ where
match (user_data, result, handler) {
(TaskState::Pending, tasks::Error::Reach(err), Some(handler)) => {
Async::Ready(CollectionEvent::ReachError {
Poll::Ready(CollectionEvent::ReachError {
id: ReachAttemptId(id),
error: err,
handler,
@ -482,7 +479,7 @@ where
debug_assert!(_handler.is_none());
let _node_task_id = self.nodes.remove(conn_info.peer_id());
debug_assert_eq!(_node_task_id, Some(id));
Async::Ready(CollectionEvent::NodeClosed {
Poll::Ready(CollectionEvent::NodeClosed {
conn_info,
error: err,
user_data,
@ -497,8 +494,8 @@ where
tasks::Event::NodeReached { task, conn_info } => {
let id = task.id();
drop(task);
Async::Ready(CollectionEvent::NodeReached(CollectionReachEvent {
parent: self,
Poll::Ready(CollectionEvent::NodeReached(CollectionReachEvent {
parent: &mut *self,
id,
conn_info: Some(conn_info),
}))
@ -512,7 +509,7 @@ where
self.tasks is switched to the Connected state; QED"),
};
drop(task);
Async::Ready(CollectionEvent::NodeEvent {
Poll::Ready(CollectionEvent::NodeEvent {
// TODO: normally we'd build a `PeerMut` manually here, but the borrow checker
// doesn't like it
peer: self.peer_mut(&conn_info.peer_id())
@ -616,14 +613,15 @@ where
}
}
/// Sends an event to the given node.
pub fn start_send_event(&mut self, event: TInEvent) -> StartSend<TInEvent, ()> {
/// Begin sending an event to the given node. Must be called only after a successful call to
/// `poll_ready_event`.
pub fn start_send_event(&mut self, event: TInEvent) {
self.inner.start_send_event(event)
}
/// Complete sending an event message initiated by `start_send_event`.
pub fn complete_send_event(&mut self) -> Poll<(), ()> {
self.inner.complete_send_event()
/// Make sure we are ready to accept an event to be sent with `start_send_event`.
pub fn poll_ready_event(&mut self, cx: &mut Context) -> Poll<()> {
self.inner.poll_ready_event(cx)
}
/// Closes the connections to this node. Returns the user data.
@ -648,23 +646,13 @@ where
/// The reach attempt will only be effectively cancelled once the peer (the object you're
/// manipulating) has received some network activity. However no event will be ever be
/// generated from this reach attempt, and this takes effect immediately.
#[must_use]
pub fn start_take_over(&mut self, id: InterruptedReachAttempt<TInEvent, TConnInfo, TUserData>)
-> StartTakeOver<(), InterruptedReachAttempt<TInEvent, TConnInfo, TUserData>>
{
match self.inner.start_take_over(id.inner) {
StartTakeOver::Ready(_state) => {
debug_assert!(if let TaskState::Pending = _state { true } else { false });
StartTakeOver::Ready(())
}
StartTakeOver::NotReady(inner) =>
StartTakeOver::NotReady(InterruptedReachAttempt { inner }),
StartTakeOver::Gone => StartTakeOver::Gone
}
pub fn start_take_over(&mut self, id: InterruptedReachAttempt<TInEvent, TConnInfo, TUserData>) {
self.inner.start_take_over(id.inner)
}
/// Complete a take over initiated by `start_take_over`.
pub fn complete_take_over(&mut self) -> Poll<(), ()> {
self.inner.complete_take_over()
/// Make sure we are ready to taking over with `start_take_over`.
#[must_use]
pub fn poll_ready_take_over(&mut self, cx: &mut Context) -> Poll<()> {
self.inner.poll_ready_take_over(cx)
}
}

373
core/src/nodes/collection/tests.rs
View File

@ -1,373 +0,0 @@
// Copyright 2018 Parity Technologies (UK) Ltd.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
#![cfg(test)]
use super::*;
use assert_matches::assert_matches;
use futures::future;
use crate::tests::dummy_muxer::{DummyMuxer, DummyConnectionState};
use crate::tests::dummy_handler::{Handler, InEvent, OutEvent, HandlerState};
use tokio::runtime::current_thread::Runtime;
use tokio::runtime::Builder;
use crate::nodes::NodeHandlerEvent;
use std::{io, sync::Arc};
use parking_lot::Mutex;
type TestCollectionStream = CollectionStream<InEvent, OutEvent, Handler, io::Error, io::Error, ()>;
#[test]
fn has_connection_is_false_before_a_connection_has_been_made() {
let cs = TestCollectionStream::new();
let peer_id = PeerId::random();
assert!(!cs.has_connection(&peer_id));
}
#[test]
fn connections_is_empty_before_connecting() {
let cs = TestCollectionStream::new();
assert!(cs.connections().next().is_none());
}
#[test]
fn retrieving_a_peer_is_none_if_peer_is_missing_or_not_connected() {
let mut cs = TestCollectionStream::new();
let peer_id = PeerId::random();
assert!(cs.peer_mut(&peer_id).is_none());
let handler = Handler::default();
let fut = future::ok((peer_id.clone(), DummyMuxer::new()));
cs.add_reach_attempt(fut, handler);
assert!(cs.peer_mut(&peer_id).is_none()); // task is pending
}
#[test]
fn collection_stream_reaches_the_nodes() {
let mut cs = TestCollectionStream::new();
let peer_id = PeerId::random();
let mut muxer = DummyMuxer::new();
muxer.set_inbound_connection_state(DummyConnectionState::Pending);
muxer.set_outbound_connection_state(DummyConnectionState::Opened);
let fut = future::ok((peer_id, muxer));
cs.add_reach_attempt(fut, Handler::default());
let mut rt = Runtime::new().unwrap();
let mut poll_count = 0;
let fut = future::poll_fn(move || -> Poll<(), ()> {
poll_count += 1;
let event = cs.poll();
match poll_count {
1 => assert_matches!(event, Async::NotReady),
2 => {
assert_matches!(event, Async::Ready(CollectionEvent::NodeReached(_)));
return Ok(Async::Ready(())); // stop
}
_ => unreachable!()
}
Ok(Async::NotReady)
});
rt.block_on(fut).unwrap();
}
#[test]
fn accepting_a_node_yields_new_entry() {
let mut cs = TestCollectionStream::new();
let peer_id = PeerId::random();
let fut = future::ok((peer_id.clone(), DummyMuxer::new()));
cs.add_reach_attempt(fut, Handler::default());
let mut rt = Runtime::new().unwrap();
let mut poll_count = 0;
let fut = future::poll_fn(move || -> Poll<(), ()> {
poll_count += 1;
{
let event = cs.poll();
match poll_count {
1 => {
assert_matches!(event, Async::NotReady);
return Ok(Async::NotReady)
}
2 => {
assert_matches!(event, Async::Ready(CollectionEvent::NodeReached(reach_ev)) => {
let (accept_ev, accepted_peer_id) = reach_ev.accept(());
assert_eq!(accepted_peer_id, peer_id);
assert_matches!(accept_ev, CollectionNodeAccept::NewEntry);
});
}
_ => unreachable!()
}
}
assert!(cs.peer_mut(&peer_id).is_some(), "peer is not in the list");
assert!(cs.has_connection(&peer_id), "peer is not connected");
assert_eq!(cs.connections().collect::<Vec<&PeerId>>(), vec![&peer_id]);
Ok(Async::Ready(()))
});
rt.block_on(fut).expect("running the future works");
}
#[test]
fn events_in_a_node_reaches_the_collection_stream() {
let cs = Arc::new(Mutex::new(TestCollectionStream::new()));
let task_peer_id = PeerId::random();
let mut handler = Handler::default();
handler.state = Some(HandlerState::Ready(NodeHandlerEvent::Custom(OutEvent::Custom("init"))));
let handler_states = vec![
HandlerState::Err,
HandlerState::Ready(NodeHandlerEvent::Custom(OutEvent::Custom("from handler 3") )),
HandlerState::Ready(NodeHandlerEvent::Custom(OutEvent::Custom("from handler 2") )),
HandlerState::Ready(NodeHandlerEvent::Custom(OutEvent::Custom("from handler 1") )),
];
handler.next_states = handler_states;
let mut muxer = DummyMuxer::new();
muxer.set_inbound_connection_state(DummyConnectionState::Pending);
muxer.set_outbound_connection_state(DummyConnectionState::Opened);
let fut = future::ok((task_peer_id.clone(), muxer));
cs.lock().add_reach_attempt(fut, handler);
let mut rt = Builder::new().core_threads(1).build().unwrap();
let cs_fut = cs.clone();
rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut cs = cs_fut.lock();
assert_matches!(cs.poll(), Async::NotReady);
Ok(Async::Ready(()))
})).expect("tokio works");
let cs2 = cs.clone();
rt.block_on(future::poll_fn(move || {
if cs2.lock().start_broadcast(&InEvent::NextState).is_not_ready() {
Ok::<_, ()>(Async::NotReady)
} else {
Ok(Async::Ready(()))
}
})).unwrap();
let cs_fut = cs.clone();
rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut cs = cs_fut.lock();
if cs.complete_broadcast().is_not_ready() {
return Ok(Async::NotReady)
}
assert_matches!(cs.poll(), Async::Ready(CollectionEvent::NodeReached(reach_ev)) => {
reach_ev.accept(());
});
Ok(Async::Ready(()))
})).expect("tokio works");
let cs2 = cs.clone();
rt.block_on(future::poll_fn(move || {
if cs2.lock().start_broadcast(&InEvent::NextState).is_not_ready() {
Ok::<_, ()>(Async::NotReady)
} else {
Ok(Async::Ready(()))
}
})).unwrap();
let cs_fut = cs.clone();
rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut cs = cs_fut.lock();
if cs.complete_broadcast().is_not_ready() {
return Ok(Async::NotReady)
}
assert_matches!(cs.poll(), Async::Ready(CollectionEvent::NodeEvent{peer: _, event}) => {
assert_matches!(event, OutEvent::Custom("init"));
});
Ok(Async::Ready(()))
})).expect("tokio works");
let cs2 = cs.clone();
rt.block_on(future::poll_fn(move || {
if cs2.lock().start_broadcast(&InEvent::NextState).is_not_ready() {
Ok::<_, ()>(Async::NotReady)
} else {
Ok(Async::Ready(()))
}
})).unwrap();
let cs_fut = cs.clone();
rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut cs = cs_fut.lock();
if cs.complete_broadcast().is_not_ready() {
return Ok(Async::NotReady)
}
assert_matches!(cs.poll(), Async::Ready(CollectionEvent::NodeEvent{peer: _, event}) => {
assert_matches!(event, OutEvent::Custom("from handler 1"));
});
Ok(Async::Ready(()))
})).expect("tokio works");
let cs2 = cs.clone();
rt.block_on(future::poll_fn(move || {
if cs2.lock().start_broadcast(&InEvent::NextState).is_not_ready() {
Ok::<_, ()>(Async::NotReady)
} else {
Ok(Async::Ready(()))
}
})).unwrap();
let cs_fut = cs.clone();
rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut cs = cs_fut.lock();
if cs.complete_broadcast().is_not_ready() {
return Ok(Async::NotReady)
}
assert_matches!(cs.poll(), Async::Ready(CollectionEvent::NodeEvent{peer: _, event}) => {
assert_matches!(event, OutEvent::Custom("from handler 2"));
});
Ok(Async::Ready(()))
})).expect("tokio works");
}
#[test]
fn task_closed_with_error_while_task_is_pending_yields_reach_error() {
let cs = Arc::new(Mutex::new(TestCollectionStream::new()));
let task_inner_fut = future::err(std::io::Error::new(std::io::ErrorKind::Other, "inner fut error"));
let reach_attempt_id = cs.lock().add_reach_attempt(task_inner_fut, Handler::default());
let mut rt = Builder::new().core_threads(1).build().unwrap();
let cs_fut = cs.clone();
rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut cs = cs_fut.lock();
assert_matches!(cs.poll(), Async::NotReady);
Ok(Async::Ready(()))
})).expect("tokio works");
let cs_fut = cs.clone();
rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut cs = cs_fut.lock();
assert_matches!(cs.poll(), Async::Ready(collection_ev) => {
assert_matches!(collection_ev, CollectionEvent::ReachError {id, error, ..} => {
assert_eq!(id, reach_attempt_id);
assert_eq!(error.to_string(), "inner fut error");
});
});
Ok(Async::Ready(()))
})).expect("tokio works");
}
#[test]
fn task_closed_with_error_when_task_is_connected_yields_node_error() {
let cs = Arc::new(Mutex::new(TestCollectionStream::new()));
let peer_id = PeerId::random();
let muxer = DummyMuxer::new();
let task_inner_fut = future::ok((peer_id.clone(), muxer));
let mut handler = Handler::default();
handler.next_states = vec![HandlerState::Err]; // triggered when sending a NextState event
cs.lock().add_reach_attempt(task_inner_fut, handler);
let mut rt = Builder::new().core_threads(1).build().unwrap();
// Kick it off
let cs2 = cs.clone();
rt.block_on(future::poll_fn(move || {
if cs2.lock().start_broadcast(&InEvent::NextState).is_not_ready() {
Ok::<_, ()>(Async::NotReady)
} else {
Ok(Async::Ready(()))
}
})).unwrap();
let cs_fut = cs.clone();
rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut cs = cs_fut.lock();
assert_matches!(cs.poll(), Async::NotReady);
// send an event so the Handler errors in two polls
Ok(cs.complete_broadcast())
})).expect("tokio works");
// Accept the new node
let cs_fut = cs.clone();
rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut cs = cs_fut.lock();
// NodeReached, accept the connection so the task transitions from Pending to Connected
assert_matches!(cs.poll(), Async::Ready(CollectionEvent::NodeReached(reach_ev)) => {
reach_ev.accept(());
});
Ok(Async::Ready(()))
})).expect("tokio works");
assert!(cs.lock().has_connection(&peer_id));
// Assert the node errored
let cs_fut = cs.clone();
rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut cs = cs_fut.lock();
assert_matches!(cs.poll(), Async::Ready(collection_ev) => {
assert_matches!(collection_ev, CollectionEvent::NodeClosed{..});
});
Ok(Async::Ready(()))
})).expect("tokio works");
}
#[test]
fn interrupting_a_pending_connection_attempt_is_ok() {
let mut cs = TestCollectionStream::new();
let fut = future::empty();
let reach_id = cs.add_reach_attempt(fut, Handler::default());
let interrupt = cs.interrupt(reach_id);
assert!(interrupt.is_ok());
}
#[test]
fn interrupting_a_connection_attempt_twice_is_err() {
let mut cs = TestCollectionStream::new();
let fut = future::empty();
let reach_id = cs.add_reach_attempt(fut, Handler::default());
assert!(cs.interrupt(reach_id).is_ok());
assert_matches!(cs.interrupt(reach_id), Err(InterruptError::ReachAttemptNotFound))
}
#[test]
fn interrupting_an_established_connection_is_err() {
let cs = Arc::new(Mutex::new(TestCollectionStream::new()));
let peer_id = PeerId::random();
let muxer = DummyMuxer::new();
let task_inner_fut = future::ok((peer_id.clone(), muxer));
let handler = Handler::default();
let reach_id = cs.lock().add_reach_attempt(task_inner_fut, handler);
let mut rt = Builder::new().core_threads(1).build().unwrap();
// Kick it off
let cs_fut = cs.clone();
rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut cs = cs_fut.lock();
assert_matches!(cs.poll(), Async::NotReady);
// send an event so the Handler errors in two polls
Ok(Async::Ready(()))
})).expect("tokio works");
// Accept the new node
let cs_fut = cs.clone();
rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut cs = cs_fut.lock();
// NodeReached, accept the connection so the task transitions from Pending to Connected
assert_matches!(cs.poll(), Async::Ready(CollectionEvent::NodeReached(reach_ev)) => {
reach_ev.accept(());
});
Ok(Async::Ready(()))
})).expect("tokio works");
assert!(cs.lock().has_connection(&peer_id), "Connection was not established");
assert_matches!(cs.lock().interrupt(reach_id), Err(InterruptError::AlreadyReached));
}

41
core/src/nodes/handled_node.rs
View File

@ -20,10 +20,7 @@
use crate::{PeerId, muxing::StreamMuxer};
use crate::nodes::node::{NodeEvent, NodeStream, Substream, Close};
use futures::prelude::*;
use std::{error, fmt, io};
mod tests;
use std::{error, fmt, io, pin::Pin, task::Context, task::Poll};
/// Handler for the substreams of a node.
// TODO: right now it is possible for a node handler to be built, then shut down right after if we
@ -59,7 +56,8 @@ pub trait NodeHandler {
/// Should behave like `Stream::poll()`.
///
/// Returning an error will close the connection to the remote.
fn poll(&mut self) -> Poll<NodeHandlerEvent<Self::OutboundOpenInfo, Self::OutEvent>, Self::Error>;
fn poll(&mut self, cx: &mut Context)
-> Poll<Result<NodeHandlerEvent<Self::OutboundOpenInfo, Self::OutEvent>, Self::Error>>;
}
/// Prototype for a `NodeHandler`.
@ -172,6 +170,13 @@ where
}
}
impl<TMuxer, THandler> Unpin for HandledNode<TMuxer, THandler>
where
TMuxer: StreamMuxer,
THandler: NodeHandler<Substream = Substream<TMuxer>>,
{
}
impl<TMuxer, THandler> HandledNode<TMuxer, THandler>
where
TMuxer: StreamMuxer,
@ -214,37 +219,41 @@ where
}
/// API similar to `Future::poll` that polls the node for events.
pub fn poll(&mut self) -> Poll<THandler::OutEvent, HandledNodeError<THandler::Error>> {
pub fn poll(mut self: Pin<&mut Self>, cx: &mut Context)
-> Poll<Result<THandler::OutEvent, HandledNodeError<THandler::Error>>>
{
loop {
let mut node_not_ready = false;
match self.node.poll().map_err(HandledNodeError::Node)? {
Async::NotReady => node_not_ready = true,
Async::Ready(NodeEvent::InboundSubstream { substream }) => {
match self.node.poll(cx) {
Poll::Pending => node_not_ready = true,
Poll::Ready(Ok(NodeEvent::InboundSubstream { substream })) => {
self.handler.inject_substream(substream, NodeHandlerEndpoint::Listener)
}
Async::Ready(NodeEvent::OutboundSubstream { user_data, substream }) => {
Poll::Ready(Ok(NodeEvent::OutboundSubstream { user_data, substream })) => {
let endpoint = NodeHandlerEndpoint::Dialer(user_data);
self.handler.inject_substream(substream, endpoint)
}
Poll::Ready(Err(err)) => return Poll::Ready(Err(HandledNodeError::Node(err))),
}
match self.handler.poll().map_err(HandledNodeError::Handler)? {
Async::NotReady => {
match self.handler.poll(cx) {
Poll::Pending => {
if node_not_ready {
break
}
}
Async::Ready(NodeHandlerEvent::OutboundSubstreamRequest(user_data)) => {
Poll::Ready(Ok(NodeHandlerEvent::OutboundSubstreamRequest(user_data))) => {
self.node.open_substream(user_data);
}
Async::Ready(NodeHandlerEvent::Custom(event)) => {
return Ok(Async::Ready(event));
Poll::Ready(Ok(NodeHandlerEvent::Custom(event))) => {
return Poll::Ready(Ok(event));
}
Poll::Ready(Err(err)) => return Poll::Ready(Err(HandledNodeError::Handler(err))),
}
}
Ok(Async::NotReady)
Poll::Pending
}
}

170
core/src/nodes/handled_node/tests.rs
View File

@ -1,170 +0,0 @@
// Copyright 2018 Parity Technologies (UK) Ltd.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
#![cfg(test)]
use super::*;
use assert_matches::assert_matches;
use crate::tests::dummy_muxer::{DummyMuxer, DummyConnectionState};
use crate::tests::dummy_handler::{Handler, HandlerState, InEvent, OutEvent, TestHandledNode};
struct TestBuilder {
muxer: DummyMuxer,
handler: Handler,
want_open_substream: bool,
substream_user_data: usize,
}
impl TestBuilder {
fn new() -> Self {
TestBuilder {
muxer: DummyMuxer::new(),
handler: Handler::default(),
want_open_substream: false,
substream_user_data: 0,
}
}
fn with_muxer_inbound_state(&mut self, state: DummyConnectionState) -> &mut Self {
self.muxer.set_inbound_connection_state(state);
self
}
fn with_muxer_outbound_state(&mut self, state: DummyConnectionState) -> &mut Self {
self.muxer.set_outbound_connection_state(state);
self
}
fn with_handler_state(&mut self, state: HandlerState) -> &mut Self {
self.handler.state = Some(state);
self
}
fn with_open_substream(&mut self, user_data: usize) -> &mut Self {
self.want_open_substream = true;
self.substream_user_data = user_data;
self
}
fn handled_node(&mut self) -> TestHandledNode {
let mut h = HandledNode::new(self.muxer.clone(), self.handler.clone());
if self.want_open_substream {
h.node.open_substream(self.substream_user_data);
}
h
}
}
// Set the state of the `Handler` after `inject_outbound_closed` is called
fn set_next_handler_outbound_state( handled_node: &mut TestHandledNode, next_state: HandlerState) {
handled_node.handler.next_outbound_state = Some(next_state);
}
#[test]
fn can_inject_event() {
let mut handled = TestBuilder::new()
.handled_node();
let event = InEvent::Custom("banana");
handled.inject_event(event.clone());
assert_eq!(handled.handler().events, vec![event]);
}
#[test]
fn poll_with_unready_node_stream_and_handler_emits_custom_event() {
let expected_event = NodeHandlerEvent::Custom(OutEvent::Custom("pineapple"));
let mut handled = TestBuilder::new()
// make NodeStream return NotReady
.with_muxer_inbound_state(DummyConnectionState::Pending)
// make Handler return return Ready(Some(…))
.with_handler_state(HandlerState::Ready(expected_event))
.handled_node();
assert_matches!(handled.poll(), Ok(Async::Ready(event)) => {
assert_matches!(event, OutEvent::Custom("pineapple"))
});
}
#[test]
fn handler_emits_outbound_closed_when_opening_new_substream_on_closed_node() {
let open_event = NodeHandlerEvent::OutboundSubstreamRequest(456);
let mut handled = TestBuilder::new()
.with_muxer_inbound_state(DummyConnectionState::Pending)
.with_muxer_outbound_state(DummyConnectionState::Pending)
.with_handler_state(HandlerState::Ready(open_event))
.handled_node();
set_next_handler_outbound_state(
&mut handled,
HandlerState::Ready(NodeHandlerEvent::Custom(OutEvent::Custom("pear")))
);
handled.poll().expect("poll works");
}
#[test]
fn poll_yields_inbound_closed_event() {
let mut h = TestBuilder::new()
.with_muxer_inbound_state(DummyConnectionState::Pending)
.with_handler_state(HandlerState::Err) // stop the loop
.handled_node();
assert_eq!(h.handler().events, vec![]);
let _ = h.poll();
}
#[test]
fn poll_yields_outbound_closed_event() {
let mut h = TestBuilder::new()
.with_muxer_inbound_state(DummyConnectionState::Pending)
.with_open_substream(32)
.with_muxer_outbound_state(DummyConnectionState::Pending)
.with_handler_state(HandlerState::Err) // stop the loop
.handled_node();
assert_eq!(h.handler().events, vec![]);
let _ = h.poll();
}
#[test]
fn poll_yields_outbound_substream() {
let mut h = TestBuilder::new()
.with_muxer_inbound_state(DummyConnectionState::Pending)
.with_muxer_outbound_state(DummyConnectionState::Opened)
.with_open_substream(1)
.with_handler_state(HandlerState::Err) // stop the loop
.handled_node();
assert_eq!(h.handler().events, vec![]);
let _ = h.poll();
assert_eq!(h.handler().events, vec![InEvent::Substream(Some(1))]);
}
#[test]
fn poll_yields_inbound_substream() {
let mut h = TestBuilder::new()
.with_muxer_inbound_state(DummyConnectionState::Opened)
.with_muxer_outbound_state(DummyConnectionState::Pending)
.with_handler_state(HandlerState::Err) // stop the loop
.handled_node();
assert_eq!(h.handler().events, vec![]);
let _ = h.poll();
assert_eq!(h.handler().events, vec![InEvent::Substream(None)]);
}

331
core/src/nodes/listeners.rs
View File

@ -21,11 +21,10 @@
//! Manage listening on multiple multiaddresses at once.
use crate::{Multiaddr, Transport, transport::{TransportError, ListenerEvent}};
use futures::prelude::*;
use futures::{prelude::*, task::Context, task::Poll};
use log::debug;
use smallvec::SmallVec;
use std::{collections::VecDeque, fmt};
use void::Void;
use std::{collections::VecDeque, fmt, pin::Pin};
/// Implementation of `futures::Stream` that allows listening on multiaddresses.
///
@ -52,32 +51,30 @@ use void::Void;
/// listeners.listen_on("/ip4/0.0.0.0/tcp/0".parse().unwrap()).unwrap();
///
/// // The `listeners` will now generate events when polled.
/// let future = listeners.for_each(move |event| {
/// match event {
/// ListenersEvent::NewAddress { listener_id, listen_addr } => {
/// println!("Listener {:?} is listening at address {}", listener_id, listen_addr);
/// },
/// ListenersEvent::AddressExpired { listener_id, listen_addr } => {
/// println!("Listener {:?} is no longer listening at address {}", listener_id, listen_addr);
/// },
/// ListenersEvent::Closed { listener_id, .. } => {
/// println!("Listener {:?} has been closed", listener_id);
/// },
/// ListenersEvent::Error { listener_id, error } => {
/// println!("Listener {:?} has experienced an error: {}", listener_id, error);
/// },
/// ListenersEvent::Incoming { listener_id, upgrade, local_addr, .. } => {
/// println!("Listener {:?} has a new connection on {}", listener_id, local_addr);
/// // We don't do anything with the newly-opened connection, but in a real-life
/// // program you probably want to use it!
/// drop(upgrade);
/// },
/// };
///
/// Ok(())
/// });
///
/// tokio::run(future.map_err(|_| ()));
/// futures::executor::block_on(async move {
/// while let Some(event) = listeners.next().await {
/// match event {
/// ListenersEvent::NewAddress { listener_id, listen_addr } => {
/// println!("Listener {:?} is listening at address {}", listener_id, listen_addr);
/// },
/// ListenersEvent::AddressExpired { listener_id, listen_addr } => {
/// println!("Listener {:?} is no longer listening at address {}", listener_id, listen_addr);
/// },
/// ListenersEvent::Closed { listener_id, .. } => {
/// println!("Listener {:?} has been closed", listener_id);
/// },
/// ListenersEvent::Error { listener_id, error } => {
/// println!("Listener {:?} has experienced an error: {}", listener_id, error);
/// },
/// ListenersEvent::Incoming { listener_id, upgrade, local_addr, .. } => {
/// println!("Listener {:?} has a new connection on {}", listener_id, local_addr);
/// // We don't do anything with the newly-opened connection, but in a real-life
/// // program you probably want to use it!
/// drop(upgrade);
/// },
/// }
/// }
/// })
/// # }
/// ```
pub struct ListenersStream<TTrans>
@ -158,7 +155,7 @@ where
/// The ID of the listener that errored.
listener_id: ListenerId,
/// The error value.
error: <TTrans::Listener as Stream>::Error
error: <TTrans::Listener as TryStream>::Error
}
}
@ -222,28 +219,31 @@ where
self.listeners.iter().flat_map(|l| l.addresses.iter())
}
/// Provides an API similar to `Stream`, except that it cannot error.
pub fn poll(&mut self) -> Async<ListenersEvent<TTrans>> {
/// 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>>
where
TTrans::Listener: Unpin,
{
// 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() {
match listener.listener.poll() {
Ok(Async::NotReady) => {
match TryStream::try_poll_next(Pin::new(&mut listener.listener), cx) {
Poll::Pending => {
self.listeners.push_front(listener);
remaining -= 1;
if remaining == 0 { break }
}
Ok(Async::Ready(Some(ListenerEvent::Upgrade { upgrade, local_addr, remote_addr }))) => {
Poll::Ready(Some(Ok(ListenerEvent::Upgrade { upgrade, local_addr, remote_addr }))) => {
let id = listener.id;
self.listeners.push_front(listener);
return Async::Ready(ListenersEvent::Incoming {
return Poll::Ready(ListenersEvent::Incoming {
listener_id: id,
upgrade,
local_addr,
send_back_addr: remote_addr
})
}
Ok(Async::Ready(Some(ListenerEvent::NewAddress(a)))) => {
Poll::Ready(Some(Ok(ListenerEvent::NewAddress(a)))) => {
if listener.addresses.contains(&a) {
debug!("Transport has reported address {} multiple times", a)
}
@ -252,28 +252,28 @@ where
}
let id = listener.id;
self.listeners.push_front(listener);
return Async::Ready(ListenersEvent::NewAddress {
return Poll::Ready(ListenersEvent::NewAddress {
listener_id: id,
listen_addr: a
})
}
Ok(Async::Ready(Some(ListenerEvent::AddressExpired(a)))) => {
Poll::Ready(Some(Ok(ListenerEvent::AddressExpired(a)))) => {
listener.addresses.retain(|x| x != &a);
let id = listener.id;
self.listeners.push_front(listener);
return Async::Ready(ListenersEvent::AddressExpired {
return Poll::Ready(ListenersEvent::AddressExpired {
listener_id: id,
listen_addr: a
})
}
Ok(Async::Ready(None)) => {
return Async::Ready(ListenersEvent::Closed {
Poll::Ready(None) => {
return Poll::Ready(ListenersEvent::Closed {
listener_id: listener.id,
listener: listener.listener
})
}
Err(err) => {
return Async::Ready(ListenersEvent::Error {
Poll::Ready(Some(Err(err))) => {
return Poll::Ready(ListenersEvent::Error {
listener_id: listener.id,
error: err
})
@ -282,22 +282,28 @@ where
}
// We register the current task to be woken up if a new listener is added.
Async::NotReady
Poll::Pending
}
}
impl<TTrans> Stream for ListenersStream<TTrans>
where
TTrans: Transport,
TTrans::Listener: Unpin,
{
type Item = ListenersEvent<TTrans>;
type Error = Void; // TODO: use ! once stable
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
Ok(self.poll().map(Option::Some))
fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
ListenersStream::poll(self, cx).map(Option::Some)
}
}
impl<TTrans> Unpin for ListenersStream<TTrans>
where
TTrans: Transport,
{
}
impl<TTrans> fmt::Debug for ListenersStream<TTrans>
where
TTrans: Transport + fmt::Debug,
@ -313,7 +319,7 @@ where
impl<TTrans> fmt::Debug for ListenersEvent<TTrans>
where
TTrans: Transport,
<TTrans::Listener as Stream>::Error: fmt::Debug,
<TTrans::Listener as TryStream>::Error: fmt::Debug,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
match self {
@ -348,220 +354,37 @@ where
#[cfg(test)]
mod tests {
use super::*;
use crate::transport::{self, ListenerEvent};
use assert_matches::assert_matches;
use tokio::runtime::current_thread::Runtime;
use std::{io, iter::FromIterator};
use futures::{future::{self}, stream};
use crate::tests::dummy_transport::{DummyTransport, ListenerState};
use crate::tests::dummy_muxer::DummyMuxer;
use crate::PeerId;
fn set_listener_state(ls: &mut ListenersStream<DummyTransport>, idx: usize, state: ListenerState) {
ls.listeners[idx].listener = match state {
ListenerState::Error =>
Box::new(stream::poll_fn(|| Err(io::Error::new(io::ErrorKind::Other, "oh noes")))),
ListenerState::Ok(state) => match state {
Async::NotReady => Box::new(stream::poll_fn(|| Ok(Async::NotReady))),
Async::Ready(Some(event)) => Box::new(stream::poll_fn(move || {
Ok(Async::Ready(Some(event.clone().map(future::ok))))
})),
Async::Ready(None) => Box::new(stream::empty())
}
ListenerState::Events(events) =>
Box::new(stream::iter_ok(events.into_iter().map(|e| e.map(future::ok))))
};
}
use crate::transport;
#[test]
fn incoming_event() {
let mem_transport = transport::MemoryTransport::default();
async_std::task::block_on(async move {
let mem_transport = transport::MemoryTransport::default();
let mut listeners = ListenersStream::new(mem_transport);
listeners.listen_on("/memory/0".parse().unwrap()).unwrap();
let mut listeners = ListenersStream::new(mem_transport);
listeners.listen_on("/memory/0".parse().unwrap()).unwrap();
let address = {
let event = listeners.by_ref().wait().next().expect("some event").expect("no error");
if let ListenersEvent::NewAddress { listen_addr, .. } = event {
listen_addr
} else {
panic!("Was expecting the listen address to be reported")
}
};
let dial = mem_transport.dial(address.clone()).unwrap();
let future = listeners
.into_future()
.map_err(|(err, _)| err)
.and_then(|(event, _)| {
match event {
Some(ListenersEvent::Incoming { local_addr, upgrade, send_back_addr, .. }) => {
assert_eq!(local_addr, address);
assert_eq!(send_back_addr, address);
upgrade.map(|_| ()).map_err(|_| panic!())
},
_ => panic!()
let address = {
let event = listeners.next().await.unwrap();
if let ListenersEvent::NewAddress { listen_addr, .. } = event {
listen_addr
} else {
panic!("Was expecting the listen address to be reported")
}
})
.select(dial.map(|_| ()).map_err(|_| panic!()))
.map_err(|(err, _)| err);
};
let mut runtime = Runtime::new().unwrap();
let _ = runtime.block_on(future).unwrap();
}
let address2 = address.clone();
async_std::task::spawn(async move {
mem_transport.dial(address2).unwrap().await.unwrap();
});
#[test]
fn listener_stream_returns_transport() {
let t = DummyTransport::new();
let t_clone = t.clone();
let ls = ListenersStream::new(t);
assert_eq!(ls.transport(), &t_clone);
}
#[test]
fn listener_stream_can_iterate_over_listeners() {
let mut t = DummyTransport::new();
let addr1 = tcp4([127, 0, 0, 1], 1234);
let addr2 = tcp4([127, 0, 0, 1], 4321);
t.set_initial_listener_state(ListenerState::Events(vec![
ListenerEvent::NewAddress(addr1.clone()),
ListenerEvent::NewAddress(addr2.clone())
]));
let mut ls = ListenersStream::new(t);
ls.listen_on(tcp4([0, 0, 0, 0], 0)).expect("listen_on");
assert_matches!(ls.by_ref().wait().next(), Some(Ok(ListenersEvent::NewAddress { listen_addr, .. })) => {
assert_eq!(addr1, listen_addr)
});
assert_matches!(ls.by_ref().wait().next(), Some(Ok(ListenersEvent::NewAddress { listen_addr, .. })) => {
assert_eq!(addr2, listen_addr)
})
}
#[test]
fn listener_stream_poll_without_listeners_is_not_ready() {
let t = DummyTransport::new();
let mut ls = ListenersStream::new(t);
assert_matches!(ls.poll(), Async::NotReady);
}
#[test]
fn listener_stream_poll_with_listeners_that_arent_ready_is_not_ready() {
let t = DummyTransport::new();
let addr = tcp4([127, 0, 0, 1], 1234);
let mut ls = ListenersStream::new(t);
ls.listen_on(addr).expect("listen_on failed");
set_listener_state(&mut ls, 0, ListenerState::Ok(Async::NotReady));
assert_matches!(ls.poll(), Async::NotReady);
assert_eq!(ls.listeners.len(), 1); // listener is still there
}
#[test]
fn listener_stream_poll_with_ready_listeners_is_ready() {
let mut t = DummyTransport::new();
let peer_id = PeerId::random();
let muxer = DummyMuxer::new();
let expected_output = (peer_id.clone(), muxer.clone());
t.set_initial_listener_state(ListenerState::Events(vec![
ListenerEvent::NewAddress(tcp4([127, 0, 0, 1], 9090)),
ListenerEvent::Upgrade {
upgrade: (peer_id.clone(), muxer.clone()),
local_addr: tcp4([127, 0, 0, 1], 9090),
remote_addr: tcp4([127, 0, 0, 1], 32000)
},
ListenerEvent::Upgrade {
upgrade: (peer_id.clone(), muxer.clone()),
local_addr: tcp4([127, 0, 0, 1], 9090),
remote_addr: tcp4([127, 0, 0, 1], 32000)
},
ListenerEvent::Upgrade {
upgrade: (peer_id.clone(), muxer.clone()),
local_addr: tcp4([127, 0, 0, 1], 9090),
remote_addr: tcp4([127, 0, 0, 1], 32000)
match listeners.next().await.unwrap() {
ListenersEvent::Incoming { local_addr, send_back_addr, .. } => {
assert_eq!(local_addr, address);
assert_eq!(send_back_addr, address);
},
_ => panic!()
}
]));
let mut ls = ListenersStream::new(t);
ls.listen_on(tcp4([127, 0, 0, 1], 1234)).expect("listen_on");
ls.listen_on(tcp4([127, 0, 0, 1], 4321)).expect("listen_on");
assert_eq!(ls.listeners.len(), 2);
assert_matches!(ls.by_ref().wait().next(), Some(Ok(listeners_event)) => {
assert_matches!(listeners_event, ListenersEvent::NewAddress { .. })
});
assert_matches!(ls.by_ref().wait().next(), Some(Ok(listeners_event)) => {
assert_matches!(listeners_event, ListenersEvent::NewAddress { .. })
});
assert_matches!(ls.by_ref().wait().next(), Some(Ok(listeners_event)) => {
assert_matches!(listeners_event, ListenersEvent::Incoming { upgrade, .. } => {
assert_matches!(upgrade.wait(), Ok(output) => {
assert_eq!(output, expected_output)
});
})
});
assert_matches!(ls.by_ref().wait().next(), Some(Ok(listeners_event)) => {
assert_matches!(listeners_event, ListenersEvent::Incoming { upgrade, .. } => {
assert_matches!(upgrade.wait(), Ok(output) => {
assert_eq!(output, expected_output)
});
})
});
set_listener_state(&mut ls, 1, ListenerState::Ok(Async::NotReady));
assert_matches!(ls.by_ref().wait().next(), Some(Ok(listeners_event)) => {
assert_matches!(listeners_event, ListenersEvent::Incoming { upgrade, .. } => {
assert_matches!(upgrade.wait(), Ok(output) => {
assert_eq!(output, expected_output)
});
})
});
}
#[test]
fn listener_stream_poll_with_closed_listener_emits_closed_event() {
let t = DummyTransport::new();
let addr = tcp4([127, 0, 0, 1], 1234);
let mut ls = ListenersStream::new(t);
ls.listen_on(addr).expect("listen_on failed");
set_listener_state(&mut ls, 0, ListenerState::Ok(Async::Ready(None)));
assert_matches!(ls.by_ref().wait().next(), Some(Ok(listeners_event)) => {
assert_matches!(listeners_event, ListenersEvent::Closed{..})
});
assert_eq!(ls.listeners.len(), 0); // it's gone
}
#[test]
fn listener_stream_poll_with_erroring_listener_emits_error_event() {
let mut t = DummyTransport::new();
let peer_id = PeerId::random();
let muxer = DummyMuxer::new();
let event = ListenerEvent::Upgrade {
upgrade: (peer_id, muxer),
local_addr: tcp4([127, 0, 0, 1], 1234),
remote_addr: tcp4([127, 0, 0, 1], 32000)
};
t.set_initial_listener_state(ListenerState::Ok(Async::Ready(Some(event))));
let addr = tcp4([127, 0, 0, 1], 1234);
let mut ls = ListenersStream::new(t);
ls.listen_on(addr).expect("listen_on failed");
set_listener_state(&mut ls, 0, ListenerState::Error); // simulate an error on the socket
assert_matches!(ls.by_ref().wait().next(), Some(Ok(listeners_event)) => {
assert_matches!(listeners_event, ListenersEvent::Error{..})
});
assert_eq!(ls.listeners.len(), 0); // it's gone
}
fn tcp4(ip: [u8; 4], port: u16) -> Multiaddr {
let protos = std::iter::once(multiaddr::Protocol::Ip4(ip.into()))
.chain(std::iter::once(multiaddr::Protocol::Tcp(port)));
Multiaddr::from_iter(protos)
}
}

148
core/src/nodes/network.rs
View File

@ -49,10 +49,10 @@ use std::{
fmt,
hash::Hash,
num::NonZeroUsize,
pin::Pin,
task::{Context, Poll},
};
pub use crate::nodes::collection::StartTakeOver;
mod tests;
/// Implementation of `Stream` that handles the nodes.
@ -81,7 +81,7 @@ where
/// If the pair's second element is `AsyncSink::Ready`, the take over
/// message has been sent and needs to be flushed using
/// `PeerMut::complete_take_over`.
take_over_to_complete: Option<(TPeerId, AsyncSink<InterruptedReachAttempt<TInEvent, (TConnInfo, ConnectedPoint), ()>>)>
take_over_to_complete: Option<(TPeerId, InterruptedReachAttempt<TInEvent, (TConnInfo, ConnectedPoint), ()>)>
}
impl<TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId> fmt::Debug for
@ -102,6 +102,13 @@ where
}
}
impl<TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId> Unpin for
Network<TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId>
where
TTrans: Transport
{
}
impl<TConnInfo> ConnectionInfo for (TConnInfo, ConnectedPoint)
where
TConnInfo: ConnectionInfo
@ -173,7 +180,7 @@ where
/// The listener that errored.
listener_id: ListenerId,
/// The listener error.
error: <TTrans::Listener as Stream>::Error
error: <TTrans::Listener as TryStream>::Error
},
/// One of the listeners is now listening on an additional address.
@ -573,7 +580,7 @@ impl<'a, TTrans, TInEvent, TOutEvent, TMuxer, THandler, THandlerErr, TConnInfo,
where
TTrans: Transport<Output = (TConnInfo, TMuxer)>,
TTrans::Error: Send + 'static,
TTrans::ListenerUpgrade: Send + 'static,
TTrans::ListenerUpgrade: Unpin + Send + 'static,
THandler: IntoNodeHandler<(TConnInfo, ConnectedPoint)> + Send + 'static,
THandler::Handler: NodeHandler<Substream = Substream<TMuxer>, InEvent = TInEvent, OutEvent = TOutEvent, Error = THandlerErr> + Send + 'static,
<THandler::Handler as NodeHandler>::OutboundOpenInfo: Send + 'static, // TODO: shouldn't be necessary
@ -609,9 +616,9 @@ where
let connected_point = connected_point.clone();
move |(peer_id, muxer)| {
if *peer_id.peer_id() == local_peer_id {
Err(InternalReachErr::FoundLocalPeerId)
future::ready(Err(InternalReachErr::FoundLocalPeerId))
} else {
Ok(((peer_id, connected_point), muxer))
future::ready(Ok(((peer_id, connected_point), muxer)))
}
}
});
@ -781,7 +788,7 @@ where
where
TTrans: Transport<Output = (TConnInfo, TMuxer)>,
TTrans::Error: Send + 'static,
TTrans::Dial: Send + 'static,
TTrans::Dial: Unpin + Send + 'static,
TMuxer: Send + Sync + 'static,
TMuxer::OutboundSubstream: Send,
TInEvent: Send + 'static,
@ -797,9 +804,9 @@ where
let connected_point = connected_point.clone();
move |(peer_id, muxer)| {
if *peer_id.peer_id() == local_peer_id {
Err(InternalReachErr::FoundLocalPeerId)
future::ready(Err(InternalReachErr::FoundLocalPeerId))
} else {
Ok(((peer_id, connected_point), muxer))
future::ready(Ok(((peer_id, connected_point), muxer)))
}
}
});
@ -838,21 +845,16 @@ where
})
}
/// Start sending an event to all nodes.
/// Sends an event to all nodes.
///
/// Make sure to complete the broadcast with `complete_broadcast`.
/// This function is "atomic", in the sense that if `Poll::Pending` is returned then no event
/// has been sent to any node yet.
#[must_use]
pub fn start_broadcast(&mut self, event: &TInEvent) -> AsyncSink<()>
pub fn poll_broadcast(&mut self, event: &TInEvent, cx: &mut Context) -> Poll<()>
where
TInEvent: Clone
{
self.active_nodes.start_broadcast(event)
}
/// Complete a broadcast initiated with `start_broadcast`.
#[must_use]
pub fn complete_broadcast(&mut self) -> Async<()> {
self.active_nodes.complete_broadcast()
self.active_nodes.poll_broadcast(event, cx)
}
/// Returns a list of all the peers we are currently connected to.
@ -934,7 +936,7 @@ where
fn start_dial_out(&mut self, peer_id: TPeerId, handler: THandler, first: Multiaddr, rest: Vec<Multiaddr>)
where
TTrans: Transport<Output = (TConnInfo, TMuxer)>,
TTrans::Dial: Send + 'static,
TTrans::Dial: Unpin + Send + 'static,
TTrans::Error: Send + 'static,
TMuxer: Send + Sync + 'static,
TMuxer::OutboundSubstream: Send,
@ -950,9 +952,9 @@ where
.map_err(|err| InternalReachErr::Transport(TransportError::Other(err)))
.and_then(move |(actual_conn_info, muxer)| {
if *actual_conn_info.peer_id() == expected_peer_id {
Ok(((actual_conn_info, connected_point), muxer))
future::ready(Ok(((actual_conn_info, connected_point), muxer)))
} else {
Err(InternalReachErr::PeerIdMismatch { obtained: actual_conn_info })
future::ready(Err(InternalReachErr::PeerIdMismatch { obtained: actual_conn_info }))
}
});
self.active_nodes.add_reach_attempt(fut, handler)
@ -976,11 +978,12 @@ where
}
/// Provides an API similar to `Stream`, except that it cannot error.
pub fn poll(&mut self) -> Async<NetworkEvent<'_, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId>>
pub fn poll<'a>(&'a mut self, cx: &mut Context) -> Poll<NetworkEvent<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId>>
where
TTrans: Transport<Output = (TConnInfo, TMuxer)>,
TTrans::Error: Send + 'static,
TTrans::Dial: Send + 'static,
TTrans::Dial: Unpin + Send + 'static,
TTrans::Listener: Unpin,
TTrans::ListenerUpgrade: Send + 'static,
TMuxer: Send + Sync + 'static,
TMuxer::OutboundSubstream: Send,
@ -998,9 +1001,9 @@ where
Some(x) if self.incoming_negotiated().count() >= (x as usize)
=> (),
_ => {
match self.listeners.poll() {
Async::NotReady => (),
Async::Ready(ListenersEvent::Incoming { listener_id, upgrade, local_addr, send_back_addr }) => {
match ListenersStream::poll(Pin::new(&mut self.listeners), cx) {
Poll::Pending => (),
Poll::Ready(ListenersEvent::Incoming { listener_id, upgrade, local_addr, send_back_addr }) => {
let event = IncomingConnectionEvent {
listener_id,
upgrade,
@ -1010,19 +1013,19 @@ where
active_nodes: &mut self.active_nodes,
other_reach_attempts: &mut self.reach_attempts.other_reach_attempts,
};
return Async::Ready(NetworkEvent::IncomingConnection(event));
return Poll::Ready(NetworkEvent::IncomingConnection(event));
}
Async::Ready(ListenersEvent::NewAddress { listener_id, listen_addr }) => {
return Async::Ready(NetworkEvent::NewListenerAddress { listener_id, listen_addr })
Poll::Ready(ListenersEvent::NewAddress { listener_id, listen_addr }) => {
return Poll::Ready(NetworkEvent::NewListenerAddress { listener_id, listen_addr })
}
Async::Ready(ListenersEvent::AddressExpired { listener_id, listen_addr }) => {
return Async::Ready(NetworkEvent::ExpiredListenerAddress { listener_id, listen_addr })
Poll::Ready(ListenersEvent::AddressExpired { listener_id, listen_addr }) => {
return Poll::Ready(NetworkEvent::ExpiredListenerAddress { listener_id, listen_addr })
}
Async::Ready(ListenersEvent::Closed { listener_id, listener }) => {
return Async::Ready(NetworkEvent::ListenerClosed { listener_id, listener })
Poll::Ready(ListenersEvent::Closed { listener_id, listener }) => {
return Poll::Ready(NetworkEvent::ListenerClosed { listener_id, listener })
}
Async::Ready(ListenersEvent::Error { listener_id, error }) => {
return Async::Ready(NetworkEvent::ListenerError { listener_id, error })
Poll::Ready(ListenersEvent::Error { listener_id, error }) => {
return Poll::Ready(NetworkEvent::ListenerError { listener_id, error })
}
}
}
@ -1031,36 +1034,30 @@ where
// Attempt to deliver any pending take over messages.
if let Some((id, interrupted)) = self.take_over_to_complete.take() {
if let Some(mut peer) = self.active_nodes.peer_mut(&id) {
if let AsyncSink::NotReady(i) = interrupted {
if let StartTakeOver::NotReady(i) = peer.start_take_over(i) {
self.take_over_to_complete = Some((id, AsyncSink::NotReady(i)))
} else if let Ok(Async::NotReady) = peer.complete_take_over() {
self.take_over_to_complete = Some((id, AsyncSink::Ready))
}
} else if let Ok(Async::NotReady) = peer.complete_take_over() {
self.take_over_to_complete = Some((id, AsyncSink::Ready))
if let Poll::Ready(()) = peer.poll_ready_take_over(cx) {
peer.start_take_over(interrupted);
} else {
self.take_over_to_complete = Some((id, interrupted));
return Poll::Pending;
}
}
}
if self.take_over_to_complete.is_some() {
return Async::NotReady
}
// Poll the existing nodes.
let (action, out_event);
match self.active_nodes.poll() {
Async::NotReady => return Async::NotReady,
Async::Ready(CollectionEvent::NodeReached(reach_event)) => {
match self.active_nodes.poll(cx) {
Poll::Pending => return Poll::Pending,
Poll::Ready(CollectionEvent::NodeReached(reach_event)) => {
let (a, e) = handle_node_reached(&mut self.reach_attempts, reach_event);
action = a;
out_event = e;
}
Async::Ready(CollectionEvent::ReachError { id, error, handler }) => {
Poll::Ready(CollectionEvent::ReachError { id, error, handler }) => {
let (a, e) = handle_reach_error(&mut self.reach_attempts, id, error, handler);
action = a;
out_event = e;
}
Async::Ready(CollectionEvent::NodeClosed {
Poll::Ready(CollectionEvent::NodeClosed {
conn_info,
error,
..
@ -1078,7 +1075,7 @@ where
error,
};
}
Async::Ready(CollectionEvent::NodeEvent { peer, event }) => {
Poll::Ready(CollectionEvent::NodeEvent { peer, event }) => {
action = Default::default();
out_event = NetworkEvent::NodeEvent { conn_info: peer.info().0.clone(), event };
}
@ -1099,17 +1096,15 @@ where
out_reach_attempts should always be in sync with the actual \
attempts; QED");
let mut peer = self.active_nodes.peer_mut(&peer_id).unwrap();
if let StartTakeOver::NotReady(i) = peer.start_take_over(interrupted) {
self.take_over_to_complete = Some((peer_id, AsyncSink::NotReady(i)));
return Async::NotReady
}
if let Ok(Async::NotReady) = peer.complete_take_over() {
self.take_over_to_complete = Some((peer_id, AsyncSink::Ready));
return Async::NotReady
if let Poll::Ready(()) = peer.poll_ready_take_over(cx) {
peer.start_take_over(interrupted);
} else {
self.take_over_to_complete = Some((peer_id, interrupted));
return Poll::Pending
}
}
Async::Ready(out_event)
Poll::Ready(out_event)
}
}
@ -1467,7 +1462,7 @@ impl<'a, TTrans, TMuxer, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo,
where
TTrans: Transport<Output = (TConnInfo, TMuxer)> + Clone,
TTrans::Error: Send + 'static,
TTrans::Dial: Send + 'static,
TTrans::Dial: Unpin + Send + 'static,
TMuxer: StreamMuxer + Send + Sync + 'static,
TMuxer::OutboundSubstream: Send,
TMuxer::Substream: Send,
@ -1644,18 +1639,33 @@ where
closed messages; QED")
}
/// Start sending an event to the node.
pub fn start_send_event(&mut self, event: TInEvent) -> StartSend<TInEvent, ()> {
/// Sends an event to the handler of the node.
pub fn send_event(&'a mut self, event: TInEvent) -> impl Future<Output = ()> + 'a {
let mut event = Some(event);
futures::future::poll_fn(move |cx| {
match self.poll_ready_event(cx) {
Poll::Ready(()) => {
self.start_send_event(event.take().expect("Future called after finished"));
Poll::Ready(())
},
Poll::Pending => Poll::Pending,
}
})
}
/// Begin sending an event to the node. Must be called only after a successful call to
/// `poll_ready_event`.
pub fn start_send_event(&mut self, event: TInEvent) {
self.active_nodes.peer_mut(&self.peer_id)
.expect("A PeerConnected is always created with a PeerId in active_nodes; QED")
.start_send_event(event)
}
/// Complete sending an event message, initiated by `start_send_event`.
pub fn complete_send_event(&mut self) -> Poll<(), ()> {
/// Make sure we are ready to accept an event to be sent with `start_send_event`.
pub fn poll_ready_event(&mut self, cx: &mut Context) -> Poll<()> {
self.active_nodes.peer_mut(&self.peer_id)
.expect("A PeerConnected is always created with a PeerId in active_nodes; QED")
.complete_send_event()
.poll_ready_event(cx)
}
}
@ -1749,7 +1759,7 @@ impl<'a, TTrans, TInEvent, TOutEvent, TMuxer, THandler, THandlerErr, TConnInfo,
where
TTrans: Transport<Output = (TConnInfo, TMuxer)> + Clone,
TTrans::Error: Send + 'static,
TTrans::Dial: Send + 'static,
TTrans::Dial: Unpin + Send + 'static,
TMuxer: StreamMuxer + Send + Sync + 'static,
TMuxer::OutboundSubstream: Send,
TMuxer::Substream: Send,

413
core/src/nodes/network/tests.rs
View File

@ -21,363 +21,6 @@
#![cfg(test)]
use super::*;
use crate::tests::dummy_transport::DummyTransport;
use crate::tests::dummy_handler::{Handler, HandlerState, InEvent, OutEvent};
use crate::tests::dummy_transport::ListenerState;
use crate::tests::dummy_muxer::{DummyMuxer, DummyConnectionState};
use crate::nodes::NodeHandlerEvent;
use crate::transport::ListenerEvent;
use assert_matches::assert_matches;
use parking_lot::Mutex;
use std::sync::Arc;
use tokio::runtime::{Builder, Runtime};
#[test]
fn query_transport() {
let transport = DummyTransport::new();
let transport2 = transport.clone();
let network = Network::<_, _, _, Handler, _>::new(transport, PeerId::random());
assert_eq!(network.transport(), &transport2);
}
#[test]
fn local_node_peer() {
let peer_id = PeerId::random();
let mut network = Network::<_, _, _, Handler, _>::new(DummyTransport::new(), peer_id.clone());
assert_matches!(network.peer(peer_id), Peer::LocalNode);
}
#[test]
fn successful_dial_reaches_a_node() {
let mut network = Network::<_, _, _, Handler, _>::new(DummyTransport::new(), PeerId::random());
let addr = "/ip4/127.0.0.1/tcp/1234".parse::<Multiaddr>().expect("bad multiaddr");
let dial_res = network.dial(addr, Handler::default());
assert!(dial_res.is_ok());
// Poll the network until we get a `NodeReached` then assert on the peer:
// it's there and it's connected.
let network = Arc::new(Mutex::new(network));
let mut rt = Runtime::new().unwrap();
let mut peer_id : Option<PeerId> = None;
// Drive forward until we're Connected
while peer_id.is_none() {
let network_fut = network.clone();
peer_id = rt.block_on(future::poll_fn(move || -> Poll<Option<PeerId>, ()> {
let mut network = network_fut.lock();
let poll_res = network.poll();
match poll_res {
Async::Ready(NetworkEvent::Connected { conn_info, .. }) => Ok(Async::Ready(Some(conn_info))),
_ => Ok(Async::Ready(None))
}
})).expect("tokio works");
}
let mut network = network.lock();
let peer = network.peer(peer_id.unwrap());
assert_matches!(peer, Peer::Connected(PeerConnected{..}));
}
#[test]
fn num_incoming_negotiated() {
let mut transport = DummyTransport::new();
let peer_id = PeerId::random();
let muxer = DummyMuxer::new();
let events = vec![
ListenerEvent::NewAddress("/ip4/127.0.0.1/tcp/1234".parse().unwrap()),
ListenerEvent::Upgrade {
upgrade: (peer_id.clone(), muxer.clone()),
local_addr: "/ip4/127.0.0.1/tcp/1234".parse().unwrap(),
remote_addr: "/ip4/127.0.0.1/tcp/32111".parse().unwrap()
}
];
transport.set_initial_listener_state(ListenerState::Events(events));
let mut network = Network::<_, _, _, Handler, _>::new(transport, PeerId::random());
network.listen_on("/memory/0".parse().unwrap()).unwrap();
// no incoming yet
assert_eq!(network.incoming_negotiated().count(), 0);
let mut rt = Runtime::new().unwrap();
let network = Arc::new(Mutex::new(network));
let network_fut = network.clone();
let fut = future::poll_fn(move || -> Poll<_, ()> {
let mut network_fut = network_fut.lock();
assert_matches!(network_fut.poll(), Async::Ready(NetworkEvent::NewListenerAddress {..}));
assert_matches!(network_fut.poll(), Async::Ready(NetworkEvent::IncomingConnection(incoming)) => {
incoming.accept(Handler::default());
});
Ok(Async::Ready(()))
});
rt.block_on(fut).expect("tokio works");
let network = network.lock();
// Now there's an incoming connection
assert_eq!(network.incoming_negotiated().count(), 1);
}
#[test]
fn broadcasted_events_reach_active_nodes() {
let mut network = Network::<_, _, _, Handler, _>::new(DummyTransport::new(), PeerId::random());
let mut muxer = DummyMuxer::new();
muxer.set_inbound_connection_state(DummyConnectionState::Pending);
muxer.set_outbound_connection_state(DummyConnectionState::Opened);
let addr = "/ip4/127.0.0.1/tcp/1234".parse::<Multiaddr>().expect("bad multiaddr");
let mut handler = Handler::default();
handler.next_states = vec![HandlerState::Ready(NodeHandlerEvent::Custom(OutEvent::Custom("from handler 1") )),];
let dial_result = network.dial(addr, handler);
assert!(dial_result.is_ok());
let network = Arc::new(Mutex::new(network));
let mut rt = Runtime::new().unwrap();
let network2 = network.clone();
rt.block_on(future::poll_fn(move || {
if network2.lock().start_broadcast(&InEvent::NextState).is_not_ready() {
Ok::<_, ()>(Async::NotReady)
} else {
Ok(Async::Ready(()))
}
})).unwrap();
let mut peer_id : Option<PeerId> = None;
while peer_id.is_none() {
let network_fut = network.clone();
peer_id = rt.block_on(future::poll_fn(move || -> Poll<Option<PeerId>, ()> {
let mut network = network_fut.lock();
if network.complete_broadcast().is_not_ready() {
return Ok(Async::NotReady)
}
let poll_res = network.poll();
match poll_res {
Async::Ready(NetworkEvent::Connected { conn_info, .. }) => Ok(Async::Ready(Some(conn_info))),
_ => Ok(Async::Ready(None))
}
})).expect("tokio works");
}
let mut keep_polling = true;
while keep_polling {
let network_fut = network.clone();
keep_polling = rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut network = network_fut.lock();
match network.poll() {
Async::Ready(event) => {
assert_matches!(event, NetworkEvent::NodeEvent { conn_info: _, event: inner_event } => {
// The event we sent reached the node and triggered sending the out event we told it to return
assert_matches!(inner_event, OutEvent::Custom("from handler 1"));
});
Ok(Async::Ready(false))
},
_ => Ok(Async::Ready(true))
}
})).expect("tokio works");
}
}
#[test]
fn querying_for_pending_peer() {
let mut network = Network::<_, _, _, Handler, _>::new(DummyTransport::new(), PeerId::random());
let peer_id = PeerId::random();
let peer = network.peer(peer_id.clone());
assert_matches!(peer, Peer::NotConnected(PeerNotConnected{ .. }));
let addr = "/memory/0".parse().expect("bad multiaddr");
let pending_peer = peer.into_not_connected().unwrap().connect(addr, Handler::default());
assert_matches!(pending_peer, PeerPendingConnect { .. });
}
#[test]
fn querying_for_unknown_peer() {
let mut network = Network::<_, _, _, Handler, _>::new(DummyTransport::new(), PeerId::random());
let peer_id = PeerId::random();
let peer = network.peer(peer_id.clone());
assert_matches!(peer, Peer::NotConnected( PeerNotConnected { nodes: _, peer_id: node_peer_id }) => {
assert_eq!(node_peer_id, peer_id);
});
}
#[test]
fn querying_for_connected_peer() {
let mut network = Network::<_, _, _, Handler, _>::new(DummyTransport::new(), PeerId::random());
// Dial a node
let addr = "/ip4/127.0.0.1/tcp/1234".parse().expect("bad multiaddr");
network.dial(addr, Handler::default()).expect("dialing works");
let network = Arc::new(Mutex::new(network));
let mut rt = Runtime::new().unwrap();
// Drive it forward until we connect; extract the new PeerId.
let mut peer_id : Option<PeerId> = None;
while peer_id.is_none() {
let network_fut = network.clone();
peer_id = rt.block_on(future::poll_fn(move || -> Poll<Option<PeerId>, ()> {
let mut network = network_fut.lock();
let poll_res = network.poll();
match poll_res {
Async::Ready(NetworkEvent::Connected { conn_info, .. }) => Ok(Async::Ready(Some(conn_info))),
_ => Ok(Async::Ready(None))
}
})).expect("tokio works");
}
// We're connected.
let mut network = network.lock();
let peer = network.peer(peer_id.unwrap());
assert_matches!(peer, Peer::Connected( PeerConnected { .. } ));
}
#[test]
fn poll_with_closed_listener() {
let mut transport = DummyTransport::new();
// Set up listener to be closed
transport.set_initial_listener_state(ListenerState::Ok(Async::Ready(None)));
let mut network = Network::<_, _, _, Handler, _>::new(transport, PeerId::random());
network.listen_on("/memory/0".parse().unwrap()).unwrap();
let mut rt = Runtime::new().unwrap();
let network = Arc::new(Mutex::new(network));
let network_fut = network.clone();
let fut = future::poll_fn(move || -> Poll<_, ()> {
let mut network = network_fut.lock();
assert_matches!(network.poll(), Async::Ready(NetworkEvent::ListenerClosed { .. } ));
Ok(Async::Ready(()))
});
rt.block_on(fut).expect("tokio works");
}
#[test]
fn unknown_peer_that_is_unreachable_yields_unknown_peer_dial_error() {
let mut transport = DummyTransport::new();
transport.make_dial_fail();
let mut network = Network::<_, _, _, Handler, _>::new(transport, PeerId::random());
let addr = "/memory/0".parse::<Multiaddr>().expect("bad multiaddr");
let handler = Handler::default();
let dial_result = network.dial(addr, handler);
assert!(dial_result.is_ok());
let network = Arc::new(Mutex::new(network));
let mut rt = Runtime::new().unwrap();
// Drive it forward until we hear back from the node.
let mut keep_polling = true;
while keep_polling {
let network_fut = network.clone();
keep_polling = rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut network = network_fut.lock();
match network.poll() {
Async::NotReady => Ok(Async::Ready(true)),
Async::Ready(event) => {
assert_matches!(event, NetworkEvent::UnknownPeerDialError { .. } );
Ok(Async::Ready(false))
},
}
})).expect("tokio works");
}
}
#[test]
fn known_peer_that_is_unreachable_yields_dial_error() {
let mut transport = DummyTransport::new();
let peer_id = PeerId::random();
transport.set_next_peer_id(&peer_id);
transport.make_dial_fail();
let network = Arc::new(Mutex::new(Network::<_, _, _, Handler, _>::new(transport, PeerId::random())));
{
let network1 = network.clone();
let mut network1 = network1.lock();
let peer = network1.peer(peer_id.clone());
assert_matches!(peer, Peer::NotConnected(PeerNotConnected{ .. }));
let addr = "/memory/0".parse::<Multiaddr>().expect("bad multiaddr");
let pending_peer = peer.into_not_connected().unwrap().connect(addr, Handler::default());
assert_matches!(pending_peer, PeerPendingConnect { .. });
}
let mut rt = Runtime::new().unwrap();
// Drive it forward until we hear back from the node.
let mut keep_polling = true;
while keep_polling {
let network_fut = network.clone();
let peer_id = peer_id.clone();
keep_polling = rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut network = network_fut.lock();
match network.poll() {
Async::NotReady => Ok(Async::Ready(true)),
Async::Ready(event) => {
let failed_peer_id = assert_matches!(
event,
NetworkEvent::DialError { new_state: _, peer_id: failed_peer_id, .. } => failed_peer_id
);
assert_eq!(peer_id, failed_peer_id);
Ok(Async::Ready(false))
},
}
})).expect("tokio works");
}
}
#[test]
fn yields_node_error_when_there_is_an_error_after_successful_connect() {
let mut transport = DummyTransport::new();
let peer_id = PeerId::random();
transport.set_next_peer_id(&peer_id);
let network = Arc::new(Mutex::new(Network::<_, _, _, Handler, _>::new(transport, PeerId::random())));
{
// Set up an outgoing connection with a PeerId we know
let network1 = network.clone();
let mut network1 = network1.lock();
let peer = network1.peer(peer_id.clone());
let addr = "/unix/reachable".parse().expect("bad multiaddr");
let mut handler = Handler::default();
// Force an error
handler.next_states = vec![ HandlerState::Err ];
peer.into_not_connected().unwrap().connect(addr, handler);
}
// Ensure we run on a single thread
let mut rt = Builder::new().core_threads(1).build().unwrap();
// Drive it forward until we connect to the node.
let mut keep_polling = true;
while keep_polling {
let network_fut = network.clone();
let network2 = network.clone();
rt.block_on(future::poll_fn(move || {
if network2.lock().start_broadcast(&InEvent::NextState).is_not_ready() {
Ok::<_, ()>(Async::NotReady)
} else {
Ok(Async::Ready(()))
}
})).unwrap();
keep_polling = rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut network = network_fut.lock();
// Push the Handler into an error state on the next poll
if network.complete_broadcast().is_not_ready() {
return Ok(Async::NotReady)
}
match network.poll() {
Async::NotReady => Ok(Async::Ready(true)),
Async::Ready(event) => {
assert_matches!(event, NetworkEvent::Connected { .. });
// We're connected, we can move on
Ok(Async::Ready(false))
},
}
})).expect("tokio works");
}
// Poll again. It is going to be a NodeClosed because of how the
// handler's next state was set up.
let network_fut = network.clone();
let expected_peer_id = peer_id.clone();
rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut network = network_fut.lock();
assert_matches!(network.poll(), Async::Ready(NetworkEvent::NodeClosed { conn_info, .. }) => {
assert_eq!(conn_info, expected_peer_id);
});
Ok(Async::Ready(()))
})).expect("tokio works");
}
#[test]
fn local_prio_equivalence_relation() {
@ -387,59 +30,3 @@ fn local_prio_equivalence_relation() {
assert_ne!(has_dial_prio(&a, &b), has_dial_prio(&b, &a));
}
}
#[test]
fn limit_incoming_connections() {
let mut transport = DummyTransport::new();
let peer_id = PeerId::random();
let muxer = DummyMuxer::new();
let limit = 1;
let mut events = vec![ListenerEvent::NewAddress("/ip4/127.0.0.1/tcp/1234".parse().unwrap())];
events.extend(std::iter::repeat(
ListenerEvent::Upgrade {
upgrade: (peer_id.clone(), muxer.clone()),
local_addr: "/ip4/127.0.0.1/tcp/1234".parse().unwrap(),
remote_addr: "/ip4/127.0.0.1/tcp/32111".parse().unwrap()
}
).take(10));
transport.set_initial_listener_state(ListenerState::Events(events));
let mut network = Network::<_, _, _, Handler, _>::new_with_incoming_limit(transport, PeerId::random(), Some(limit));
assert_eq!(network.incoming_limit(), Some(limit));
network.listen_on("/memory/0".parse().unwrap()).unwrap();
assert_eq!(network.incoming_negotiated().count(), 0);
let network = Arc::new(Mutex::new(network));
let mut rt = Runtime::new().unwrap();
for i in 1..10 {
let network_fut = network.clone();
let fut = future::poll_fn(move || -> Poll<_, ()> {
let mut network_fut = network_fut.lock();
if i <= limit {
assert_matches!(network_fut.poll(), Async::Ready(NetworkEvent::NewListenerAddress {..}));
assert_matches!(network_fut.poll(),
Async::Ready(NetworkEvent::IncomingConnection(incoming)) => {
incoming.accept(Handler::default());
});
} else {
match network_fut.poll() {
Async::NotReady => (),
Async::Ready(x) => {
match x {
NetworkEvent::NewListenerAddress {..} => {}
NetworkEvent::ExpiredListenerAddress {..} => {}
NetworkEvent::IncomingConnection(_) => {}
NetworkEvent::Connected {..} => {}
e => panic!("Not expected event: {:?}", e)
}
},
}
}
Ok(Async::Ready(()))
});
rt.block_on(fut).expect("tokio works");
let network = network.lock();
assert!(network.incoming_negotiated().count() <= (limit as usize));
}
}

111
core/src/nodes/node.rs
View File

@ -21,9 +21,7 @@
use futures::prelude::*;
use crate::muxing;
use smallvec::SmallVec;
use std::fmt;
use std::io::Error as IoError;
use std::sync::Arc;
use std::{fmt, io::Error as IoError, pin::Pin, sync::Arc, task::Context, task::Poll};
// Implementation notes
// =================
@ -135,7 +133,7 @@ where
/// Destroys all outbound streams and returns the corresponding user data.
pub fn cancel_outgoing(&mut self) -> Vec<TUserData> {
let mut out = Vec::with_capacity(self.outbound_substreams.len());
for (user_data, outbound) in self.outbound_substreams.drain() {
for (user_data, outbound) in self.outbound_substreams.drain(..) {
out.push(user_data);
self.muxer.destroy_outbound(outbound);
}
@ -143,43 +141,44 @@ where
}
/// Provides an API similar to `Future`.
pub fn poll(&mut self) -> Poll<NodeEvent<TMuxer, TUserData>, IoError> {
pub fn poll(&mut self, cx: &mut Context) -> Poll<Result<NodeEvent<TMuxer, TUserData>, IoError>> {
// Polling inbound substream.
match self.muxer.poll_inbound().map_err(|e| e.into())? {
Async::Ready(substream) => {
match self.muxer.poll_inbound(cx) {
Poll::Ready(Ok(substream)) => {
let substream = muxing::substream_from_ref(self.muxer.clone(), substream);
return Ok(Async::Ready(NodeEvent::InboundSubstream {
return Poll::Ready(Ok(NodeEvent::InboundSubstream {
substream,
}));
}
Async::NotReady => {}
Poll::Ready(Err(err)) => return Poll::Ready(Err(err.into())),
Poll::Pending => {}
}
// Polling outbound substreams.
// We remove each element from `outbound_substreams` one by one and add them back.
for n in (0..self.outbound_substreams.len()).rev() {
let (user_data, mut outbound) = self.outbound_substreams.swap_remove(n);
match self.muxer.poll_outbound(&mut outbound) {
Ok(Async::Ready(substream)) => {
match self.muxer.poll_outbound(cx, &mut outbound) {
Poll::Ready(Ok(substream)) => {
let substream = muxing::substream_from_ref(self.muxer.clone(), substream);
self.muxer.destroy_outbound(outbound);
return Ok(Async::Ready(NodeEvent::OutboundSubstream {
return Poll::Ready(Ok(NodeEvent::OutboundSubstream {
user_data,
substream,
}));
}
Ok(Async::NotReady) => {
Poll::Pending => {
self.outbound_substreams.push((user_data, outbound));
}
Err(err) => {
Poll::Ready(Err(err)) => {
self.muxer.destroy_outbound(outbound);
return Err(err.into());
return Poll::Ready(Err(err.into()));
}
}
}
// Nothing happened. Register our task to be notified and return.
Ok(Async::NotReady)
Poll::Pending
}
}
@ -202,7 +201,7 @@ where
// The substreams that were produced will continue to work, as the muxer is held in an Arc.
// However we will no longer process any further inbound or outbound substream, and we
// therefore close everything.
for (_, outbound) in self.outbound_substreams.drain() {
for (_, outbound) in self.outbound_substreams.drain(..) {
self.muxer.destroy_outbound(outbound);
}
}
@ -212,11 +211,14 @@ impl<TMuxer> Future for Close<TMuxer>
where
TMuxer: muxing::StreamMuxer,
{
type Item = ();
type Error = IoError;
type Output = Result<(), IoError>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
self.muxer.close().map_err(|e| e.into())
fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
match self.muxer.close(cx) {
Poll::Pending => Poll::Pending,
Poll::Ready(Ok(())) => Poll::Ready(Ok(())),
Poll::Ready(Err(err)) => Poll::Ready(Err(err.into())),
}
}
}
@ -252,70 +254,3 @@ where
}
}
}
#[cfg(test)]
mod node_stream {
use super::{NodeEvent, NodeStream};
use crate::tests::dummy_muxer::{DummyMuxer, DummyConnectionState};
use assert_matches::assert_matches;
use futures::prelude::*;
use tokio_mock_task::MockTask;
fn build_node_stream() -> NodeStream<DummyMuxer, Vec<u8>> {
let muxer = DummyMuxer::new();
NodeStream::<_, Vec<u8>>::new(muxer)
}
#[test]
fn closing_a_node_stream_destroys_substreams_and_returns_submitted_user_data() {
let mut ns = build_node_stream();
ns.open_substream(vec![2]);
ns.open_substream(vec![3]);
ns.open_substream(vec![5]);
let user_data_submitted = ns.close();
assert_eq!(user_data_submitted.1, vec![
vec![2], vec![3], vec![5]
]);
}
#[test]
fn poll_returns_not_ready_when_there_is_nothing_to_do() {
let mut task = MockTask::new();
task.enter(|| {
// ensure the address never resolves
let mut muxer = DummyMuxer::new();
// ensure muxer.poll_inbound() returns Async::NotReady
muxer.set_inbound_connection_state(DummyConnectionState::Pending);
// ensure muxer.poll_outbound() returns Async::NotReady
muxer.set_outbound_connection_state(DummyConnectionState::Pending);
let mut ns = NodeStream::<_, Vec<u8>>::new(muxer);
assert_matches!(ns.poll(), Ok(Async::NotReady));
});
}
#[test]
fn poll_keeps_outbound_substreams_when_the_outgoing_connection_is_not_ready() {
let mut muxer = DummyMuxer::new();
// ensure muxer.poll_inbound() returns Async::NotReady
muxer.set_inbound_connection_state(DummyConnectionState::Pending);
// ensure muxer.poll_outbound() returns Async::NotReady
muxer.set_outbound_connection_state(DummyConnectionState::Pending);
let mut ns = NodeStream::<_, Vec<u8>>::new(muxer);
ns.open_substream(vec![1]);
ns.poll().unwrap(); // poll past inbound
ns.poll().unwrap(); // poll outbound
assert!(format!("{:?}", ns).contains("outbound_substreams: 1"));
}
#[test]
fn poll_returns_incoming_substream() {
let mut muxer = DummyMuxer::new();
// ensure muxer.poll_inbound() returns Async::Ready(subs)
muxer.set_inbound_connection_state(DummyConnectionState::Opened);
let mut ns = NodeStream::<_, Vec<u8>>::new(muxer);
assert_matches!(ns.poll(), Ok(Async::Ready(node_event)) => {
assert_matches!(node_event, NodeEvent::InboundSubstream{ substream: _ });
});
}
}

268
core/src/nodes/tasks/manager.rs
View File

@ -27,9 +27,8 @@ use crate::{
}
};
use fnv::FnvHashMap;
use futures::{prelude::*, future::Executor, sync::mpsc};
use smallvec::SmallVec;
use std::{collections::hash_map::{Entry, OccupiedEntry}, error, fmt};
use futures::{prelude::*, channel::mpsc, executor::ThreadPool, stream::FuturesUnordered};
use std::{collections::hash_map::{Entry, OccupiedEntry}, error, fmt, pin::Pin, task::Context, task::Poll};
use super::{TaskId, task::{Task, FromTaskMessage, ToTaskMessage}, Error};
// Implementor notes
@ -64,12 +63,13 @@ pub struct Manager<I, O, H, E, HE, T, C = PeerId> {
/// Identifier for the next task to spawn.
next_task_id: TaskId,
/// List of node tasks to spawn.
to_spawn: SmallVec<[Box<dyn Future<Item = (), Error = ()> + Send>; 8]>,
/// Threads pool where we spawn the nodes' tasks. If `None`, then we push tasks to the
/// `local_spawns` list instead.
threads_pool: Option<ThreadPool>,
/// If no tokio executor is available, we move tasks to this list, and futures are polled on
/// the current thread instead.
local_spawns: Vec<Box<dyn Future<Item = (), Error = ()> + Send>>,
/// If no executor is available, we move tasks to this set, and futures are polled on the
/// current thread instead.
local_spawns: FuturesUnordered<Pin<Box<dyn Future<Output = ()> + Send>>>,
/// Sender to emit events to the outside. Meant to be cloned and sent to tasks.
events_tx: mpsc::Sender<(FromTaskMessage<O, H, E, HE, C>, TaskId)>,
@ -91,16 +91,13 @@ where
/// Information about a running task.
///
/// Contains the sender to deliver event messages to the task,
/// the associated user data and a pending message if any,
/// meant to be delivered to the task via the sender.
/// Contains the sender to deliver event messages to the task, and
/// the associated user data.
struct TaskInfo<I, T> {
/// channel endpoint to send messages to the task
sender: mpsc::Sender<ToTaskMessage<I>>,
/// task associated data
user_data: T,
/// any pending event to deliver to the task
pending: Option<AsyncSink<ToTaskMessage<I>>>
}
/// Event produced by the [`Manager`].
@ -140,11 +137,15 @@ impl<I, O, H, E, HE, T, C> Manager<I, O, H, E, HE, T, C> {
/// Creates a new task manager.
pub fn new() -> Self {
let (tx, rx) = mpsc::channel(1);
let threads_pool = ThreadPool::builder()
.name_prefix("libp2p-nodes-")
.create().ok();
Self {
tasks: FnvHashMap::default(),
next_task_id: TaskId(0),
to_spawn: SmallVec::new(),
local_spawns: Vec::new(),
threads_pool,
local_spawns: FuturesUnordered::new(),
events_tx: tx,
events_rx: rx
}
@ -156,7 +157,7 @@ impl<I, O, H, E, HE, T, C> Manager<I, O, H, E, HE, T, C> {
/// processing the node's events.
pub fn add_reach_attempt<F, M>(&mut self, future: F, user_data: T, handler: H) -> TaskId
where
F: Future<Item = (C, M), Error = E> + Send + 'static,
F: Future<Output = Result<(C, M), E>> + Unpin + Send + 'static,
H: IntoNodeHandler<C> + Send + 'static,
H::Handler: NodeHandler<Substream = Substream<M>, InEvent = I, OutEvent = O, Error = HE> + Send + 'static,
E: error::Error + Send + 'static,
@ -172,10 +173,14 @@ impl<I, O, H, E, HE, T, C> Manager<I, O, H, E, HE, T, C> {
self.next_task_id.0 += 1;
let (tx, rx) = mpsc::channel(4);
self.tasks.insert(task_id, TaskInfo { sender: tx, user_data, pending: None });
self.tasks.insert(task_id, TaskInfo { sender: tx, user_data });
let task = Box::new(Task::new(task_id, self.events_tx.clone(), rx, future, handler));
self.to_spawn.push(task);
let task = Box::pin(Task::new(task_id, self.events_tx.clone(), rx, future, handler));
if let Some(threads_pool) = &mut self.threads_pool {
threads_pool.spawn_ok(task);
} else {
self.local_spawns.push(task);
}
task_id
}
@ -202,71 +207,46 @@ impl<I, O, H, E, HE, T, C> Manager<I, O, H, E, HE, T, C> {
self.next_task_id.0 += 1;
let (tx, rx) = mpsc::channel(4);
self.tasks.insert(task_id, TaskInfo { sender: tx, user_data, pending: None });
self.tasks.insert(task_id, TaskInfo { sender: tx, user_data });
let task: Task<futures::future::Empty<_, _>, _, _, _, _, _, _> =
let task: Task<Pin<Box<futures::future::Pending<_>>>, _, _, _, _, _, _> =
Task::node(task_id, self.events_tx.clone(), rx, HandledNode::new(muxer, handler));
self.to_spawn.push(Box::new(task));
if let Some(threads_pool) = &mut self.threads_pool {
threads_pool.spawn_ok(Box::pin(task));
} else {
self.local_spawns.push(Box::pin(task));
}
task_id
}
/// Start sending an event to all the tasks, including the pending ones.
/// Sends a message to all the tasks, including the pending ones.
///
/// After starting a broadcast make sure to finish it with `complete_broadcast`,
/// otherwise starting another broadcast or sending an event directly to a
/// task would overwrite the pending broadcast.
/// This function is "atomic", in the sense that if `Poll::Pending` is returned then no event
/// has been sent to any node yet.
#[must_use]
pub fn start_broadcast(&mut self, event: &I) -> AsyncSink<()>
pub fn poll_broadcast(&mut self, event: &I, cx: &mut Context) -> Poll<()>
where
I: Clone
{
if self.complete_broadcast().is_not_ready() {
return AsyncSink::NotReady(())
for task in self.tasks.values_mut() {
if let Poll::Pending = task.sender.poll_ready(cx) {
return Poll::Pending;
}
}
for task in self.tasks.values_mut() {
let msg = ToTaskMessage::HandlerEvent(event.clone());
task.pending = Some(AsyncSink::NotReady(msg))
}
AsyncSink::Ready
}
/// Complete a started broadcast.
#[must_use]
pub fn complete_broadcast(&mut self) -> Async<()> {
let mut ready = true;
for task in self.tasks.values_mut() {
match task.pending.take() {
Some(AsyncSink::NotReady(msg)) =>
match task.sender.start_send(msg) {
Ok(AsyncSink::NotReady(msg)) => {
task.pending = Some(AsyncSink::NotReady(msg));
ready = false
}
Ok(AsyncSink::Ready) =>
if let Ok(Async::NotReady) = task.sender.poll_complete() {
task.pending = Some(AsyncSink::Ready);
ready = false
}
Err(_) => {}
}
Some(AsyncSink::Ready) =>
if let Ok(Async::NotReady) = task.sender.poll_complete() {
task.pending = Some(AsyncSink::Ready);
ready = false
}
None => {}
match task.sender.start_send(msg) {
Ok(()) => {},
Err(ref err) if err.is_full() =>
panic!("poll_ready returned Poll::Ready just above; qed"),
Err(_) => {},
}
}
if ready {
Async::Ready(())
} else {
Async::NotReady
}
Poll::Ready(())
}
/// Grants access to an object that allows controlling a task of the collection.
@ -285,32 +265,13 @@ impl<I, O, H, E, HE, T, C> Manager<I, O, H, E, HE, T, C> {
}
/// Provides an API similar to `Stream`, except that it cannot produce an error.
pub fn poll(&mut self) -> Async<Event<I, O, H, E, HE, T, C>> {
for to_spawn in self.to_spawn.drain() {
// We try to use the default executor, but fall back to polling the task manually if
// no executor is available. This makes it possible to use the core in environments
// outside of tokio.
let executor = tokio_executor::DefaultExecutor::current();
if let Err(err) = executor.execute(to_spawn) {
self.local_spawns.push(err.into_future())
}
}
for n in (0 .. self.local_spawns.len()).rev() {
let mut task = self.local_spawns.swap_remove(n);
match task.poll() {
Ok(Async::Ready(())) => {}
Ok(Async::NotReady) => self.local_spawns.push(task),
// It would normally be desirable to either report or log when a background task
// errors. However the default tokio executor doesn't do anything in case of error,
// and therefore we mimic this behaviour by also not doing anything.
Err(()) => {}
}
}
pub fn poll(&mut self, cx: &mut Context) -> Poll<Event<I, O, H, E, HE, T, C>> {
// Advance the content of `local_spawns`.
while let Poll::Ready(Some(_)) = Stream::poll_next(Pin::new(&mut self.local_spawns), cx) {}
let (message, task_id) = loop {
match self.events_rx.poll() {
Ok(Async::Ready(Some((message, task_id)))) => {
match Stream::poll_next(Pin::new(&mut self.events_rx), cx) {
Poll::Ready(Some((message, task_id))) => {
// If the task id is no longer in `self.tasks`, that means that the user called
// `close()` on this task earlier. Therefore no new event should be generated
// for this task.
@ -318,13 +279,12 @@ impl<I, O, H, E, HE, T, C> Manager<I, O, H, E, HE, T, C> {
break (message, task_id)
}
}
Ok(Async::NotReady) => return Async::NotReady,
Ok(Async::Ready(None)) => unreachable!("sender and receiver have same lifetime"),
Err(()) => unreachable!("An `mpsc::Receiver` does not error.")
Poll::Pending => return Poll::Pending,
Poll::Ready(None) => unreachable!("sender and receiver have same lifetime"),
}
};
Async::Ready(match message {
Poll::Ready(match message {
FromTaskMessage::NodeEvent(event) =>
Event::NodeEvent {
task: match self.tasks.entry(task_id) {
@ -360,24 +320,16 @@ pub struct TaskEntry<'a, E, T> {
}
impl<'a, E, T> TaskEntry<'a, E, T> {
/// Begin sending an event to the given node.
///
/// Make sure to finish the send operation with `complete_send_event`.
pub fn start_send_event(&mut self, event: E) -> StartSend<E, ()> {
/// Begin sending an event to the given node. Must be called only after a successful call to
/// `poll_ready_event`.
pub fn start_send_event(&mut self, event: E) {
let msg = ToTaskMessage::HandlerEvent(event);
if let AsyncSink::NotReady(msg) = self.start_send_event_msg(msg)? {
if let ToTaskMessage::HandlerEvent(event) = msg {
return Ok(AsyncSink::NotReady(event))
} else {
unreachable!("we tried to send an handler event, so we get one back if not ready")
}
}
Ok(AsyncSink::Ready)
self.start_send_event_msg(msg);
}
/// Finish a send operation started with `start_send_event`.
pub fn complete_send_event(&mut self) -> Poll<(), ()> {
self.complete_send_event_msg()
/// Make sure we are ready to accept an event to be sent with `start_send_event`.
pub fn poll_ready_event(&mut self, cx: &mut Context) -> Poll<()> {
self.poll_ready_event_msg(cx)
}
/// Returns the user data associated with the task.
@ -409,79 +361,38 @@ impl<'a, E, T> TaskEntry<'a, E, T> {
/// As soon as our task (`self`) has some acknowledgment from the remote
/// that its connection is alive, it will close the connection with `other`.
///
/// Make sure to complete this operation with `complete_take_over`.
#[must_use]
pub fn start_take_over(&mut self, t: ClosedTask<E, T>) -> StartTakeOver<T, ClosedTask<E, T>> {
/// Must be called only after a successful call to `poll_ready_take_over`.
pub fn start_take_over(&mut self, t: ClosedTask<E, T>) {
self.start_send_event_msg(ToTaskMessage::TakeOver(t.sender));
}
/// Make sure we are ready to taking over with `start_take_over`.
pub fn poll_ready_take_over(&mut self, cx: &mut Context) -> Poll<()> {
self.poll_ready_event_msg(cx)
}
/// Sends a message to the task. Must be called only after a successful call to
/// `poll_ready_event`.
///
/// The API mimicks the one of [`futures::Sink`].
fn start_send_event_msg(&mut self, msg: ToTaskMessage<E>) {
// It is possible that the sender is closed if the background task has already finished
// but the local state hasn't been updated yet because we haven't been polled in the
// meanwhile.
let id = t.id();
match self.start_send_event_msg(ToTaskMessage::TakeOver(t.sender)) {
Ok(AsyncSink::Ready) => StartTakeOver::Ready(t.user_data),
Ok(AsyncSink::NotReady(ToTaskMessage::TakeOver(sender))) =>
StartTakeOver::NotReady(ClosedTask::new(id, sender, t.user_data)),
Ok(AsyncSink::NotReady(_)) =>
unreachable!("We tried to send a take over message, so we get one back."),
Err(()) => StartTakeOver::Gone
match self.inner.get_mut().sender.start_send(msg) {
Ok(()) => {},
Err(ref err) if err.is_full() => {}, // TODO: somehow report to user?
Err(_) => {},
}
}
/// Finish take over started by `start_take_over`.
pub fn complete_take_over(&mut self) -> Poll<(), ()> {
self.complete_send_event_msg()
}
/// Begin to send a message to the task.
///
/// The API mimicks the one of [`futures::Sink`]. If this method returns
/// `Ok(AsyncSink::Ready)` drive the sending to completion with
/// `complete_send_event_msg`. If the receiving end does not longer exist,
/// i.e. the task has ended, we return this information as an error.
fn start_send_event_msg(&mut self, msg: ToTaskMessage<E>) -> StartSend<ToTaskMessage<E>, ()> {
// We first drive any pending send to completion before starting another one.
if self.complete_send_event_msg()?.is_ready() {
self.inner.get_mut().pending = Some(AsyncSink::NotReady(msg));
Ok(AsyncSink::Ready)
} else {
Ok(AsyncSink::NotReady(msg))
}
}
/// Complete event message deliver started by `start_send_event_msg`.
fn complete_send_event_msg(&mut self) -> Poll<(), ()> {
/// Wait until we have space to send an event using `start_send_event_msg`.
fn poll_ready_event_msg(&mut self, cx: &mut Context) -> Poll<()> {
// It is possible that the sender is closed if the background task has already finished
// but the local state hasn't been updated yet because we haven't been polled in the
// meanwhile.
let task = self.inner.get_mut();
let state =
if let Some(state) = task.pending.take() {
state
} else {
return Ok(Async::Ready(()))
};
match state {
AsyncSink::NotReady(msg) =>
match task.sender.start_send(msg).map_err(|_| ())? {
AsyncSink::Ready =>
if task.sender.poll_complete().map_err(|_| ())?.is_not_ready() {
task.pending = Some(AsyncSink::Ready);
Ok(Async::NotReady)
} else {
Ok(Async::Ready(()))
}
AsyncSink::NotReady(msg) => {
task.pending = Some(AsyncSink::NotReady(msg));
Ok(Async::NotReady)
}
}
AsyncSink::Ready =>
if task.sender.poll_complete().map_err(|_| ())?.is_not_ready() {
task.pending = Some(AsyncSink::Ready);
Ok(Async::NotReady)
} else {
Ok(Async::Ready(()))
}
}
task.sender.poll_ready(cx).map(|_| ())
}
}
@ -494,18 +405,6 @@ impl<E, T: fmt::Debug> fmt::Debug for TaskEntry<'_, E, T> {
}
}
/// Result of [`TaskEntry::start_take_over`].
#[derive(Debug)]
pub enum StartTakeOver<A, B> {
/// The take over message has been enqueued.
/// Complete the take over with [`TaskEntry::complete_take_over`].
Ready(A),
/// Not ready to send the take over message to the task.
NotReady(B),
/// The task to send the take over message is no longer there.
Gone
}
/// Task after it has been closed.
///
/// The connection to the remote is potentially still going on, but no new
@ -565,4 +464,3 @@ impl<E, T: fmt::Debug> fmt::Debug for ClosedTask<E, T> {
.finish()
}
}

4
core/src/nodes/tasks/mod.rs
View File

@ -29,7 +29,7 @@
//! an existing connection to a node should be driven forward (cf.
//! [`Manager::add_connection`]). Tasks can be referred to by [`TaskId`]
//! and messages can be sent to individual tasks or all (cf.
//! [`Manager::start_broadcast`]). Messages produces by tasks can be
//! [`Manager::poll_broadcast`]). Messages produces by tasks can be
//! retrieved by polling the manager (cf. [`Manager::poll`]).
mod error;
@ -37,7 +37,7 @@ mod manager;
mod task;
pub use error::Error;
pub use manager::{ClosedTask, TaskEntry, Manager, Event, StartTakeOver};
pub use manager::{ClosedTask, TaskEntry, Manager, Event};
/// Task identifier.
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]

190
core/src/nodes/tasks/task.rs
View File

@ -25,8 +25,9 @@ use crate::{
node::{Close, Substream}
}
};
use futures::{prelude::*, stream, sync::mpsc};
use futures::{prelude::*, channel::mpsc, stream};
use smallvec::SmallVec;
use std::{pin::Pin, task::Context, task::Poll};
use super::{TaskId, Error};
/// Message to transmit from the public API to a task.
@ -140,13 +141,6 @@ where
event: FromTaskMessage<O, H, E, <H::Handler as NodeHandler>::Error, C>
},
/// We started sending an event, now drive the sending to completion.
///
/// The `bool` parameter determines if we transition to `State::Node`
/// afterwards or to `State::Closing` (assuming we have `Some` node,
/// otherwise the task will end).
PollComplete(Option<HandledNode<M, H::Handler>>, bool),
/// Fully functional node.
Node(HandledNode<M, H::Handler>),
@ -158,94 +152,103 @@ where
Undefined
}
impl<F, M, H, I, O, E, C> Unpin for Task<F, M, H, I, O, E, C>
where
M: StreamMuxer,
H: IntoNodeHandler<C>,
H::Handler: NodeHandler<Substream = Substream<M>>
{
}
impl<F, M, H, I, O, E, C> Future for Task<F, M, H, I, O, E, C>
where
M: StreamMuxer,
F: Future<Item = (C, M), Error = E>,
F: Future<Output = Result<(C, M), E>> + Unpin,
H: IntoNodeHandler<C>,
H::Handler: NodeHandler<Substream = Substream<M>, InEvent = I, OutEvent = O>
{
type Item = ();
type Error = ();
type Output = ();
// NOTE: It is imperative to always consume all incoming event messages
// first in order to not prevent the outside from making progress because
// they are blocked on the channel capacity.
fn poll(&mut self) -> Poll<(), ()> {
fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<()> {
// We use a `this` because the compiler isn't smart enough to allow mutably borrowing
// multiple different fields from the `Pin` at the same time.
let this = &mut *self;
'poll: loop {
match std::mem::replace(&mut self.state, State::Undefined) {
match std::mem::replace(&mut this.state, State::Undefined) {
State::Future { mut future, handler, mut events_buffer } => {
// If self.receiver is closed, we stop the task.
// If this.receiver is closed, we stop the task.
loop {
match self.receiver.poll() {
Ok(Async::NotReady) => break,
Ok(Async::Ready(None)) => return Ok(Async::Ready(())),
Ok(Async::Ready(Some(ToTaskMessage::HandlerEvent(event)))) =>
match Stream::poll_next(Pin::new(&mut this.receiver), cx) {
Poll::Pending => break,
Poll::Ready(None) => return Poll::Ready(()),
Poll::Ready(Some(ToTaskMessage::HandlerEvent(event))) =>
events_buffer.push(event),
Ok(Async::Ready(Some(ToTaskMessage::TakeOver(take_over)))) =>
self.taken_over.push(take_over),
Err(()) => unreachable!("An `mpsc::Receiver` does not error.")
Poll::Ready(Some(ToTaskMessage::TakeOver(take_over))) =>
this.taken_over.push(take_over),
}
}
// Check if dialing succeeded.
match future.poll() {
Ok(Async::Ready((conn_info, muxer))) => {
match Future::poll(Pin::new(&mut future), cx) {
Poll::Ready(Ok((conn_info, muxer))) => {
let mut node = HandledNode::new(muxer, handler.into_handler(&conn_info));
for event in events_buffer {
node.inject_event(event)
}
self.state = State::SendEvent {
this.state = State::SendEvent {
node: Some(node),
event: FromTaskMessage::NodeReached(conn_info)
}
}
Ok(Async::NotReady) => {
self.state = State::Future { future, handler, events_buffer };
return Ok(Async::NotReady)
Poll::Pending => {
this.state = State::Future { future, handler, events_buffer };
return Poll::Pending
}
Err(e) => {
Poll::Ready(Err(e)) => {
let event = FromTaskMessage::TaskClosed(Error::Reach(e), Some(handler));
self.state = State::SendEvent { node: None, event }
this.state = State::SendEvent { node: None, event }
}
}
}
State::Node(mut node) => {
// Start by handling commands received from the outside of the task.
loop {
match self.receiver.poll() {
Ok(Async::NotReady) => break,
Ok(Async::Ready(Some(ToTaskMessage::HandlerEvent(event)))) =>
match Stream::poll_next(Pin::new(&mut this.receiver), cx) {
Poll::Pending => break,
Poll::Ready(Some(ToTaskMessage::HandlerEvent(event))) =>
node.inject_event(event),
Ok(Async::Ready(Some(ToTaskMessage::TakeOver(take_over)))) =>
self.taken_over.push(take_over),
Ok(Async::Ready(None)) => {
Poll::Ready(Some(ToTaskMessage::TakeOver(take_over))) =>
this.taken_over.push(take_over),
Poll::Ready(None) => {
// Node closed by the external API; start closing.
self.state = State::Closing(node.close());
this.state = State::Closing(node.close());
continue 'poll
}
Err(()) => unreachable!("An `mpsc::Receiver` does not error.")
}
}
// Process the node.
loop {
if !self.taken_over.is_empty() && node.is_remote_acknowledged() {
self.taken_over.clear()
if !this.taken_over.is_empty() && node.is_remote_acknowledged() {
this.taken_over.clear()
}
match node.poll() {
Ok(Async::NotReady) => {
self.state = State::Node(node);
return Ok(Async::NotReady)
match HandledNode::poll(Pin::new(&mut node), cx) {
Poll::Pending => {
this.state = State::Node(node);
return Poll::Pending
}
Ok(Async::Ready(event)) => {
self.state = State::SendEvent {
Poll::Ready(Ok(event)) => {
this.state = State::SendEvent {
node: Some(node),
event: FromTaskMessage::NodeEvent(event)
};
continue 'poll
}
Err(err) => {
Poll::Ready(Err(err)) => {
let event = FromTaskMessage::TaskClosed(Error::Node(err), None);
self.state = State::SendEvent { node: None, event };
this.state = State::SendEvent { node: None, event };
continue 'poll
}
}
@ -254,23 +257,22 @@ where
// Deliver an event to the outside.
State::SendEvent { mut node, event } => {
loop {
match self.receiver.poll() {
Ok(Async::NotReady) => break,
Ok(Async::Ready(Some(ToTaskMessage::HandlerEvent(event)))) =>
match Stream::poll_next(Pin::new(&mut this.receiver), cx) {
Poll::Pending => break,
Poll::Ready(Some(ToTaskMessage::HandlerEvent(event))) =>
if let Some(ref mut n) = node {
n.inject_event(event)
}
Ok(Async::Ready(Some(ToTaskMessage::TakeOver(take_over)))) =>
self.taken_over.push(take_over),
Ok(Async::Ready(None)) =>
Poll::Ready(Some(ToTaskMessage::TakeOver(take_over))) =>
this.taken_over.push(take_over),
Poll::Ready(None) =>
// Node closed by the external API; start closing.
if let Some(n) = node {
self.state = State::Closing(n.close());
this.state = State::Closing(n.close());
continue 'poll
} else {
return Ok(Async::Ready(())) // end task
return Poll::Ready(()) // end task
}
Err(()) => unreachable!("An `mpsc::Receiver` does not error.")
}
}
// Check if this task is about to close. We pass the flag to
@ -281,80 +283,46 @@ where
} else {
false
};
match self.sender.start_send((event, self.id)) {
Ok(AsyncSink::NotReady((event, _))) => {
match this.sender.poll_ready(cx) {
Poll::Pending => {
self.state = State::SendEvent { node, event };
return Ok(Async::NotReady)
return Poll::Pending
}
Ok(AsyncSink::Ready) => self.state = State::PollComplete(node, close),
Err(_) => {
if let Some(n) = node {
self.state = State::Closing(n.close());
continue 'poll
}
// We can not communicate to the outside and there is no
// node to handle, so this is the end of this task.
return Ok(Async::Ready(()))
}
}
}
// We started delivering an event, now try to complete the sending.
State::PollComplete(mut node, close) => {
loop {
match self.receiver.poll() {
Ok(Async::NotReady) => break,
Ok(Async::Ready(Some(ToTaskMessage::HandlerEvent(event)))) =>
if let Some(ref mut n) = node {
n.inject_event(event)
}
Ok(Async::Ready(Some(ToTaskMessage::TakeOver(take_over)))) =>
self.taken_over.push(take_over),
Ok(Async::Ready(None)) =>
// Node closed by the external API; start closing.
if let Some(n) = node {
self.state = State::Closing(n.close());
continue 'poll
} else {
return Ok(Async::Ready(())) // end task
}
Err(()) => unreachable!("An `mpsc::Receiver` does not error.")
}
}
match self.sender.poll_complete() {
Ok(Async::NotReady) => {
self.state = State::PollComplete(node, close);
return Ok(Async::NotReady)
}
Ok(Async::Ready(())) =>
Poll::Ready(Ok(())) => {
// We assume that if `poll_ready` has succeeded, then sending the event
// will succeed as well. If it turns out that it didn't, we will detect
// the closing at the next loop iteration.
let _ = this.sender.start_send((event, this.id));
if let Some(n) = node {
if close {
self.state = State::Closing(n.close())
this.state = State::Closing(n.close())
} else {
self.state = State::Node(n)
this.state = State::Node(n)
}
} else {
// Since we have no node we terminate this task.
assert!(close);
return Ok(Async::Ready(()))
return Poll::Ready(())
}
Err(_) => {
},
Poll::Ready(Err(_)) => {
if let Some(n) = node {
self.state = State::Closing(n.close());
this.state = State::Closing(n.close());
continue 'poll
}
// We can not communicate to the outside and there is no
// node to handle, so this is the end of this task.
return Ok(Async::Ready(()))
return Poll::Ready(())
}
}
}
State::Closing(mut closing) =>
match closing.poll() {
Ok(Async::Ready(())) | Err(_) =>
return Ok(Async::Ready(())), // end task
Ok(Async::NotReady) => {
self.state = State::Closing(closing);
return Ok(Async::NotReady)
match Future::poll(Pin::new(&mut closing), cx) {
Poll::Ready(_) =>
return Poll::Ready(()), // end task
Poll::Pending => {
this.state = State::Closing(closing);
return Poll::Pending
}
}
// This happens if a previous poll has resolved the future.

2
core/src/peer_id.rs
View File

@ -28,7 +28,7 @@ use std::{convert::TryFrom, fmt, str::FromStr};
/// automatically used as the peer id using an identity multihash.
//
// Note: see `from_public_key` for how this value will be used in the future.
const MAX_INLINE_KEY_LENGTH: usize = 42;
const _MAX_INLINE_KEY_LENGTH: usize = 42;
/// Identifier of a peer of the network.
///

125
core/src/tests/dummy_handler.rs
View File

@ -1,125 +0,0 @@
// Copyright 2018 Parity Technologies (UK) Ltd.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//! Concrete `NodeHandler` implementation and assorted testing types
use std::io::{self, Error as IoError};
use super::dummy_muxer::DummyMuxer;
use futures::prelude::*;
use crate::muxing::SubstreamRef;
use crate::nodes::handled_node::{HandledNode, NodeHandler, NodeHandlerEndpoint, NodeHandlerEvent};
use std::sync::Arc;
#[derive(Debug, PartialEq, Clone)]
pub(crate) struct Handler {
/// Inspect events passed through the Handler
pub events: Vec<InEvent>,
/// Current state of the Handler
pub state: Option<HandlerState>,
/// Next state for outbound streams of the Handler
pub next_outbound_state: Option<HandlerState>,
/// Vec of states the Handler will assume
pub next_states: Vec<HandlerState>,
}
impl Default for Handler {
fn default() -> Self {
Handler {
events: Vec::new(),
state: None,
next_states: Vec::new(),
next_outbound_state: None,
}
}
}
#[derive(Debug, PartialEq, Clone)]
pub(crate) enum HandlerState {
Ready(NodeHandlerEvent<usize, OutEvent>),
Err,
}
#[derive(Debug, PartialEq, Clone)]
pub(crate) enum InEvent {
/// A custom inbound event
Custom(&'static str),
/// A substream request with a dummy payload
Substream(Option<usize>),
/// Request the handler to move to the next state
NextState,
}
#[derive(Debug, PartialEq, Clone)]
pub(crate) enum OutEvent {
/// A message from the Handler upwards in the stack
Custom(&'static str),
}
// Concrete `HandledNode` parametrised for the test helpers
pub(crate) type TestHandledNode = HandledNode<DummyMuxer, Handler>;
impl NodeHandler for Handler {
type InEvent = InEvent;
type OutEvent = OutEvent;
type Error = IoError;
type OutboundOpenInfo = usize;
type Substream = SubstreamRef<Arc<DummyMuxer>>;
fn inject_substream(
&mut self,
_: Self::Substream,
endpoint: NodeHandlerEndpoint<Self::OutboundOpenInfo>,
) {
let user_data = match endpoint {
NodeHandlerEndpoint::Dialer(user_data) => Some(user_data),
NodeHandlerEndpoint::Listener => None,
};
self.events.push(InEvent::Substream(user_data));
}
fn inject_event(&mut self, inevent: Self::InEvent) {
self.events.push(inevent.clone());
match inevent {
InEvent::Custom(s) => {
self.state = Some(HandlerState::Ready(NodeHandlerEvent::Custom(
OutEvent::Custom(s),
)))
}
InEvent::Substream(Some(user_data)) => {
self.state = Some(HandlerState::Ready(
NodeHandlerEvent::OutboundSubstreamRequest(user_data),
))
}
InEvent::NextState => {
let next_state = self.next_states.pop();
self.state = next_state
}
_ => unreachable!(),
}
}
fn poll(&mut self) -> Poll<NodeHandlerEvent<usize, OutEvent>, IoError> {
match self.state.take() {
Some(ref state) => match state {
HandlerState::Ready(event) => Ok(Async::Ready(event.clone())),
HandlerState::Err => Err(io::Error::new(io::ErrorKind::Other, "oh noes")),
},
None => Ok(Async::NotReady),
}
}
}

122
core/src/tests/dummy_muxer.rs
View File

@ -1,122 +0,0 @@
// Copyright 2018 Parity Technologies (UK) Ltd.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//! `DummyMuxer` is a `StreamMuxer` to be used in tests. It implements a bare-bones
//! version of the trait along with a way to setup the muxer to behave in the
//! desired way when testing other components.
use futures::prelude::*;
use crate::muxing::StreamMuxer;
use std::io::Error as IoError;
/// Substream type
#[derive(Debug)]
pub struct DummySubstream {}
/// OutboundSubstream type
#[derive(Debug)]
pub struct DummyOutboundSubstream {}
/// Control the muxer state by setting the "connection" state as to set up a mock
/// muxer for higher level components.
#[derive(Debug, PartialEq, Clone)]
pub enum DummyConnectionState {
Pending, // use this to trigger the Async::NotReady code path
Opened, // use this to trigger the Async::Ready(_) code path
}
#[derive(Debug, PartialEq, Clone)]
struct DummyConnection {
state: DummyConnectionState,
}
/// `DummyMuxer` implements `StreamMuxer` and methods to control its behaviour when used in tests
#[derive(Debug, PartialEq, Clone)]
pub struct DummyMuxer{
in_connection: DummyConnection,
out_connection: DummyConnection,
}
impl DummyMuxer {
/// Create a new `DummyMuxer` where the inbound substream is set to `Pending`
/// and the (single) outbound substream to `Pending`.
pub fn new() -> Self {
DummyMuxer {
in_connection: DummyConnection {
state: DummyConnectionState::Pending,
},
out_connection: DummyConnection {
state: DummyConnectionState::Pending,
},
}
}
/// Set the muxer state inbound "connection" state
pub fn set_inbound_connection_state(&mut self, state: DummyConnectionState) {
self.in_connection.state = state
}
/// Set the muxer state outbound "connection" state
pub fn set_outbound_connection_state(&mut self, state: DummyConnectionState) {
self.out_connection.state = state
}
}
impl StreamMuxer for DummyMuxer {
type Substream = DummySubstream;
type OutboundSubstream = DummyOutboundSubstream;
type Error = IoError;
fn poll_inbound(&self) -> Poll<Self::Substream, IoError> {
match self.in_connection.state {
DummyConnectionState::Pending => Ok(Async::NotReady),
DummyConnectionState::Opened => Ok(Async::Ready(Self::Substream {})),
}
}
fn open_outbound(&self) -> Self::OutboundSubstream {
Self::OutboundSubstream {}
}
fn poll_outbound(
&self,
_substream: &mut Self::OutboundSubstream,
) -> Poll<Self::Substream, IoError> {
match self.out_connection.state {
DummyConnectionState::Pending => Ok(Async::NotReady),
DummyConnectionState::Opened => Ok(Async::Ready(Self::Substream {})),
}
}
fn destroy_outbound(&self, _: Self::OutboundSubstream) {}
fn read_substream(&self, _: &mut Self::Substream, _buf: &mut [u8]) -> Poll<usize, IoError> {
unreachable!()
}
fn write_substream(&self, _: &mut Self::Substream, _buf: &[u8]) -> Poll<usize, IoError> {
unreachable!()
}
fn flush_substream(&self, _: &mut Self::Substream) -> Poll<(), IoError> {
unreachable!()
}
fn shutdown_substream(&self, _: &mut Self::Substream) -> Poll<(), IoError> {
unreachable!()
}
fn destroy_substream(&self, _: Self::Substream) {}
fn is_remote_acknowledged(&self) -> bool { true }
fn close(&self) -> Poll<(), IoError> {
Ok(Async::Ready(()))
}
fn flush_all(&self) -> Poll<(), IoError> {
Ok(Async::Ready(()))
}
}

115
core/src/tests/dummy_transport.rs
View File

@ -1,115 +0,0 @@
// Copyright 2018 Parity Technologies (UK) Ltd.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//! `DummyTransport` is a `Transport` used in tests. It implements a bare-bones
//! version of the trait along with a way to setup the transport listeners with
//! an initial state to facilitate testing.
use futures::prelude::*;
use futures::{
future::{self, FutureResult},
stream,
};
use std::io;
use crate::{Multiaddr, PeerId, Transport, transport::{ListenerEvent, TransportError}};
use crate::tests::dummy_muxer::DummyMuxer;
#[derive(Debug, PartialEq, Clone)]
pub(crate) enum ListenerState {
Ok(Async<Option<ListenerEvent<(PeerId, DummyMuxer)>>>),
Error,
Events(Vec<ListenerEvent<(PeerId, DummyMuxer)>>)
}
#[derive(Debug, PartialEq, Clone)]
pub(crate) struct DummyTransport {
/// The current state of Listeners.
listener_state: ListenerState,
/// The next peer returned from dial().
next_peer_id: Option<PeerId>,
/// When true, all dial attempts return error.
dial_should_fail: bool,
}
impl DummyTransport {
pub(crate) fn new() -> Self {
DummyTransport {
listener_state: ListenerState::Ok(Async::NotReady),
next_peer_id: None,
dial_should_fail: false,
}
}
pub(crate) fn set_initial_listener_state(&mut self, state: ListenerState) {
self.listener_state = state;
}
pub(crate) fn set_next_peer_id(&mut self, peer_id: &PeerId) {
self.next_peer_id = Some(peer_id.clone());
}
pub(crate) fn make_dial_fail(&mut self) {
self.dial_should_fail = true;
}
}
impl Transport for DummyTransport {
type Output = (PeerId, DummyMuxer);
type Error = io::Error;
type Listener = Box<dyn Stream<Item=ListenerEvent<Self::ListenerUpgrade>, Error=io::Error> + Send>;
type ListenerUpgrade = FutureResult<Self::Output, io::Error>;
type Dial = Box<dyn Future<Item = Self::Output, Error = io::Error> + Send>;
fn listen_on(self, addr: Multiaddr) -> Result<Self::Listener, TransportError<Self::Error>>
where
Self: Sized,
{
match self.listener_state {
ListenerState::Ok(state) => match state {
Async::NotReady => Ok(Box::new(stream::poll_fn(|| Ok(Async::NotReady)))),
Async::Ready(Some(event)) => Ok(Box::new(stream::poll_fn(move || {
Ok(Async::Ready(Some(event.clone().map(future::ok))))
}))),
Async::Ready(None) => Ok(Box::new(stream::empty()))
},
ListenerState::Error => Err(TransportError::MultiaddrNotSupported(addr)),
ListenerState::Events(events) =>
Ok(Box::new(stream::iter_ok(events.into_iter().map(|e| e.map(future::ok)))))
}
}
fn dial(self, _addr: Multiaddr) -> Result<Self::Dial, TransportError<Self::Error>>
where
Self: Sized,
{
let peer_id = if let Some(peer_id) = self.next_peer_id {
peer_id
} else {
PeerId::random()
};
let fut =
if self.dial_should_fail {
let err_string = format!("unreachable host error, peer={:?}", peer_id);
future::err(io::Error::new(io::ErrorKind::Other, err_string))
} else {
future::ok((peer_id, DummyMuxer::new()))
};
Ok(Box::new(fut))
}
}

28
core/src/tests/mod.rs
View File

@ -1,28 +0,0 @@
// Copyright 2018 Parity Technologies (UK) Ltd.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
#[cfg(test)]
pub(crate) mod dummy_muxer;
#[cfg(test)]
pub(crate) mod dummy_transport;
#[cfg(test)]
pub(crate) mod dummy_handler;

88
core/src/transport/and_then.rs
View File

@ -23,9 +23,9 @@ use crate::{
either::EitherError,
transport::{Transport, TransportError, ListenerEvent}
};
use futures::{future::Either, prelude::*, try_ready};
use futures::{future::Either, prelude::*};
use multiaddr::Multiaddr;
use std::error;
use std::{error, pin::Pin, task::Context, task::Poll};
/// See the `Transport::and_then` method.
#[derive(Debug, Clone)]
@ -40,15 +40,18 @@ impl<T, C> AndThen<T, C> {
impl<T, C, F, O> Transport for AndThen<T, C>
where
T: Transport,
T::Dial: Unpin,
T::Listener: Unpin,
T::ListenerUpgrade: Unpin,
C: FnOnce(T::Output, ConnectedPoint) -> F + Clone,
F: IntoFuture<Item = O>,
F: TryFuture<Ok = O> + Unpin,
F::Error: error::Error,
{
type Output = O;
type Error = EitherError<T::Error, F::Error>;
type Listener = AndThenStream<T::Listener, C>;
type ListenerUpgrade = AndThenFuture<T::ListenerUpgrade, C, F::Future>;
type Dial = AndThenFuture<T::Dial, C, F::Future>;
type ListenerUpgrade = AndThenFuture<T::ListenerUpgrade, C, F>;
type Dial = AndThenFuture<T::Dial, C, F>;
fn listen_on(self, addr: Multiaddr) -> Result<Self::Listener, TransportError<Self::Error>> {
let listener = self.transport.listen_on(addr).map_err(|err| err.map(EitherError::A))?;
@ -63,7 +66,7 @@ where
fn dial(self, addr: Multiaddr) -> Result<Self::Dial, TransportError<Self::Error>> {
let dialed_fut = self.transport.dial(addr.clone()).map_err(|err| err.map(EitherError::A))?;
let future = AndThenFuture {
inner: Either::A(dialed_fut),
inner: Either::Left(dialed_fut),
args: Some((self.fun, ConnectedPoint::Dialer { address: addr }))
};
Ok(future)
@ -79,19 +82,24 @@ pub struct AndThenStream<TListener, TMap> {
fun: TMap
}
impl<TListener, TMap> Unpin for AndThenStream<TListener, TMap> {
}
impl<TListener, TMap, TTransOut, TMapOut, TListUpgr, TTransErr> Stream for AndThenStream<TListener, TMap>
where
TListener: Stream<Item = ListenerEvent<TListUpgr>, Error = TTransErr>,
TListUpgr: Future<Item = TTransOut, Error = TTransErr>,
TListener: TryStream<Ok = ListenerEvent<TListUpgr>, Error = TTransErr> + Unpin,
TListUpgr: TryFuture<Ok = TTransOut, Error = TTransErr>,
TMap: FnOnce(TTransOut, ConnectedPoint) -> TMapOut + Clone,
TMapOut: IntoFuture
TMapOut: TryFuture
{
type Item = ListenerEvent<AndThenFuture<TListUpgr, TMap, TMapOut::Future>>;
type Error = EitherError<TTransErr, TMapOut::Error>;
type Item = Result<
ListenerEvent<AndThenFuture<TListUpgr, TMap, TMapOut>>,
EitherError<TTransErr, TMapOut::Error>
>;
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
match self.stream.poll().map_err(EitherError::A)? {
Async::Ready(Some(event)) => {
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
match TryStream::try_poll_next(Pin::new(&mut self.stream), cx) {
Poll::Ready(Some(Ok(event))) => {
let event = match event {
ListenerEvent::Upgrade { upgrade, local_addr, remote_addr } => {
let point = ConnectedPoint::Listener {
@ -100,7 +108,7 @@ where
};
ListenerEvent::Upgrade {
upgrade: AndThenFuture {
inner: Either::A(upgrade),
inner: Either::Left(upgrade),
args: Some((self.fun.clone(), point))
},
local_addr,
@ -110,10 +118,11 @@ where
ListenerEvent::NewAddress(a) => ListenerEvent::NewAddress(a),
ListenerEvent::AddressExpired(a) => ListenerEvent::AddressExpired(a)
};
Ok(Async::Ready(Some(event)))
Poll::Ready(Some(Ok(event)))
}
Async::Ready(None) => Ok(Async::Ready(None)),
Async::NotReady => Ok(Async::NotReady)
Poll::Ready(Some(Err(err))) => Poll::Ready(Some(Err(EitherError::A(err)))),
Poll::Ready(None) => Poll::Ready(None),
Poll::Pending => Poll::Pending
}
}
}
@ -127,28 +136,39 @@ pub struct AndThenFuture<TFut, TMap, TMapOut> {
args: Option<(TMap, ConnectedPoint)>
}
impl<TFut, TMap, TMapOut> Future for AndThenFuture<TFut, TMap, TMapOut::Future>
where
TFut: Future,
TMap: FnOnce(TFut::Item, ConnectedPoint) -> TMapOut,
TMapOut: IntoFuture
{
type Item = <TMapOut::Future as Future>::Item;
type Error = EitherError<TFut::Error, TMapOut::Error>;
impl<TFut, TMap, TMapOut> Unpin for AndThenFuture<TFut, TMap, TMapOut> {
}
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
impl<TFut, TMap, TMapOut> Future for AndThenFuture<TFut, TMap, TMapOut>
where
TFut: TryFuture + Unpin,
TMap: FnOnce(TFut::Ok, ConnectedPoint) -> TMapOut,
TMapOut: TryFuture + Unpin
{
type Output = Result<TMapOut::Ok, EitherError<TFut::Error, TMapOut::Error>>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
loop {
let future = match self.inner {
Either::A(ref mut future) => {
let item = try_ready!(future.poll().map_err(EitherError::A));
let future = match (*self).inner {
Either::Left(ref mut future) => {
let item = match TryFuture::try_poll(Pin::new(future), cx) {
Poll::Ready(Ok(v)) => v,
Poll::Ready(Err(err)) => return Poll::Ready(Err(EitherError::A(err))),
Poll::Pending => return Poll::Pending,
};
let (f, a) = self.args.take().expect("AndThenFuture has already finished.");
f(item, a).into_future()
f(item, a)
}
Either::Right(ref mut future) => {
return match TryFuture::try_poll(Pin::new(future), cx) {
Poll::Ready(Ok(v)) => Poll::Ready(Ok(v)),
Poll::Ready(Err(err)) => return Poll::Ready(Err(EitherError::B(err))),
Poll::Pending => Poll::Pending,
}
}
Either::B(ref mut future) => return future.poll().map_err(EitherError::B)
};
self.inner = Either::B(future);
(*self).inner = Either::Right(future);
}
}
}

16
core/src/transport/boxed.rs
View File

@ -21,7 +21,7 @@
use crate::transport::{ListenerEvent, Transport, TransportError};
use futures::prelude::*;
use multiaddr::Multiaddr;
use std::{error, fmt, sync::Arc};
use std::{error, fmt, pin::Pin, sync::Arc};
/// See the `Transport::boxed` method.
#[inline]
@ -37,9 +37,9 @@ where
}
}
pub type Dial<O, E> = Box<dyn Future<Item = O, Error = E> + Send>;
pub type Listener<O, E> = Box<dyn Stream<Item = ListenerEvent<ListenerUpgrade<O, E>>, Error = E> + Send>;
pub type ListenerUpgrade<O, E> = Box<dyn Future<Item = O, Error = E> + Send>;
pub type Dial<O, E> = Pin<Box<dyn Future<Output = Result<O, E>> + Send>>;
pub type Listener<O, E> = Pin<Box<dyn Stream<Item = Result<ListenerEvent<ListenerUpgrade<O, E>>, E>> + Send>>;
pub type ListenerUpgrade<O, E> = Pin<Box<dyn Future<Output = Result<O, E>> + Send>>;
trait Abstract<O, E> {
fn listen_on(&self, addr: Multiaddr) -> Result<Listener<O, E>, TransportError<E>>;
@ -56,15 +56,15 @@ where
{
fn listen_on(&self, addr: Multiaddr) -> Result<Listener<O, E>, TransportError<E>> {
let listener = Transport::listen_on(self.clone(), addr)?;
let fut = listener.map(|event| event.map(|upgrade| {
Box::new(upgrade) as ListenerUpgrade<O, E>
let fut = listener.map_ok(|event| event.map(|upgrade| {
Box::pin(upgrade) as ListenerUpgrade<O, E>
}));
Ok(Box::new(fut) as Box<_>)
Ok(Box::pin(fut))
}
fn dial(&self, addr: Multiaddr) -> Result<Dial<O, E>, TransportError<E>> {
let fut = Transport::dial(self.clone(), addr)?;
Ok(Box::new(fut) as Box<_>)
Ok(Box::pin(fut) as Dial<_, _>)
}
}

47
core/src/transport/dummy.rs
View File

@ -20,7 +20,8 @@
use crate::transport::{Transport, TransportError, ListenerEvent};
use crate::Multiaddr;
use std::{fmt, io, marker::PhantomData};
use futures::{prelude::*, task::Context, task::Poll};
use std::{fmt, io, marker::PhantomData, pin::Pin};
/// Implementation of `Transport` that doesn't support any multiaddr.
///
@ -55,9 +56,9 @@ impl<TOut> Clone for DummyTransport<TOut> {
impl<TOut> Transport for DummyTransport<TOut> {
type Output = TOut;
type Error = io::Error;
type Listener = futures::stream::Empty<ListenerEvent<Self::ListenerUpgrade>, io::Error>;
type ListenerUpgrade = futures::future::Empty<Self::Output, io::Error>;
type Dial = futures::future::Empty<Self::Output, io::Error>;
type Listener = futures::stream::Pending<Result<ListenerEvent<Self::ListenerUpgrade>, io::Error>>;
type ListenerUpgrade = futures::future::Pending<Result<Self::Output, io::Error>>;
type Dial = futures::future::Pending<Result<Self::Output, io::Error>>;
fn listen_on(self, addr: Multiaddr) -> Result<Self::Listener, TransportError<Self::Error>> {
Err(TransportError::MultiaddrNotSupported(addr))
@ -68,7 +69,7 @@ impl<TOut> Transport for DummyTransport<TOut> {
}
}
/// Implementation of `Read` and `Write`. Not meant to be instanciated.
/// Implementation of `AsyncRead` and `AsyncWrite`. Not meant to be instanciated.
pub struct DummyStream(());
impl fmt::Debug for DummyStream {
@ -77,30 +78,30 @@ impl fmt::Debug for DummyStream {
}
}
impl io::Read for DummyStream {
fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
Err(io::ErrorKind::Other.into())
impl AsyncRead for DummyStream {
fn poll_read(self: Pin<&mut Self>, _: &mut Context, _: &mut [u8])
-> Poll<Result<usize, io::Error>>
{
Poll::Ready(Err(io::ErrorKind::Other.into()))
}
}
impl io::Write for DummyStream {
fn write(&mut self, _: &[u8]) -> io::Result<usize> {
Err(io::ErrorKind::Other.into())
impl AsyncWrite for DummyStream {
fn poll_write(self: Pin<&mut Self>, _: &mut Context, _: &[u8])
-> Poll<Result<usize, io::Error>>
{
Poll::Ready(Err(io::ErrorKind::Other.into()))
}
fn flush(&mut self) -> io::Result<()> {
Err(io::ErrorKind::Other.into())
fn poll_flush(self: Pin<&mut Self>, _: &mut Context)
-> Poll<Result<(), io::Error>>
{
Poll::Ready(Err(io::ErrorKind::Other.into()))
}
}
impl tokio_io::AsyncRead for DummyStream {
unsafe fn prepare_uninitialized_buffer(&self, _: &mut [u8]) -> bool {
false
}
}
impl tokio_io::AsyncWrite for DummyStream {
fn shutdown(&mut self) -> futures::Poll<(), io::Error> {
Err(io::ErrorKind::Other.into())
fn poll_close(self: Pin<&mut Self>, _: &mut Context)
-> Poll<Result<(), io::Error>>
{
Poll::Ready(Err(io::ErrorKind::Other.into()))
}
}

50
core/src/transport/map.rs
View File

@ -22,8 +22,9 @@ use crate::{
ConnectedPoint,
transport::{Transport, TransportError, ListenerEvent}
};
use futures::{prelude::*, try_ready};
use futures::prelude::*;
use multiaddr::Multiaddr;
use std::{pin::Pin, task::Context, task::Poll};
/// See `Transport::map`.
#[derive(Debug, Copy, Clone)]
@ -61,21 +62,22 @@ where
/// Custom `Stream` implementation to avoid boxing.
///
/// Maps a function over every stream item.
#[pin_project::pin_project]
#[derive(Clone, Debug)]
pub struct MapStream<T, F> { stream: T, fun: F }
pub struct MapStream<T, F> { #[pin] stream: T, fun: F }
impl<T, F, A, B, X> Stream for MapStream<T, F>
where
T: Stream<Item = ListenerEvent<X>>,
X: Future<Item = A>,
T: TryStream<Ok = ListenerEvent<X>>,
X: TryFuture<Ok = A>,
F: FnOnce(A, ConnectedPoint) -> B + Clone
{
type Item = ListenerEvent<MapFuture<X, F>>;
type Error = T::Error;
type Item = Result<ListenerEvent<MapFuture<X, F>>, T::Error>;
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
match self.stream.poll()? {
Async::Ready(Some(event)) => {
fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
let this = self.project();
match TryStream::try_poll_next(this.stream, cx) {
Poll::Ready(Some(Ok(event))) => {
let event = match event {
ListenerEvent::Upgrade { upgrade, local_addr, remote_addr } => {
let point = ConnectedPoint::Listener {
@ -85,7 +87,7 @@ where
ListenerEvent::Upgrade {
upgrade: MapFuture {
inner: upgrade,
args: Some((self.fun.clone(), point))
args: Some((this.fun.clone(), point))
},
local_addr,
remote_addr
@ -94,10 +96,11 @@ where
ListenerEvent::NewAddress(a) => ListenerEvent::NewAddress(a),
ListenerEvent::AddressExpired(a) => ListenerEvent::AddressExpired(a)
};
Ok(Async::Ready(Some(event)))
Poll::Ready(Some(Ok(event)))
}
Async::Ready(None) => Ok(Async::Ready(None)),
Async::NotReady => Ok(Async::NotReady)
Poll::Ready(Some(Err(err))) => Poll::Ready(Some(Err(err))),
Poll::Ready(None) => Poll::Ready(None),
Poll::Pending => Poll::Pending
}
}
}
@ -105,24 +108,29 @@ where
/// Custom `Future` to avoid boxing.
///
/// Applies a function to the inner future's result.
#[pin_project::pin_project]
#[derive(Clone, Debug)]
pub struct MapFuture<T, F> {
#[pin]
inner: T,
args: Option<(F, ConnectedPoint)>
}
impl<T, A, F, B> Future for MapFuture<T, F>
where
T: Future<Item = A>,
T: TryFuture<Ok = A>,
F: FnOnce(A, ConnectedPoint) -> B
{
type Item = B;
type Error = T::Error;
type Output = Result<B, T::Error>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
let item = try_ready!(self.inner.poll());
let (f, a) = self.args.take().expect("MapFuture has already finished.");
Ok(Async::Ready(f(item, a)))
fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
let this = self.project();
let item = match TryFuture::try_poll(this.inner, cx) {
Poll::Pending => return Poll::Pending,
Poll::Ready(Ok(v)) => v,
Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
};
let (f, a) = this.args.take().expect("MapFuture has already finished.");
Poll::Ready(Ok(f(item, a)))
}
}

67
core/src/transport/map_err.rs
View File

@ -21,7 +21,7 @@
use crate::transport::{Transport, TransportError, ListenerEvent};
use futures::prelude::*;
use multiaddr::Multiaddr;
use std::error;
use std::{error, pin::Pin, task::Context, task::Poll};
/// See `Transport::map_err`.
#[derive(Debug, Copy, Clone)]
@ -67,7 +67,9 @@ where
}
/// Listening stream for `MapErr`.
#[pin_project::pin_project]
pub struct MapErrListener<T: Transport, F> {
#[pin]
inner: T::Listener,
map: F,
}
@ -78,29 +80,32 @@ where
F: FnOnce(T::Error) -> TErr + Clone,
TErr: error::Error,
{
type Item = ListenerEvent<MapErrListenerUpgrade<T, F>>;
type Error = TErr;
type Item = Result<ListenerEvent<MapErrListenerUpgrade<T, F>>, TErr>;
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
match self.inner.poll() {
Ok(Async::Ready(Some(event))) => {
fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
let this = self.project();
match TryStream::try_poll_next(this.inner, cx) {
Poll::Ready(Some(Ok(event))) => {
let map = &*this.map;
let event = event.map(move |value| {
MapErrListenerUpgrade {
inner: value,
map: Some(self.map.clone())
map: Some(map.clone())
}
});
Ok(Async::Ready(Some(event)))
Poll::Ready(Some(Ok(event)))
}
Ok(Async::Ready(None)) => Ok(Async::Ready(None)),
Ok(Async::NotReady) => Ok(Async::NotReady),
Err(err) => Err((self.map.clone())(err)),
Poll::Ready(None) => Poll::Ready(None),
Poll::Pending => Poll::Pending,
Poll::Ready(Some(Err(err))) => Poll::Ready(Some(Err((this.map.clone())(err)))),
}
}
}
/// Listening upgrade future for `MapErr`.
#[pin_project::pin_project]
pub struct MapErrListenerUpgrade<T: Transport, F> {
#[pin]
inner: T::ListenerUpgrade,
map: Option<F>,
}
@ -109,23 +114,25 @@ impl<T, F, TErr> Future for MapErrListenerUpgrade<T, F>
where T: Transport,
F: FnOnce(T::Error) -> TErr,
{
type Item = T::Output;
type Error = TErr;
type Output = Result<T::Output, TErr>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
match self.inner.poll() {
Ok(Async::Ready(value)) => Ok(Async::Ready(value)),
Ok(Async::NotReady) => Ok(Async::NotReady),
Err(err) => {
let map = self.map.take().expect("poll() called again after error");
Err(map(err))
fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
let this = self.project();
match Future::poll(this.inner, cx) {
Poll::Ready(Ok(value)) => Poll::Ready(Ok(value)),
Poll::Pending => Poll::Pending,
Poll::Ready(Err(err)) => {
let map = this.map.take().expect("poll() called again after error");
Poll::Ready(Err(map(err)))
}
}
}
}
/// Dialing future for `MapErr`.
#[pin_project::pin_project]
pub struct MapErrDial<T: Transport, F> {
#[pin]
inner: T::Dial,
map: Option<F>,
}
@ -135,18 +142,16 @@ where
T: Transport,
F: FnOnce(T::Error) -> TErr,
{
type Item = T::Output;
type Error = TErr;
type Output = Result<T::Output, TErr>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
match self.inner.poll() {
Ok(Async::Ready(value)) => {
Ok(Async::Ready(value))
},
Ok(Async::NotReady) => Ok(Async::NotReady),
Err(err) => {
let map = self.map.take().expect("poll() called again after error");
Err(map(err))
fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
let this = self.project();
match Future::poll(this.inner, cx) {
Poll::Ready(Ok(value)) => Poll::Ready(Ok(value)),
Poll::Pending => Poll::Pending,
Poll::Ready(Err(err)) => {
let map = this.map.take().expect("poll() called again after error");
Poll::Ready(Err(map(err)))
}
}
}

119
core/src/transport/memory.rs
View File

@ -19,17 +19,16 @@
// DEALINGS IN THE SOFTWARE.
use crate::{Transport, transport::{TransportError, ListenerEvent}};
use bytes::{Bytes, IntoBuf};
use fnv::FnvHashMap;
use futures::{future::{self, FutureResult}, prelude::*, sync::mpsc, try_ready};
use futures::{future::{self, Ready}, prelude::*, channel::mpsc, task::Context, task::Poll};
use lazy_static::lazy_static;
use multiaddr::{Protocol, Multiaddr};
use parking_lot::Mutex;
use rw_stream_sink::RwStreamSink;
use std::{collections::hash_map::Entry, error, fmt, io, num::NonZeroU64};
use std::{collections::hash_map::Entry, error, fmt, io, num::NonZeroU64, pin::Pin};
lazy_static! {
static ref HUB: Mutex<FnvHashMap<NonZeroU64, mpsc::Sender<Channel<Bytes>>>> =
static ref HUB: Mutex<FnvHashMap<NonZeroU64, mpsc::Sender<Channel<Vec<u8>>>>> =
Mutex::new(FnvHashMap::default());
}
@ -39,40 +38,38 @@ pub struct MemoryTransport;
/// Connection to a `MemoryTransport` currently being opened.
pub struct DialFuture {
sender: mpsc::Sender<Channel<Bytes>>,
channel_to_send: Option<Channel<Bytes>>,
channel_to_return: Option<Channel<Bytes>>,
sender: mpsc::Sender<Channel<Vec<u8>>>,
channel_to_send: Option<Channel<Vec<u8>>>,
channel_to_return: Option<Channel<Vec<u8>>>,
}
impl Future for DialFuture {
type Item = Channel<Bytes>;
type Error = MemoryTransportError;
type Output = Result<Channel<Vec<u8>>, MemoryTransportError>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
if let Some(c) = self.channel_to_send.take() {
match self.sender.start_send(c) {
Err(_) => return Err(MemoryTransportError::Unreachable),
Ok(AsyncSink::NotReady(t)) => {
self.channel_to_send = Some(t);
return Ok(Async::NotReady)
},
_ => (),
}
fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
match self.sender.poll_ready(cx) {
Poll::Pending => return Poll::Pending,
Poll::Ready(Ok(())) => {},
Poll::Ready(Err(_)) => return Poll::Ready(Err(MemoryTransportError::Unreachable)),
}
match self.sender.close() {
Err(_) => Err(MemoryTransportError::Unreachable),
Ok(Async::NotReady) => Ok(Async::NotReady),
Ok(Async::Ready(_)) => Ok(Async::Ready(self.channel_to_return.take()
.expect("Future should not be polled again once complete"))),
let channel_to_send = self.channel_to_send.take()
.expect("Future should not be polled again once complete");
match self.sender.start_send(channel_to_send) {
Err(_) => return Poll::Ready(Err(MemoryTransportError::Unreachable)),
Ok(()) => {}
}
Poll::Ready(Ok(self.channel_to_return.take()
.expect("Future should not be polled again once complete")))
}
}
impl Transport for MemoryTransport {
type Output = Channel<Bytes>;
type Output = Channel<Vec<u8>>;
type Error = MemoryTransportError;
type Listener = Listener;
type ListenerUpgrade = FutureResult<Self::Output, Self::Error>;
type ListenerUpgrade = Ready<Result<Self::Output, Self::Error>>;
type Dial = DialFuture;
fn listen_on(self, addr: Multiaddr) -> Result<Self::Listener, TransportError<Self::Error>> {
@ -170,32 +167,33 @@ pub struct Listener {
/// The address we are listening on.
addr: Multiaddr,
/// Receives incoming connections.
receiver: mpsc::Receiver<Channel<Bytes>>,
receiver: mpsc::Receiver<Channel<Vec<u8>>>,
/// Generate `ListenerEvent::NewAddress` to inform about our listen address.
tell_listen_addr: bool
}
impl Stream for Listener {
type Item = ListenerEvent<FutureResult<Channel<Bytes>, MemoryTransportError>>;
type Error = MemoryTransportError;
type Item = Result<ListenerEvent<Ready<Result<Channel<Vec<u8>>, MemoryTransportError>>>, MemoryTransportError>;
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
if self.tell_listen_addr {
self.tell_listen_addr = false;
return Ok(Async::Ready(Some(ListenerEvent::NewAddress(self.addr.clone()))))
return Poll::Ready(Some(Ok(ListenerEvent::NewAddress(self.addr.clone()))))
}
let channel = try_ready!(Ok(self.receiver.poll()
.expect("Life listeners always have a sender.")));
let channel = match channel {
Some(c) => c,
None => return Ok(Async::Ready(None))
let channel = match Stream::poll_next(Pin::new(&mut self.receiver), cx) {
Poll::Pending => return Poll::Pending,
Poll::Ready(None) => panic!("Alive listeners always have a sender."),
Poll::Ready(Some(v)) => v,
};
let event = ListenerEvent::Upgrade {
upgrade: future::ok(channel),
upgrade: future::ready(Ok(channel)),
local_addr: self.addr.clone(),
remote_addr: Protocol::Memory(self.port.get()).into()
};
Ok(Async::Ready(Some(event)))
Poll::Ready(Some(Ok(event)))
}
}
@ -231,43 +229,48 @@ pub type Channel<T> = RwStreamSink<Chan<T>>;
/// A channel represents an established, in-memory, logical connection between two endpoints.
///
/// Implements `Sink` and `Stream`.
pub struct Chan<T = Bytes> {
pub struct Chan<T = Vec<u8>> {
incoming: mpsc::Receiver<T>,
outgoing: mpsc::Sender<T>,
}
impl<T> Stream for Chan<T> {
type Item = T;
type Error = io::Error;
impl<T> Unpin for Chan<T> {
}
#[inline]
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
self.incoming.poll().map_err(|()| io::ErrorKind::BrokenPipe.into())
impl<T> Stream for Chan<T> {
type Item = Result<T, io::Error>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
match Stream::poll_next(Pin::new(&mut self.incoming), cx) {
Poll::Pending => Poll::Pending,
Poll::Ready(None) => Poll::Ready(Some(Err(io::ErrorKind::BrokenPipe.into()))),
Poll::Ready(Some(v)) => Poll::Ready(Some(Ok(v))),
}
}
}
impl<T> Sink for Chan<T> {
type SinkItem = T;
type SinkError = io::Error;
impl<T> Sink<T> for Chan<T> {
type Error = io::Error;
#[inline]
fn start_send(&mut self, item: Self::SinkItem) -> StartSend<Self::SinkItem, Self::SinkError> {
fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
self.outgoing.poll_ready(cx)
.map(|v| v.map_err(|_| io::ErrorKind::BrokenPipe.into()))
}
fn start_send(mut self: Pin<&mut Self>, item: T) -> Result<(), Self::Error> {
self.outgoing.start_send(item).map_err(|_| io::ErrorKind::BrokenPipe.into())
}
#[inline]
fn poll_complete(&mut self) -> Poll<(), Self::SinkError> {
self.outgoing.poll_complete().map_err(|_| io::ErrorKind::BrokenPipe.into())
fn poll_flush(self: Pin<&mut Self>, _: &mut Context) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
#[inline]
fn close(&mut self) -> Poll<(), Self::SinkError> {
self.outgoing.close().map_err(|_| io::ErrorKind::BrokenPipe.into())
fn poll_close(self: Pin<&mut Self>, _: &mut Context) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(()))
}
}
impl<T: IntoBuf> Into<RwStreamSink<Chan<T>>> for Chan<T> {
#[inline]
impl<T: AsRef<[u8]>> Into<RwStreamSink<Chan<T>>> for Chan<T> {
fn into(self) -> RwStreamSink<Chan<T>> {
RwStreamSink::new(self)
}

10
core/src/transport/mod.rs
View File

@ -91,7 +91,7 @@ pub trait Transport {
/// transport stack. The item must be a [`ListenerUpgrade`](Transport::ListenerUpgrade) future
/// that resolves to an [`Output`](Transport::Output) value once all protocol upgrades
/// have been applied.
type Listener: Stream<Item = ListenerEvent<Self::ListenerUpgrade>, Error = Self::Error>;
type Listener: TryStream<Ok = ListenerEvent<Self::ListenerUpgrade>, Error = Self::Error>;
/// A pending [`Output`](Transport::Output) for an inbound connection,
/// obtained from the [`Listener`](Transport::Listener) stream.
@ -102,11 +102,11 @@ pub trait Transport {
/// connection, hence further connection setup proceeds asynchronously.
/// Once a `ListenerUpgrade` future resolves it yields the [`Output`](Transport::Output)
/// of the connection setup process.
type ListenerUpgrade: Future<Item = Self::Output, Error = Self::Error>;
type ListenerUpgrade: Future<Output = Result<Self::Output, Self::Error>>;
/// A pending [`Output`](Transport::Output) for an outbound connection,
/// obtained from [dialing](Transport::dial).
type Dial: Future<Item = Self::Output, Error = Self::Error>;
type Dial: Future<Output = Result<Self::Output, Self::Error>>;
/// Listens on the given [`Multiaddr`], producing a stream of pending, inbound connections
/// and addresses this transport is listening on (cf. [`ListenerEvent`]).
@ -175,8 +175,8 @@ pub trait Transport {
where
Self: Sized,
C: FnOnce(Self::Output, ConnectedPoint) -> F + Clone,
F: IntoFuture<Item = O>,
<F as IntoFuture>::Error: Error + 'static
F: TryFuture<Ok = O>,
<F as TryFuture>::Error: Error + 'static
{
and_then::AndThen::new(self, f)
}

104
core/src/transport/timeout.rs
View File

@ -25,11 +25,9 @@
// TODO: add example
use crate::{Multiaddr, Transport, transport::{TransportError, ListenerEvent}};
use futures::{try_ready, Async, Future, Poll, Stream};
use log::debug;
use std::{error, fmt, time::Duration};
use wasm_timer::Timeout;
use wasm_timer::timeout::Error as TimeoutError;
use futures::prelude::*;
use futures_timer::Delay;
use std::{error, fmt, io, pin::Pin, task::Context, task::Poll, time::Duration};
/// A `TransportTimeout` is a `Transport` that wraps another `Transport` and adds
/// timeouts to all inbound and outbound connection attempts.
@ -80,8 +78,8 @@ where
type Output = InnerTrans::Output;
type Error = TransportTimeoutError<InnerTrans::Error>;
type Listener = TimeoutListener<InnerTrans::Listener>;
type ListenerUpgrade = TokioTimerMapErr<Timeout<InnerTrans::ListenerUpgrade>>;
type Dial = TokioTimerMapErr<Timeout<InnerTrans::Dial>>;
type ListenerUpgrade = Timeout<InnerTrans::ListenerUpgrade>;
type Dial = Timeout<InnerTrans::Dial>;
fn listen_on(self, addr: Multiaddr) -> Result<Self::Listener, TransportError<Self::Error>> {
let listener = self.inner.listen_on(addr)
@ -98,36 +96,47 @@ where
fn dial(self, addr: Multiaddr) -> Result<Self::Dial, TransportError<Self::Error>> {
let dial = self.inner.dial(addr)
.map_err(|err| err.map(TransportTimeoutError::Other))?;
Ok(TokioTimerMapErr {
inner: Timeout::new(dial, self.outgoing_timeout),
Ok(Timeout {
inner: dial,
timer: Delay::new(self.outgoing_timeout),
})
}
}
// TODO: can be removed and replaced with an `impl Stream` once impl Trait is fully stable
// in Rust (https://github.com/rust-lang/rust/issues/34511)
#[pin_project::pin_project]
pub struct TimeoutListener<InnerStream> {
#[pin]
inner: InnerStream,
timeout: Duration,
}
impl<InnerStream, O> Stream for TimeoutListener<InnerStream>
where
InnerStream: Stream<Item = ListenerEvent<O>>
InnerStream: TryStream<Ok = ListenerEvent<O>>,
{
type Item = ListenerEvent<TokioTimerMapErr<Timeout<O>>>;
type Error = TransportTimeoutError<InnerStream::Error>;
type Item = Result<ListenerEvent<Timeout<O>>, TransportTimeoutError<InnerStream::Error>>;
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
let poll_out = try_ready!(self.inner.poll().map_err(TransportTimeoutError::Other));
if let Some(event) = poll_out {
let event = event.map(move |inner_fut| {
TokioTimerMapErr { inner: Timeout::new(inner_fut, self.timeout) }
});
Ok(Async::Ready(Some(event)))
} else {
Ok(Async::Ready(None))
}
fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
let this = self.project();
let poll_out = match TryStream::try_poll_next(this.inner, cx) {
Poll::Ready(Some(Err(err))) => return Poll::Ready(Some(Err(TransportTimeoutError::Other(err)))),
Poll::Ready(Some(Ok(v))) => v,
Poll::Ready(None) => return Poll::Ready(None),
Poll::Pending => return Poll::Pending,
};
let timeout = *this.timeout;
let event = poll_out.map(move |inner_fut| {
Timeout {
inner: inner_fut,
timer: Delay::new(timeout),
}
});
Poll::Ready(Some(Ok(event)))
}
}
@ -135,41 +144,48 @@ where
/// `TransportTimeoutError<Err>`.
// TODO: can be replaced with `impl Future` once `impl Trait` are fully stable in Rust
// (https://github.com/rust-lang/rust/issues/34511)
#[pin_project::pin_project]
#[must_use = "futures do nothing unless polled"]
pub struct TokioTimerMapErr<InnerFut> {
pub struct Timeout<InnerFut> {
#[pin]
inner: InnerFut,
timer: Delay,
}
impl<InnerFut, TErr> Future for TokioTimerMapErr<InnerFut>
impl<InnerFut> Future for Timeout<InnerFut>
where
InnerFut: Future<Error = TimeoutError<TErr>>,
InnerFut: TryFuture,
{
type Item = InnerFut::Item;
type Error = TransportTimeoutError<TErr>;
type Output = Result<InnerFut::Ok, TransportTimeoutError<InnerFut::Error>>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
self.inner.poll().map_err(|err: TimeoutError<TErr>| {
if err.is_inner() {
TransportTimeoutError::Other(err.into_inner().expect("ensured by is_inner()"))
} else if err.is_elapsed() {
debug!("timeout elapsed for connection");
TransportTimeoutError::Timeout
} else {
assert!(err.is_timer());
debug!("tokio timer error in timeout wrapper");
TransportTimeoutError::TimerError
}
})
fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
// It is debatable whether we should poll the inner future first or the timer first.
// For example, if you start dialing with a timeout of 10 seconds, then after 15 seconds
// the dialing succeeds on the wire, then after 20 seconds you poll, then depending on
// which gets polled first, the outcome will be success or failure.
let mut this = self.project();
match TryFuture::try_poll(this.inner, cx) {
Poll::Pending => {},
Poll::Ready(Ok(v)) => return Poll::Ready(Ok(v)),
Poll::Ready(Err(err)) => return Poll::Ready(Err(TransportTimeoutError::Other(err))),
}
match Pin::new(&mut this.timer).poll(cx) {
Poll::Pending => Poll::Pending,
Poll::Ready(()) => Poll::Ready(Err(TransportTimeoutError::Timeout))
}
}
}
/// Error that can be produced by the `TransportTimeout` layer.
#[derive(Debug, Copy, Clone)]
#[derive(Debug)]
pub enum TransportTimeoutError<TErr> {
/// The transport timed out.
Timeout,
/// An error happened in the timer.
TimerError,
TimerError(io::Error),
/// Other kind of error.
Other(TErr),
}
@ -180,7 +196,7 @@ where TErr: fmt::Display,
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
TransportTimeoutError::Timeout => write!(f, "Timeout has been reached"),
TransportTimeoutError::TimerError => write!(f, "Error in the timer"),
TransportTimeoutError::TimerError(err) => write!(f, "Error in the timer: {}", err),
TransportTimeoutError::Other(err) => write!(f, "{}", err),
}
}
@ -192,7 +208,7 @@ where TErr: error::Error + 'static,
fn source(&self) -> Option<&(dyn error::Error + 'static)> {
match self {
TransportTimeoutError::Timeout => None,
TransportTimeoutError::TimerError => None,
TransportTimeoutError::TimerError(err) => Some(err),
TransportTimeoutError::Other(err) => Some(err),
}
}

179
core/src/transport/upgrade.rs
View File

@ -43,10 +43,9 @@ use crate::{
InboundUpgradeApply
}
};
use futures::{future, prelude::*, try_ready};
use futures::{prelude::*, ready};
use multiaddr::Multiaddr;
use std::{error::Error, fmt};
use tokio_io::{AsyncRead, AsyncWrite};
use std::{error::Error, fmt, pin::Pin, task::Context, task::Poll};
/// A `Builder` facilitates upgrading of a [`Transport`] for use with
/// a [`Network`].
@ -101,9 +100,12 @@ where
AndThen<T, impl FnOnce(C, ConnectedPoint) -> Authenticate<C, U> + Clone>
> where
T: Transport<Output = C>,
T::Dial: Unpin,
T::Listener: Unpin,
T::ListenerUpgrade: Unpin,
I: ConnectionInfo,
C: AsyncRead + AsyncWrite,
D: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
D: AsyncRead + AsyncWrite + Unpin,
U: InboundUpgrade<C, Output = (I, D), Error = E>,
U: OutboundUpgrade<C, Output = (I, D), Error = E> + Clone,
E: Error + 'static,
@ -130,8 +132,11 @@ where
pub fn apply<C, D, U, I, E>(self, upgrade: U) -> Builder<Upgrade<T, U>>
where
T: Transport<Output = (I, C)>,
C: AsyncRead + AsyncWrite,
D: AsyncRead + AsyncWrite,
T::Dial: Unpin,
T::Listener: Unpin,
T::ListenerUpgrade: Unpin,
C: AsyncRead + AsyncWrite + Unpin,
D: AsyncRead + AsyncWrite + Unpin,
I: ConnectionInfo,
U: InboundUpgrade<C, Output = D, Error = E>,
U: OutboundUpgrade<C, Output = D, Error = E> + Clone,
@ -155,7 +160,10 @@ where
-> AndThen<T, impl FnOnce((I, C), ConnectedPoint) -> Multiplex<C, U, I> + Clone>
where
T: Transport<Output = (I, C)>,
C: AsyncRead + AsyncWrite,
T::Dial: Unpin,
T::Listener: Unpin,
T::ListenerUpgrade: Unpin,
C: AsyncRead + AsyncWrite + Unpin,
M: StreamMuxer,
I: ConnectionInfo,
U: InboundUpgrade<C, Output = M, Error = E>,
@ -176,7 +184,7 @@ where
/// Configured through [`Builder::authenticate`].
pub struct Authenticate<C, U>
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
U: InboundUpgrade<C> + OutboundUpgrade<C>
{
inner: EitherUpgrade<C, U>
@ -184,17 +192,16 @@ where
impl<C, U> Future for Authenticate<C, U>
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
U: InboundUpgrade<C> + OutboundUpgrade<C,
Output = <U as InboundUpgrade<C>>::Output,
Error = <U as InboundUpgrade<C>>::Error
>
{
type Item = <EitherUpgrade<C, U> as Future>::Item;
type Error = <EitherUpgrade<C, U> as Future>::Error;
type Output = <EitherUpgrade<C, U> as Future>::Output;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
self.inner.poll()
fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
Future::poll(Pin::new(&mut self.inner), cx)
}
}
@ -204,7 +211,7 @@ where
/// Configured through [`Builder::multiplex`].
pub struct Multiplex<C, U, I>
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
U: InboundUpgrade<C> + OutboundUpgrade<C>,
{
info: Option<I>,
@ -213,20 +220,29 @@ where
impl<C, U, I, M, E> Future for Multiplex<C, U, I>
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
U: InboundUpgrade<C, Output = M, Error = E>,
U: OutboundUpgrade<C, Output = M, Error = E>
{
type Item = (I, M);
type Error = UpgradeError<E>;
type Output = Result<(I, M), UpgradeError<E>>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
let m = try_ready!(self.upgrade.poll());
fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
let m = match ready!(Future::poll(Pin::new(&mut self.upgrade), cx)) {
Ok(m) => m,
Err(err) => return Poll::Ready(Err(err)),
};
let i = self.info.take().expect("Multiplex future polled after completion.");
Ok(Async::Ready((i, m)))
Poll::Ready(Ok((i, m)))
}
}
impl<C, U, I> Unpin for Multiplex<C, U, I>
where
C: AsyncRead + AsyncWrite + Unpin,
U: InboundUpgrade<C> + OutboundUpgrade<C>,
{
}
/// An inbound or outbound upgrade.
type EitherUpgrade<C, U> = future::Either<InboundUpgradeApply<C, U>, OutboundUpgradeApply<C, U>>;
@ -245,8 +261,11 @@ impl<T, U> Upgrade<T, U> {
impl<T, C, D, U, I, E> Transport for Upgrade<T, U>
where
T: Transport<Output = (I, C)>,
T::Dial: Unpin,
T::Listener: Unpin,
T::ListenerUpgrade: Unpin,
T::Error: 'static,
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
U: InboundUpgrade<C, Output = D, Error = E>,
U: OutboundUpgrade<C, Output = D, Error = E> + Clone,
E: Error + 'static
@ -262,7 +281,7 @@ where
.map_err(|err| err.map(TransportUpgradeError::Transport))?;
Ok(DialUpgradeFuture {
future,
upgrade: future::Either::A(Some(self.upgrade))
upgrade: future::Either::Left(Some(self.upgrade))
})
}
@ -315,7 +334,7 @@ where
pub struct DialUpgradeFuture<F, U, I, C>
where
U: OutboundUpgrade<C>,
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
{
future: F,
upgrade: future::Either<Option<U>, (Option<I>, OutboundUpgradeApply<C, U>)>
@ -323,32 +342,48 @@ where
impl<F, U, I, C, D> Future for DialUpgradeFuture<F, U, I, C>
where
F: Future<Item = (I, C)>,
C: AsyncRead + AsyncWrite,
F: TryFuture<Ok = (I, C)> + Unpin,
C: AsyncRead + AsyncWrite + Unpin,
U: OutboundUpgrade<C, Output = D>,
U::Error: Error
{
type Item = (I, D);
type Error = TransportUpgradeError<F::Error, U::Error>;
type Output = Result<(I, D), TransportUpgradeError<F::Error, U::Error>>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
// We use a `this` variable because the compiler can't mutably borrow multiple times
// accross a `Deref`.
let this = &mut *self;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
loop {
self.upgrade = match self.upgrade {
future::Either::A(ref mut up) => {
let (i, c) = try_ready!(self.future.poll().map_err(TransportUpgradeError::Transport));
let u = up.take().expect("DialUpgradeFuture is constructed with Either::A(Some).");
future::Either::B((Some(i), apply_outbound(c, u, upgrade::Version::V1)))
this.upgrade = match this.upgrade {
future::Either::Left(ref mut up) => {
let (i, c) = match ready!(TryFuture::try_poll(Pin::new(&mut this.future), cx).map_err(TransportUpgradeError::Transport)) {
Ok(v) => v,
Err(err) => return Poll::Ready(Err(err)),
};
let u = up.take().expect("DialUpgradeFuture is constructed with Either::Left(Some).");
future::Either::Right((Some(i), apply_outbound(c, u, upgrade::Version::V1)))
}
future::Either::B((ref mut i, ref mut up)) => {
let d = try_ready!(up.poll().map_err(TransportUpgradeError::Upgrade));
future::Either::Right((ref mut i, ref mut up)) => {
let d = match ready!(Future::poll(Pin::new(up), cx).map_err(TransportUpgradeError::Upgrade)) {
Ok(d) => d,
Err(err) => return Poll::Ready(Err(err)),
};
let i = i.take().expect("DialUpgradeFuture polled after completion.");
return Ok(Async::Ready((i, d)))
return Poll::Ready(Ok((i, d)))
}
}
}
}
}
impl<F, U, I, C> Unpin for DialUpgradeFuture<F, U, I, C>
where
U: OutboundUpgrade<C>,
C: AsyncRead + AsyncWrite + Unpin,
{
}
/// The [`Transport::Listener`] stream of an [`Upgrade`]d transport.
pub struct ListenerStream<S, U> {
stream: S,
@ -357,34 +392,39 @@ pub struct ListenerStream<S, U> {
impl<S, U, F, I, C, D> Stream for ListenerStream<S, U>
where
S: Stream<Item = ListenerEvent<F>>,
F: Future<Item = (I, C)>,
C: AsyncRead + AsyncWrite,
S: TryStream<Ok = ListenerEvent<F>> + Unpin,
F: TryFuture<Ok = (I, C)>,
C: AsyncRead + AsyncWrite + Unpin,
U: InboundUpgrade<C, Output = D> + Clone
{
type Item = ListenerEvent<ListenerUpgradeFuture<F, U, I, C>>;
type Error = TransportUpgradeError<S::Error, U::Error>;
type Item = Result<ListenerEvent<ListenerUpgradeFuture<F, U, I, C>>, TransportUpgradeError<S::Error, U::Error>>;
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
match try_ready!(self.stream.poll().map_err(TransportUpgradeError::Transport)) {
Some(event) => {
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
match ready!(TryStream::try_poll_next(Pin::new(&mut self.stream), cx)) {
Some(Ok(event)) => {
let event = event.map(move |future| {
ListenerUpgradeFuture {
future,
upgrade: future::Either::A(Some(self.upgrade.clone()))
upgrade: future::Either::Left(Some(self.upgrade.clone()))
}
});
Ok(Async::Ready(Some(event)))
Poll::Ready(Some(Ok(event)))
}
None => Ok(Async::Ready(None))
Some(Err(err)) => {
Poll::Ready(Some(Err(TransportUpgradeError::Transport(err))))
}
None => Poll::Ready(None)
}
}
}
impl<S, U> Unpin for ListenerStream<S, U> {
}
/// The [`Transport::ListenerUpgrade`] future of an [`Upgrade`]d transport.
pub struct ListenerUpgradeFuture<F, U, I, C>
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
U: InboundUpgrade<C>
{
future: F,
@ -393,29 +433,44 @@ where
impl<F, U, I, C, D> Future for ListenerUpgradeFuture<F, U, I, C>
where
F: Future<Item = (I, C)>,
C: AsyncRead + AsyncWrite,
F: TryFuture<Ok = (I, C)> + Unpin,
C: AsyncRead + AsyncWrite + Unpin,
U: InboundUpgrade<C, Output = D>,
U::Error: Error
{
type Item = (I, D);
type Error = TransportUpgradeError<F::Error, U::Error>;
type Output = Result<(I, D), TransportUpgradeError<F::Error, U::Error>>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
// We use a `this` variable because the compiler can't mutably borrow multiple times
// accross a `Deref`.
let this = &mut *self;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
loop {
self.upgrade = match self.upgrade {
future::Either::A(ref mut up) => {
let (i, c) = try_ready!(self.future.poll().map_err(TransportUpgradeError::Transport));
let u = up.take().expect("ListenerUpgradeFuture is constructed with Either::A(Some).");
future::Either::B((Some(i), apply_inbound(c, u)))
this.upgrade = match this.upgrade {
future::Either::Left(ref mut up) => {
let (i, c) = match ready!(TryFuture::try_poll(Pin::new(&mut this.future), cx).map_err(TransportUpgradeError::Transport)) {
Ok(v) => v,
Err(err) => return Poll::Ready(Err(err))
};
let u = up.take().expect("ListenerUpgradeFuture is constructed with Either::Left(Some).");
future::Either::Right((Some(i), apply_inbound(c, u)))
}
future::Either::B((ref mut i, ref mut up)) => {
let d = try_ready!(up.poll().map_err(TransportUpgradeError::Upgrade));
future::Either::Right((ref mut i, ref mut up)) => {
let d = match ready!(TryFuture::try_poll(Pin::new(up), cx).map_err(TransportUpgradeError::Upgrade)) {
Ok(v) => v,
Err(err) => return Poll::Ready(Err(err))
};
let i = i.take().expect("ListenerUpgradeFuture polled after completion.");
return Ok(Async::Ready((i, d)))
return Poll::Ready(Ok((i, d)))
}
}
}
}
}
impl<F, U, I, C> Unpin for ListenerUpgradeFuture<F, U, I, C>
where
C: AsyncRead + AsyncWrite + Unpin,
U: InboundUpgrade<C>
{
}

116
core/src/upgrade/apply.rs
View File

@ -19,13 +19,11 @@
// DEALINGS IN THE SOFTWARE.
use crate::ConnectedPoint;
use crate::upgrade::{InboundUpgrade, OutboundUpgrade, UpgradeError};
use crate::upgrade::ProtocolName;
use futures::{future::Either, prelude::*};
use crate::upgrade::{InboundUpgrade, OutboundUpgrade, UpgradeError, ProtocolName};
use futures::{future::Either, prelude::*, compat::Compat, compat::Compat01As03, compat::Future01CompatExt};
use log::debug;
use multistream_select::{self, DialerSelectFuture, ListenerSelectFuture};
use std::{iter, mem};
use tokio_io::{AsyncRead, AsyncWrite};
use std::{iter, mem, pin::Pin, task::Context, task::Poll};
pub use multistream_select::Version;
@ -33,24 +31,24 @@ pub use multistream_select::Version;
pub fn apply<C, U>(conn: C, up: U, cp: ConnectedPoint, v: Version)
-> Either<InboundUpgradeApply<C, U>, OutboundUpgradeApply<C, U>>
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
U: InboundUpgrade<C> + OutboundUpgrade<C>,
{
if cp.is_listener() {
Either::A(apply_inbound(conn, up))
Either::Left(apply_inbound(conn, up))
} else {
Either::B(apply_outbound(conn, up, v))
Either::Right(apply_outbound(conn, up, v))
}
}
/// Tries to perform an upgrade on an inbound connection or substream.
pub fn apply_inbound<C, U>(conn: C, up: U) -> InboundUpgradeApply<C, U>
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
U: InboundUpgrade<C>,
{
let iter = up.protocol_info().into_iter().map(NameWrap as fn(_) -> NameWrap<_>);
let future = multistream_select::listener_select_proto(conn, iter);
let future = multistream_select::listener_select_proto(Compat::new(conn), iter).compat();
InboundUpgradeApply {
inner: InboundUpgradeApplyState::Init { future, upgrade: up }
}
@ -59,11 +57,11 @@ where
/// Tries to perform an upgrade on an outbound connection or substream.
pub fn apply_outbound<C, U>(conn: C, up: U, v: Version) -> OutboundUpgradeApply<C, U>
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
U: OutboundUpgrade<C>
{
let iter = up.protocol_info().into_iter().map(NameWrap as fn(_) -> NameWrap<_>);
let future = multistream_select::dialer_select_proto(conn, iter, v);
let future = multistream_select::dialer_select_proto(Compat::new(conn), iter, v).compat();
OutboundUpgradeApply {
inner: OutboundUpgradeApplyState::Init { future, upgrade: up }
}
@ -72,7 +70,7 @@ where
/// Future returned by `apply_inbound`. Drives the upgrade process.
pub struct InboundUpgradeApply<C, U>
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
U: InboundUpgrade<C>
{
inner: InboundUpgradeApplyState<C, U>
@ -80,11 +78,11 @@ where
enum InboundUpgradeApplyState<C, U>
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
U: InboundUpgrade<C>,
{
Init {
future: ListenerSelectFuture<C, NameWrap<U::Info>>,
future: Compat01As03<ListenerSelectFuture<Compat<C>, NameWrap<U::Info>>>,
upgrade: U,
},
Upgrade {
@ -93,42 +91,49 @@ where
Undefined
}
impl<C, U> Future for InboundUpgradeApply<C, U>
impl<C, U> Unpin for InboundUpgradeApply<C, U>
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
U: InboundUpgrade<C>,
{
type Item = U::Output;
type Error = UpgradeError<U::Error>;
}
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
impl<C, U> Future for InboundUpgradeApply<C, U>
where
C: AsyncRead + AsyncWrite + Unpin,
U: InboundUpgrade<C>,
U::Future: Unpin,
{
type Output = Result<U::Output, UpgradeError<U::Error>>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
loop {
match mem::replace(&mut self.inner, InboundUpgradeApplyState::Undefined) {
InboundUpgradeApplyState::Init { mut future, upgrade } => {
let (info, io) = match future.poll()? {
Async::Ready(x) => x,
Async::NotReady => {
let (info, io) = match Future::poll(Pin::new(&mut future), cx)? {
Poll::Ready(x) => x,
Poll::Pending => {
self.inner = InboundUpgradeApplyState::Init { future, upgrade };
return Ok(Async::NotReady)
return Poll::Pending
}
};
self.inner = InboundUpgradeApplyState::Upgrade {
future: upgrade.upgrade_inbound(io, info.0)
future: upgrade.upgrade_inbound(Compat01As03::new(io), info.0)
};
}
InboundUpgradeApplyState::Upgrade { mut future } => {
match future.poll() {
Ok(Async::NotReady) => {
match Future::poll(Pin::new(&mut future), cx) {
Poll::Pending => {
self.inner = InboundUpgradeApplyState::Upgrade { future };
return Ok(Async::NotReady)
return Poll::Pending
}
Ok(Async::Ready(x)) => {
Poll::Ready(Ok(x)) => {
debug!("Successfully applied negotiated protocol");
return Ok(Async::Ready(x))
return Poll::Ready(Ok(x))
}
Err(e) => {
Poll::Ready(Err(e)) => {
debug!("Failed to apply negotiated protocol");
return Err(UpgradeError::Apply(e))
return Poll::Ready(Err(UpgradeError::Apply(e)))
}
}
}
@ -142,7 +147,7 @@ where
/// Future returned by `apply_outbound`. Drives the upgrade process.
pub struct OutboundUpgradeApply<C, U>
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
U: OutboundUpgrade<C>
{
inner: OutboundUpgradeApplyState<C, U>
@ -150,11 +155,11 @@ where
enum OutboundUpgradeApplyState<C, U>
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
U: OutboundUpgrade<C>
{
Init {
future: DialerSelectFuture<C, NameWrapIter<<U::InfoIter as IntoIterator>::IntoIter>>,
future: Compat01As03<DialerSelectFuture<Compat<C>, NameWrapIter<<U::InfoIter as IntoIterator>::IntoIter>>>,
upgrade: U
},
Upgrade {
@ -163,42 +168,49 @@ where
Undefined
}
impl<C, U> Unpin for OutboundUpgradeApply<C, U>
where
C: AsyncRead + AsyncWrite + Unpin,
U: OutboundUpgrade<C>,
{
}
impl<C, U> Future for OutboundUpgradeApply<C, U>
where
C: AsyncRead + AsyncWrite,
U: OutboundUpgrade<C>
C: AsyncRead + AsyncWrite + Unpin,
U: OutboundUpgrade<C>,
U::Future: Unpin,
{
type Item = U::Output;
type Error = UpgradeError<U::Error>;
type Output = Result<U::Output, UpgradeError<U::Error>>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
loop {
match mem::replace(&mut self.inner, OutboundUpgradeApplyState::Undefined) {
OutboundUpgradeApplyState::Init { mut future, upgrade } => {
let (info, connection) = match future.poll()? {
Async::Ready(x) => x,
Async::NotReady => {
let (info, connection) = match Future::poll(Pin::new(&mut future), cx)? {
Poll::Ready(x) => x,
Poll::Pending => {
self.inner = OutboundUpgradeApplyState::Init { future, upgrade };
return Ok(Async::NotReady)
return Poll::Pending
}
};
self.inner = OutboundUpgradeApplyState::Upgrade {
future: upgrade.upgrade_outbound(connection, info.0)
future: upgrade.upgrade_outbound(Compat01As03::new(connection), info.0)
};
}
OutboundUpgradeApplyState::Upgrade { mut future } => {
match future.poll() {
Ok(Async::NotReady) => {
match Future::poll(Pin::new(&mut future), cx) {
Poll::Pending => {
self.inner = OutboundUpgradeApplyState::Upgrade { future };
return Ok(Async::NotReady)
return Poll::Pending
}
Ok(Async::Ready(x)) => {
Poll::Ready(Ok(x)) => {
debug!("Successfully applied negotiated protocol");
return Ok(Async::Ready(x))
return Poll::Ready(Ok(x))
}
Err(e) => {
Poll::Ready(Err(e)) => {
debug!("Failed to apply negotiated protocol");
return Err(UpgradeError::Apply(e))
return Poll::Ready(Err(UpgradeError::Apply(e)));
}
}
}

11
core/src/upgrade/denied.rs
View File

@ -18,9 +18,9 @@
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
use crate::Negotiated;
use crate::upgrade::{InboundUpgrade, OutboundUpgrade, UpgradeInfo};
use futures::future;
use multistream_select::Negotiated;
use std::iter;
use void::Void;
@ -41,20 +41,19 @@ impl UpgradeInfo for DeniedUpgrade {
impl<C> InboundUpgrade<C> for DeniedUpgrade {
type Output = Void;
type Error = Void;
type Future = future::Empty<Self::Output, Self::Error>;
type Future = future::Pending<Result<Self::Output, Self::Error>>;
fn upgrade_inbound(self, _: Negotiated<C>, _: Self::Info) -> Self::Future {
future::empty()
future::pending()
}
}
impl<C> OutboundUpgrade<C> for DeniedUpgrade {
type Output = Void;
type Error = Void;
type Future = future::Empty<Self::Output, Self::Error>;
type Future = future::Pending<Result<Self::Output, Self::Error>>;
fn upgrade_outbound(self, _: Negotiated<C>, _: Self::Info) -> Self::Future {
future::empty()
future::pending()
}
}

2
core/src/upgrade/either.rs
View File

@ -19,10 +19,10 @@
// DEALINGS IN THE SOFTWARE.
use crate::{
Negotiated,
either::{EitherOutput, EitherError, EitherFuture2, EitherName},
upgrade::{InboundUpgrade, OutboundUpgrade, UpgradeInfo}
};
use multistream_select::Negotiated;
/// A type to represent two possible upgrade types (inbound or outbound).
#[derive(Debug, Clone)]

54
core/src/upgrade/map.rs
View File

@ -18,9 +18,10 @@
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
use crate::Negotiated;
use crate::upgrade::{InboundUpgrade, OutboundUpgrade, UpgradeInfo};
use futures::{prelude::*, try_ready};
use multistream_select::Negotiated;
use futures::prelude::*;
use std::{pin::Pin, task::Context, task::Poll};
/// Wraps around an upgrade and applies a closure to the output.
#[derive(Debug, Clone)]
@ -63,7 +64,7 @@ where
impl<C, U, F> OutboundUpgrade<C> for MapInboundUpgrade<U, F>
where
U: OutboundUpgrade<C>
U: OutboundUpgrade<C>,
{
type Output = U::Output;
type Error = U::Error;
@ -98,7 +99,7 @@ where
impl<C, U, F> InboundUpgrade<C> for MapOutboundUpgrade<U, F>
where
U: InboundUpgrade<C>
U: InboundUpgrade<C>,
{
type Output = U::Output;
type Error = U::Error;
@ -167,7 +168,7 @@ where
impl<C, U, F> OutboundUpgrade<C> for MapInboundUpgradeErr<U, F>
where
U: OutboundUpgrade<C>
U: OutboundUpgrade<C>,
{
type Output = U::Output;
type Error = U::Error;
@ -230,46 +231,55 @@ where
}
}
#[pin_project::pin_project]
pub struct MapFuture<TInnerFut, TMap> {
#[pin]
inner: TInnerFut,
map: Option<TMap>,
}
impl<TInnerFut, TIn, TMap, TOut> Future for MapFuture<TInnerFut, TMap>
where
TInnerFut: Future<Item = TIn>,
TInnerFut: TryFuture<Ok = TIn>,
TMap: FnOnce(TIn) -> TOut,
{
type Item = TOut;
type Error = TInnerFut::Error;
type Output = Result<TOut, TInnerFut::Error>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
let item = try_ready!(self.inner.poll());
let map = self.map.take().expect("Future has already finished");
Ok(Async::Ready(map(item)))
fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
let this = self.project();
let item = match TryFuture::try_poll(this.inner, cx) {
Poll::Ready(Ok(v)) => v,
Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
Poll::Pending => return Poll::Pending,
};
let map = this.map.take().expect("Future has already finished");
Poll::Ready(Ok(map(item)))
}
}
#[pin_project::pin_project]
pub struct MapErrFuture<T, F> {
#[pin]
fut: T,
fun: Option<F>,
}
impl<T, E, F, A> Future for MapErrFuture<T, F>
where
T: Future<Error = E>,
T: TryFuture<Error = E>,
F: FnOnce(E) -> A,
{
type Item = T::Item;
type Error = A;
type Output = Result<T::Ok, A>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
match self.fut.poll() {
Ok(Async::NotReady) => Ok(Async::NotReady),
Ok(Async::Ready(x)) => Ok(Async::Ready(x)),
Err(e) => {
let f = self.fun.take().expect("Future has not resolved yet");
Err(f(e))
fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
let this = self.project();
match TryFuture::try_poll(this.fut, cx) {
Poll::Pending => Poll::Pending,
Poll::Ready(Ok(x)) => Poll::Ready(Ok(x)),
Poll::Ready(Err(e)) => {
let f = this.fun.take().expect("Future has not resolved yet");
Poll::Ready(Err(f(e)))
}
}
}

9
core/src/upgrade/mod.rs
View File

@ -68,7 +68,8 @@ mod transfer;
use futures::future::Future;
pub use multistream_select::{Version, Negotiated, NegotiatedComplete, NegotiationError, ProtocolError};
pub use crate::Negotiated;
pub use multistream_select::{Version, NegotiatedComplete, NegotiationError, ProtocolError};
pub use self::{
apply::{apply, apply_inbound, apply_outbound, InboundUpgradeApply, OutboundUpgradeApply},
denied::DeniedUpgrade,
@ -77,7 +78,7 @@ pub use self::{
map::{MapInboundUpgrade, MapOutboundUpgrade, MapInboundUpgradeErr, MapOutboundUpgradeErr},
optional::OptionalUpgrade,
select::SelectUpgrade,
transfer::{write_one, WriteOne, read_one, ReadOne, read_one_then, ReadOneThen, ReadOneError, request_response, RequestResponse, read_respond, ReadRespond},
transfer::{write_one, write_with_len_prefix, write_varint, read_one, ReadOneError, read_varint},
};
/// Types serving as protocol names.
@ -143,7 +144,7 @@ pub trait InboundUpgrade<C>: UpgradeInfo {
/// Possible error during the handshake.
type Error;
/// Future that performs the handshake with the remote.
type Future: Future<Item = Self::Output, Error = Self::Error>;
type Future: Future<Output = Result<Self::Output, Self::Error>> + Unpin;
/// After we have determined that the remote supports one of the protocols we support, this
/// method is called to start the handshake.
@ -183,7 +184,7 @@ pub trait OutboundUpgrade<C>: UpgradeInfo {
/// Possible error during the handshake.
type Error;
/// Future that performs the handshake with the remote.
type Future: Future<Item = Self::Output, Error = Self::Error>;
type Future: Future<Output = Result<Self::Output, Self::Error>> + Unpin;
/// After we have determined that the remote supports one of the protocols we support, this
/// method is called to start the handshake.

2
core/src/upgrade/optional.rs
View File

@ -19,7 +19,7 @@
// DEALINGS IN THE SOFTWARE.
use crate::upgrade::{InboundUpgrade, OutboundUpgrade, UpgradeInfo};
use multistream_select::Negotiated;
use crate::Negotiated;
/// Upgrade that can be disabled at runtime.
///

2
core/src/upgrade/select.rs
View File

@ -19,10 +19,10 @@
// DEALINGS IN THE SOFTWARE.
use crate::{
Negotiated,
either::{EitherOutput, EitherError, EitherFuture2, EitherName},
upgrade::{InboundUpgrade, OutboundUpgrade, UpgradeInfo}
};
use multistream_select::Negotiated;
/// Upgrade that combines two upgrades into one. Supports all the protocols supported by either
/// sub-upgrade.

490
core/src/upgrade/transfer.rs
View File

@ -20,104 +20,93 @@
//! Contains some helper futures for creating upgrades.
use futures::{prelude::*, try_ready};
use std::{cmp, error, fmt, io::Cursor, mem};
use tokio_io::{io, AsyncRead, AsyncWrite};
use futures::prelude::*;
use std::{error, fmt, io};
// TODO: these methods could be on an Ext trait to AsyncWrite
/// Send a message to the given socket, then shuts down the writing side.
///
/// > **Note**: Prepends a variable-length prefix indicate the length of the message. This is
/// > compatible with what `read_one` expects.
pub fn write_one<TSocket, TData>(socket: TSocket, data: TData) -> WriteOne<TSocket, TData>
where
TSocket: AsyncWrite,
TData: AsRef<[u8]>,
pub async fn write_one(socket: &mut (impl AsyncWrite + Unpin), data: impl AsRef<[u8]>)
-> Result<(), io::Error>
{
let len_data = build_int_buffer(data.as_ref().len());
WriteOne {
inner: WriteOneInner::WriteLen(io::write_all(socket, len_data), data),
}
write_varint(socket, data.as_ref().len()).await?;
socket.write_all(data.as_ref()).await?;
socket.close().await?;
Ok(())
}
/// Builds a buffer that contains the given integer encoded as variable-length.
fn build_int_buffer(num: usize) -> io::Window<[u8; 10]> {
let mut len_data = unsigned_varint::encode::u64_buffer();
let encoded_len = unsigned_varint::encode::u64(num as u64, &mut len_data).len();
let mut len_data = io::Window::new(len_data);
len_data.set_end(encoded_len);
len_data
}
/// Future that makes `write_one` work.
#[derive(Debug)]
pub struct WriteOne<TSocket, TData = Vec<u8>> {
inner: WriteOneInner<TSocket, TData>,
}
#[derive(Debug)]
enum WriteOneInner<TSocket, TData> {
/// We need to write the data length to the socket.
WriteLen(io::WriteAll<TSocket, io::Window<[u8; 10]>>, TData),
/// We need to write the actual data to the socket.
Write(io::WriteAll<TSocket, TData>),
/// We need to shut down the socket.
Shutdown(io::Shutdown<TSocket>),
/// A problem happened during the processing.
Poisoned,
}
impl<TSocket, TData> Future for WriteOne<TSocket, TData>
where
TSocket: AsyncWrite,
TData: AsRef<[u8]>,
/// Send a message to the given socket with a length prefix appended to it. Also flushes the socket.
///
/// > **Note**: Prepends a variable-length prefix indicate the length of the message. This is
/// > compatible with what `read_one` expects.
pub async fn write_with_len_prefix(socket: &mut (impl AsyncWrite + Unpin), data: impl AsRef<[u8]>)
-> Result<(), io::Error>
{
type Item = ();
type Error = std::io::Error;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
Ok(self.inner.poll()?.map(|_socket| ()))
}
write_varint(socket, data.as_ref().len()).await?;
socket.write_all(data.as_ref()).await?;
socket.flush().await?;
Ok(())
}
impl<TSocket, TData> Future for WriteOneInner<TSocket, TData>
where
TSocket: AsyncWrite,
TData: AsRef<[u8]>,
/// Writes a variable-length integer to the `socket`.
///
/// > **Note**: Does **NOT** flush the socket.
pub async fn write_varint(socket: &mut (impl AsyncWrite + Unpin), len: usize)
-> Result<(), io::Error>
{
type Item = TSocket;
type Error = std::io::Error;
let mut len_data = unsigned_varint::encode::usize_buffer();
let encoded_len = unsigned_varint::encode::usize(len, &mut len_data).len();
socket.write_all(&len_data[..encoded_len]).await?;
Ok(())
}
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
loop {
match mem::replace(self, WriteOneInner::Poisoned) {
WriteOneInner::WriteLen(mut inner, data) => match inner.poll()? {
Async::Ready((socket, _)) => {
*self = WriteOneInner::Write(io::write_all(socket, data));
}
Async::NotReady => {
*self = WriteOneInner::WriteLen(inner, data);
}
},
WriteOneInner::Write(mut inner) => match inner.poll()? {
Async::Ready((socket, _)) => {
*self = WriteOneInner::Shutdown(tokio_io::io::shutdown(socket));
}
Async::NotReady => {
*self = WriteOneInner::Write(inner);
}
},
WriteOneInner::Shutdown(ref mut inner) => {
let socket = try_ready!(inner.poll());
return Ok(Async::Ready(socket));
/// Reads a variable-length integer from the `socket`.
///
/// As a special exception, if the `socket` is empty and EOFs right at the beginning, then we
/// return `Ok(0)`.
///
/// > **Note**: This function reads bytes one by one from the `socket`. It is therefore encouraged
/// > to use some sort of buffering mechanism.
pub async fn read_varint(socket: &mut (impl AsyncRead + Unpin)) -> Result<usize, io::Error> {
let mut buffer = unsigned_varint::encode::usize_buffer();
let mut buffer_len = 0;
loop {
match socket.read(&mut buffer[buffer_len..buffer_len+1]).await? {
0 => {
// Reaching EOF before finishing to read the length is an error, unless the EOF is
// at the very beginning of the substream, in which case we assume that the data is
// empty.
if buffer_len == 0 {
return Ok(0);
} else {
return Err(io::ErrorKind::UnexpectedEof.into());
}
WriteOneInner::Poisoned => panic!(),
}
n => debug_assert_eq!(n, 1),
}
buffer_len += 1;
match unsigned_varint::decode::usize(&buffer[..buffer_len]) {
Ok((len, _)) => return Ok(len),
Err(unsigned_varint::decode::Error::Overflow) => {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"overflow in variable-length integer"
));
}
// TODO: why do we have a `__Nonexhaustive` variant in the error? I don't know how to process it
// Err(unsigned_varint::decode::Error::Insufficient) => {}
Err(_) => {}
}
}
}
/// Reads a message from the given socket. Only one message is processed and the socket is dropped,
/// because we assume that the socket will not send anything more.
/// Reads a length-prefixed message from the given socket.
///
/// The `max_size` parameter is the maximum size in bytes of the message that we accept. This is
/// necessary in order to avoid DoS attacks where the remote sends us a message of several
@ -125,137 +114,20 @@ where
///
/// > **Note**: Assumes that a variable-length prefix indicates the length of the message. This is
/// > compatible with what `write_one` does.
pub fn read_one<TSocket>(
socket: TSocket,
max_size: usize,
) -> ReadOne<TSocket>
pub async fn read_one(socket: &mut (impl AsyncRead + Unpin), max_size: usize)
-> Result<Vec<u8>, ReadOneError>
{
ReadOne {
inner: ReadOneInner::ReadLen {
socket,
len_buf: Cursor::new([0; 10]),
max_size,
},
let len = read_varint(socket).await?;
if len > max_size {
return Err(ReadOneError::TooLarge {
requested: len,
max: max_size,
});
}
}
/// Future that makes `read_one` work.
#[derive(Debug)]
pub struct ReadOne<TSocket> {
inner: ReadOneInner<TSocket>,
}
#[derive(Debug)]
enum ReadOneInner<TSocket> {
// We need to read the data length from the socket.
ReadLen {
socket: TSocket,
/// A small buffer where we will right the variable-length integer representing the
/// length of the actual packet.
len_buf: Cursor<[u8; 10]>,
max_size: usize,
},
// We need to read the actual data from the socket.
ReadRest(io::ReadExact<TSocket, io::Window<Vec<u8>>>),
/// A problem happened during the processing.
Poisoned,
}
impl<TSocket> Future for ReadOne<TSocket>
where
TSocket: AsyncRead,
{
type Item = Vec<u8>;
type Error = ReadOneError;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
Ok(self.inner.poll()?.map(|(_, out)| out))
}
}
impl<TSocket> Future for ReadOneInner<TSocket>
where
TSocket: AsyncRead,
{
type Item = (TSocket, Vec<u8>);
type Error = ReadOneError;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
loop {
match mem::replace(self, ReadOneInner::Poisoned) {
ReadOneInner::ReadLen {
mut socket,
mut len_buf,
max_size,
} => {
match socket.read_buf(&mut len_buf)? {
Async::Ready(num_read) => {
// Reaching EOF before finishing to read the length is an error, unless
// the EOF is at the very beginning of the substream, in which case we
// assume that the data is empty.
if num_read == 0 {
if len_buf.position() == 0 {
return Ok(Async::Ready((socket, Vec::new())));
} else {
return Err(ReadOneError::Io(
std::io::ErrorKind::UnexpectedEof.into(),
));
}
}
let len_buf_with_data =
&len_buf.get_ref()[..len_buf.position() as usize];
if let Ok((len, data_start)) =
unsigned_varint::decode::usize(len_buf_with_data)
{
if len >= max_size {
return Err(ReadOneError::TooLarge {
requested: len,
max: max_size,
});
}
// Create `data_buf` containing the start of the data that was
// already in `len_buf`.
let n = cmp::min(data_start.len(), len);
let mut data_buf = vec![0; len];
data_buf[.. n].copy_from_slice(&data_start[.. n]);
let mut data_buf = io::Window::new(data_buf);
data_buf.set_start(data_start.len());
*self = ReadOneInner::ReadRest(io::read_exact(socket, data_buf));
} else {
*self = ReadOneInner::ReadLen {
socket,
len_buf,
max_size,
};
}
}
Async::NotReady => {
*self = ReadOneInner::ReadLen {
socket,
len_buf,
max_size,
};
return Ok(Async::NotReady);
}
}
}
ReadOneInner::ReadRest(mut inner) => {
match inner.poll()? {
Async::Ready((socket, data)) => {
return Ok(Async::Ready((socket, data.into_inner())));
}
Async::NotReady => {
*self = ReadOneInner::ReadRest(inner);
return Ok(Async::NotReady);
}
}
}
ReadOneInner::Poisoned => panic!(),
}
}
}
let mut buf = vec![0; len];
socket.read_exact(&mut buf).await?;
Ok(buf)
}
/// Error while reading one message.
@ -296,194 +168,9 @@ impl error::Error for ReadOneError {
}
}
/// Similar to `read_one`, but applies a transformation on the output buffer.
///
/// > **Note**: The `param` parameter is an arbitrary value that will be passed back to `then`.
/// > This parameter is normally not necessary, as we could just pass a closure that has
/// > ownership of any data we want. In practice, though, this would make the
/// > `ReadRespond` type impossible to express as a concrete type. Once the `impl Trait`
/// > syntax is allowed within traits, we can remove this parameter.
pub fn read_one_then<TSocket, TParam, TThen, TOut, TErr>(
socket: TSocket,
max_size: usize,
param: TParam,
then: TThen,
) -> ReadOneThen<TSocket, TParam, TThen>
where
TSocket: AsyncRead,
TThen: FnOnce(Vec<u8>, TParam) -> Result<TOut, TErr>,
TErr: From<ReadOneError>,
{
ReadOneThen {
inner: read_one(socket, max_size),
then: Some((param, then)),
}
}
/// Future that makes `read_one_then` work.
#[derive(Debug)]
pub struct ReadOneThen<TSocket, TParam, TThen> {
inner: ReadOne<TSocket>,
then: Option<(TParam, TThen)>,
}
impl<TSocket, TParam, TThen, TOut, TErr> Future for ReadOneThen<TSocket, TParam, TThen>
where
TSocket: AsyncRead,
TThen: FnOnce(Vec<u8>, TParam) -> Result<TOut, TErr>,
TErr: From<ReadOneError>,
{
type Item = TOut;
type Error = TErr;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
match self.inner.poll()? {
Async::Ready(buffer) => {
let (param, then) = self.then.take()
.expect("Future was polled after it was finished");
Ok(Async::Ready(then(buffer, param)?))
},
Async::NotReady => Ok(Async::NotReady),
}
}
}
/// Similar to `read_one`, but applies a transformation on the output buffer.
///
/// > **Note**: The `param` parameter is an arbitrary value that will be passed back to `then`.
/// > This parameter is normally not necessary, as we could just pass a closure that has
/// > ownership of any data we want. In practice, though, this would make the
/// > `ReadRespond` type impossible to express as a concrete type. Once the `impl Trait`
/// > syntax is allowed within traits, we can remove this parameter.
pub fn read_respond<TSocket, TThen, TParam, TOut, TErr>(
socket: TSocket,
max_size: usize,
param: TParam,
then: TThen,
) -> ReadRespond<TSocket, TParam, TThen>
where
TSocket: AsyncRead,
TThen: FnOnce(TSocket, Vec<u8>, TParam) -> Result<TOut, TErr>,
TErr: From<ReadOneError>,
{
ReadRespond {
inner: read_one(socket, max_size).inner,
then: Some((then, param)),
}
}
/// Future that makes `read_respond` work.
#[derive(Debug)]
pub struct ReadRespond<TSocket, TParam, TThen> {
inner: ReadOneInner<TSocket>,
then: Option<(TThen, TParam)>,
}
impl<TSocket, TThen, TParam, TOut, TErr> Future for ReadRespond<TSocket, TParam, TThen>
where
TSocket: AsyncRead,
TThen: FnOnce(TSocket, Vec<u8>, TParam) -> Result<TOut, TErr>,
TErr: From<ReadOneError>,
{
type Item = TOut;
type Error = TErr;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
match self.inner.poll()? {
Async::Ready((socket, buffer)) => {
let (then, param) = self.then.take().expect("Future was polled after it was finished");
Ok(Async::Ready(then(socket, buffer, param)?))
},
Async::NotReady => Ok(Async::NotReady),
}
}
}
/// Send a message to the given socket, then shuts down the writing side, then reads an answer.
///
/// This combines `write_one` followed with `read_one_then`.
///
/// > **Note**: The `param` parameter is an arbitrary value that will be passed back to `then`.
/// > This parameter is normally not necessary, as we could just pass a closure that has
/// > ownership of any data we want. In practice, though, this would make the
/// > `ReadRespond` type impossible to express as a concrete type. Once the `impl Trait`
/// > syntax is allowed within traits, we can remove this parameter.
pub fn request_response<TSocket, TData, TParam, TThen, TOut, TErr>(
socket: TSocket,
data: TData,
max_size: usize,
param: TParam,
then: TThen,
) -> RequestResponse<TSocket, TParam, TThen, TData>
where
TSocket: AsyncRead + AsyncWrite,
TData: AsRef<[u8]>,
TThen: FnOnce(Vec<u8>, TParam) -> Result<TOut, TErr>,
{
RequestResponse {
inner: RequestResponseInner::Write(write_one(socket, data).inner, max_size, param, then),
}
}
/// Future that makes `request_response` work.
#[derive(Debug)]
pub struct RequestResponse<TSocket, TParam, TThen, TData = Vec<u8>> {
inner: RequestResponseInner<TSocket, TData, TParam, TThen>,
}
#[derive(Debug)]
enum RequestResponseInner<TSocket, TData, TParam, TThen> {
// We need to write data to the socket.
Write(WriteOneInner<TSocket, TData>, usize, TParam, TThen),
// We need to read the message.
Read(ReadOneThen<TSocket, TParam, TThen>),
// An error happened during the processing.
Poisoned,
}
impl<TSocket, TData, TParam, TThen, TOut, TErr> Future for RequestResponse<TSocket, TParam, TThen, TData>
where
TSocket: AsyncRead + AsyncWrite,
TData: AsRef<[u8]>,
TThen: FnOnce(Vec<u8>, TParam) -> Result<TOut, TErr>,
TErr: From<ReadOneError>,
{
type Item = TOut;
type Error = TErr;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
loop {
match mem::replace(&mut self.inner, RequestResponseInner::Poisoned) {
RequestResponseInner::Write(mut inner, max_size, param, then) => {
match inner.poll().map_err(ReadOneError::Io)? {
Async::Ready(socket) => {
self.inner =
RequestResponseInner::Read(read_one_then(socket, max_size, param, then));
}
Async::NotReady => {
self.inner = RequestResponseInner::Write(inner, max_size, param, then);
return Ok(Async::NotReady);
}
}
}
RequestResponseInner::Read(mut inner) => match inner.poll()? {
Async::Ready(packet) => return Ok(Async::Ready(packet)),
Async::NotReady => {
self.inner = RequestResponseInner::Read(inner);
return Ok(Async::NotReady);
}
},
RequestResponseInner::Poisoned => panic!(),
};
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::{self, Cursor};
use tokio::runtime::current_thread::Runtime;
#[test]
fn write_one_works() {
@ -492,14 +179,17 @@ mod tests {
.collect::<Vec<_>>();
let mut out = vec![0; 10_000];
let future = write_one(Cursor::new(&mut out[..]), data.clone());
Runtime::new().unwrap().block_on(future).unwrap();
futures::executor::block_on(
write_one(&mut futures::io::Cursor::new(&mut out[..]), data.clone())
).unwrap();
let (out_len, out_data) = unsigned_varint::decode::usize(&out).unwrap();
assert_eq!(out_len, data.len());
assert_eq!(&out_data[..out_len], &data[..]);
}
// TODO: rewrite these tests
/*
#[test]
fn read_one_works() {
let original_data = (0..rand::random::<usize>() % 10_000)
@ -517,7 +207,7 @@ mod tests {
Ok(())
});
Runtime::new().unwrap().block_on(future).unwrap();
futures::executor::block_on(future).unwrap();
}
#[test]
@ -527,7 +217,7 @@ mod tests {
Ok(())
});
Runtime::new().unwrap().block_on(future).unwrap();
futures::executor::block_on(future).unwrap();
}
#[test]
@ -542,7 +232,7 @@ mod tests {
Ok(())
});
match Runtime::new().unwrap().block_on(future) {
match futures::executor::block_on(future) {
Err(ReadOneError::TooLarge { .. }) => (),
_ => panic!(),
}
@ -555,7 +245,7 @@ mod tests {
Ok(())
});
Runtime::new().unwrap().block_on(future).unwrap();
futures::executor::block_on(future).unwrap();
}
#[test]
@ -564,9 +254,9 @@ mod tests {
unreachable!()
});
match Runtime::new().unwrap().block_on(future) {
match futures::executor::block_on(future) {
Err(ReadOneError::Io(ref err)) if err.kind() == io::ErrorKind::UnexpectedEof => (),
_ => panic!()
}
}
}*/
}

94
core/tests/network_dial_error.rs
View File

@ -20,7 +20,7 @@
mod util;
use futures::{future, prelude::*};
use futures::prelude::*;
use libp2p_core::identity;
use libp2p_core::multiaddr::multiaddr;
use libp2p_core::nodes::network::{Network, NetworkEvent, NetworkReachError, PeerState, UnknownPeerDialErr, IncomingError};
@ -34,7 +34,7 @@ use libp2p_swarm::{
protocols_handler::NodeHandlerWrapperBuilder
};
use rand::seq::SliceRandom;
use std::io;
use std::{io, task::Context, task::Poll};
// TODO: replace with DummyProtocolsHandler after https://github.com/servo/rust-smallvec/issues/139 ?
struct TestHandler<TSubstream>(std::marker::PhantomData<TSubstream>);
@ -47,7 +47,7 @@ impl<TSubstream> Default for TestHandler<TSubstream> {
impl<TSubstream> ProtocolsHandler for TestHandler<TSubstream>
where
TSubstream: tokio_io::AsyncRead + tokio_io::AsyncWrite
TSubstream: AsyncRead + AsyncWrite + Unpin + Send + 'static
{
type InEvent = (); // TODO: cannot be Void (https://github.com/servo/rust-smallvec/issues/139)
type OutEvent = (); // TODO: cannot be Void (https://github.com/servo/rust-smallvec/issues/139)
@ -82,8 +82,8 @@ where
fn connection_keep_alive(&self) -> KeepAlive { KeepAlive::No }
fn poll(&mut self) -> Poll<ProtocolsHandlerEvent<Self::OutboundProtocol, Self::OutboundOpenInfo, Self::OutEvent>, Self::Error> {
Ok(Async::NotReady)
fn poll(&mut self, _: &mut Context) -> Poll<ProtocolsHandlerEvent<Self::OutboundProtocol, Self::OutboundOpenInfo, Self::OutEvent, Self::Error>> {
Poll::Pending
}
}
@ -113,27 +113,28 @@ fn deny_incoming_connec() {
swarm1.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap()).unwrap();
let address =
if let Async::Ready(NetworkEvent::NewListenerAddress { listen_addr, .. }) = swarm1.poll() {
listen_addr
let address = async_std::task::block_on(future::poll_fn(|cx| {
if let Poll::Ready(NetworkEvent::NewListenerAddress { listen_addr, .. }) = swarm1.poll(cx) {
Poll::Ready(listen_addr)
} else {
panic!("Was expecting the listen address to be reported")
};
}
}));
swarm2
.peer(swarm1.local_peer_id().clone())
.into_not_connected().unwrap()
.connect(address.clone(), TestHandler::default().into_node_handler_builder());
let future = future::poll_fn(|| -> Poll<(), io::Error> {
match swarm1.poll() {
Async::Ready(NetworkEvent::IncomingConnection(inc)) => drop(inc),
Async::Ready(_) => unreachable!(),
Async::NotReady => (),
async_std::task::block_on(future::poll_fn(|cx| -> Poll<Result<(), io::Error>> {
match swarm1.poll(cx) {
Poll::Ready(NetworkEvent::IncomingConnection(inc)) => drop(inc),
Poll::Ready(_) => unreachable!(),
Poll::Pending => (),
}
match swarm2.poll() {
Async::Ready(NetworkEvent::DialError {
match swarm2.poll(cx) {
Poll::Ready(NetworkEvent::DialError {
new_state: PeerState::NotConnected,
peer_id,
multiaddr,
@ -141,16 +142,14 @@ fn deny_incoming_connec() {
}) => {
assert_eq!(peer_id, *swarm1.local_peer_id());
assert_eq!(multiaddr, address);
return Ok(Async::Ready(()));
return Poll::Ready(Ok(()));
},
Async::Ready(_) => unreachable!(),
Async::NotReady => (),
Poll::Ready(_) => unreachable!(),
Poll::Pending => (),
}
Ok(Async::NotReady)
});
tokio::runtime::current_thread::Runtime::new().unwrap().block_on(future).unwrap();
Poll::Pending
})).unwrap();
}
#[test]
@ -176,32 +175,31 @@ fn dial_self() {
.and_then(|(peer, mplex), _| {
// Gracefully close the connection to allow protocol
// negotiation to complete.
util::CloseMuxer::new(mplex).map(move |mplex| (peer, mplex))
util::CloseMuxer::new(mplex).map_ok(move |mplex| (peer, mplex))
});
Network::new(transport, local_public_key.into())
};
swarm.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap()).unwrap();
let (address, mut swarm) =
future::lazy(move || {
if let Async::Ready(NetworkEvent::NewListenerAddress { listen_addr, .. }) = swarm.poll() {
let (address, mut swarm) = async_std::task::block_on(
future::lazy(move |cx| {
if let Poll::Ready(NetworkEvent::NewListenerAddress { listen_addr, .. }) = swarm.poll(cx) {
Ok::<_, void::Void>((listen_addr, swarm))
} else {
panic!("Was expecting the listen address to be reported")
}
})
.wait()
}))
.unwrap();
swarm.dial(address.clone(), TestHandler::default().into_node_handler_builder()).unwrap();
let mut got_dial_err = false;
let mut got_inc_err = false;
let future = future::poll_fn(|| -> Poll<(), io::Error> {
async_std::task::block_on(future::poll_fn(|cx| -> Poll<Result<(), io::Error>> {
loop {
match swarm.poll() {
Async::Ready(NetworkEvent::UnknownPeerDialError {
match swarm.poll(cx) {
Poll::Ready(NetworkEvent::UnknownPeerDialError {
multiaddr,
error: UnknownPeerDialErr::FoundLocalPeerId,
handler: _
@ -210,10 +208,10 @@ fn dial_self() {
assert!(!got_dial_err);
got_dial_err = true;
if got_inc_err {
return Ok(Async::Ready(()));
return Poll::Ready(Ok(()));
}
},
Async::Ready(NetworkEvent::IncomingConnectionError {
Poll::Ready(NetworkEvent::IncomingConnectionError {
local_addr,
send_back_addr: _,
error: IncomingError::FoundLocalPeerId
@ -222,22 +220,20 @@ fn dial_self() {
assert!(!got_inc_err);
got_inc_err = true;
if got_dial_err {
return Ok(Async::Ready(()));
return Poll::Ready(Ok(()));
}
},
Async::Ready(NetworkEvent::IncomingConnection(inc)) => {
Poll::Ready(NetworkEvent::IncomingConnection(inc)) => {
assert_eq!(*inc.local_addr(), address);
inc.accept(TestHandler::default().into_node_handler_builder());
},
Async::Ready(ev) => {
Poll::Ready(ev) => {
panic!("Unexpected event: {:?}", ev)
}
Async::NotReady => break Ok(Async::NotReady),
Poll::Pending => break Poll::Pending,
}
}
});
tokio::runtime::current_thread::Runtime::new().unwrap().block_on(future).unwrap();
})).unwrap();
}
#[test]
@ -288,10 +284,10 @@ fn multiple_addresses_err() {
.connect_iter(addresses.clone(), TestHandler::default().into_node_handler_builder())
.unwrap();
let future = future::poll_fn(|| -> Poll<(), io::Error> {
async_std::task::block_on(future::poll_fn(|cx| -> Poll<Result<(), io::Error>> {
loop {
match swarm.poll() {
Async::Ready(NetworkEvent::DialError {
match swarm.poll(cx) {
Poll::Ready(NetworkEvent::DialError {
new_state,
peer_id,
multiaddr,
@ -302,7 +298,7 @@ fn multiple_addresses_err() {
assert_eq!(multiaddr, expected);
if addresses.is_empty() {
assert_eq!(new_state, PeerState::NotConnected);
return Ok(Async::Ready(()));
return Poll::Ready(Ok(()));
} else {
match new_state {
PeerState::Dialing { num_pending_addresses } => {
@ -312,11 +308,9 @@ fn multiple_addresses_err() {
}
}
},
Async::Ready(_) => unreachable!(),
Async::NotReady => break Ok(Async::NotReady),
Poll::Ready(_) => unreachable!(),
Poll::Pending => break Poll::Pending,
}
}
});
tokio::runtime::current_thread::Runtime::new().unwrap().block_on(future).unwrap();
})).unwrap();
}

249
core/tests/network_simult.rs
View File

@ -18,9 +18,7 @@
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
mod util;
use futures::{future, prelude::*};
use futures::prelude::*;
use libp2p_core::{identity, upgrade, Transport};
use libp2p_core::nodes::{Network, NetworkEvent, Peer};
use libp2p_core::nodes::network::IncomingError;
@ -31,10 +29,9 @@ use libp2p_swarm::{
ProtocolsHandlerEvent,
ProtocolsHandlerUpgrErr,
};
use std::{io, time::Duration};
use wasm_timer::{Delay, Instant};
use std::{io, task::Context, task::Poll, time::Duration};
use wasm_timer::Delay;
// TODO: replace with DummyProtocolsHandler after https://github.com/servo/rust-smallvec/issues/139 ?
struct TestHandler<TSubstream>(std::marker::PhantomData<TSubstream>);
impl<TSubstream> Default for TestHandler<TSubstream> {
@ -45,7 +42,7 @@ impl<TSubstream> Default for TestHandler<TSubstream> {
impl<TSubstream> ProtocolsHandler for TestHandler<TSubstream>
where
TSubstream: tokio_io::AsyncRead + tokio_io::AsyncWrite
TSubstream: AsyncRead + AsyncWrite + Unpin + Send + 'static
{
type InEvent = (); // TODO: cannot be Void (https://github.com/servo/rust-smallvec/issues/139)
type OutEvent = (); // TODO: cannot be Void (https://github.com/servo/rust-smallvec/issues/139)
@ -80,8 +77,8 @@ where
fn connection_keep_alive(&self) -> KeepAlive { KeepAlive::Yes }
fn poll(&mut self) -> Poll<ProtocolsHandlerEvent<Self::OutboundProtocol, Self::OutboundOpenInfo, Self::OutEvent>, Self::Error> {
Ok(Async::NotReady)
fn poll(&mut self, _: &mut Context) -> Poll<ProtocolsHandlerEvent<Self::OutboundProtocol, Self::OutboundOpenInfo, Self::OutEvent, Self::Error>> {
Poll::Pending
}
}
@ -112,12 +109,7 @@ fn raw_swarm_simultaneous_connect() {
let transport = libp2p_tcp::TcpConfig::new()
.upgrade(upgrade::Version::V1Lazy)
.authenticate(libp2p_secio::SecioConfig::new(local_key))
.multiplex(libp2p_mplex::MplexConfig::new())
.and_then(|(peer, mplex), _| {
// Gracefully close the connection to allow protocol
// negotiation to complete.
util::CloseMuxer::new(mplex).map(move |mplex| (peer, mplex))
});
.multiplex(libp2p_mplex::MplexConfig::new());
Network::new(transport, local_public_key.into_peer_id())
};
@ -127,49 +119,50 @@ fn raw_swarm_simultaneous_connect() {
let transport = libp2p_tcp::TcpConfig::new()
.upgrade(upgrade::Version::V1Lazy)
.authenticate(libp2p_secio::SecioConfig::new(local_key))
.multiplex(libp2p_mplex::MplexConfig::new())
.and_then(|(peer, mplex), _| {
// Gracefully close the connection to allow protocol
// negotiation to complete.
util::CloseMuxer::new(mplex).map(move |mplex| (peer, mplex))
});
.multiplex(libp2p_mplex::MplexConfig::new());
Network::new(transport, local_public_key.into_peer_id())
};
swarm1.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap()).unwrap();
swarm2.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap()).unwrap();
let (swarm1_listen_addr, swarm2_listen_addr, mut swarm1, mut swarm2) =
future::lazy(move || {
let swarm1_listen_addr =
if let Async::Ready(NetworkEvent::NewListenerAddress { listen_addr, .. }) = swarm1.poll() {
listen_addr
} else {
panic!("Was expecting the listen address to be reported")
};
let swarm1_listen_addr = future::poll_fn(|cx| {
if let Poll::Ready(NetworkEvent::NewListenerAddress { listen_addr, .. }) = swarm1.poll(cx) {
Poll::Ready(listen_addr)
} else {
panic!("Was expecting the listen address to be reported")
}
})
.now_or_never()
.expect("listen address of swarm1");
let swarm2_listen_addr =
if let Async::Ready(NetworkEvent::NewListenerAddress { listen_addr, .. }) = swarm2.poll() {
listen_addr
} else {
panic!("Was expecting the listen address to be reported")
};
let swarm2_listen_addr = future::poll_fn(|cx| {
if let Poll::Ready(NetworkEvent::NewListenerAddress { listen_addr, .. }) = swarm2.poll(cx) {
Poll::Ready(listen_addr)
} else {
panic!("Was expecting the listen address to be reported")
}
})
.now_or_never()
.expect("listen address of swarm2");
Ok::<_, void::Void>((swarm1_listen_addr, swarm2_listen_addr, swarm1, swarm2))
})
.wait()
.unwrap();
let mut reactor = tokio::runtime::current_thread::Runtime::new().unwrap();
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
enum Step {
Start,
Dialing,
Connected,
Replaced,
Denied
}
loop {
let mut swarm1_step = 0;
let mut swarm2_step = 0;
let mut swarm1_step = Step::Start;
let mut swarm2_step = Step::Start;
let mut swarm1_dial_start = Delay::new(Instant::now() + Duration::new(0, rand::random::<u32>() % 50_000_000));
let mut swarm2_dial_start = Delay::new(Instant::now() + Duration::new(0, rand::random::<u32>() % 50_000_000));
let mut swarm1_dial_start = Delay::new(Duration::new(0, rand::random::<u32>() % 50_000_000));
let mut swarm2_dial_start = Delay::new(Duration::new(0, rand::random::<u32>() % 50_000_000));
let future = future::poll_fn(|| -> Poll<bool, io::Error> {
let future = future::poll_fn(|cx| {
loop {
let mut swarm1_not_ready = false;
let mut swarm2_not_ready = false;
@ -177,123 +170,127 @@ fn raw_swarm_simultaneous_connect() {
// We add a lot of randomness. In a real-life situation the swarm also has to
// handle other nodes, which may delay the processing.
if swarm1_step == 0 {
match swarm1_dial_start.poll().unwrap() {
Async::Ready(_) => {
let handler = TestHandler::default().into_node_handler_builder();
swarm1.peer(swarm2.local_peer_id().clone())
.into_not_connected()
.unwrap()
.connect(swarm2_listen_addr.clone(), handler);
swarm1_step = 1;
},
Async::NotReady => swarm1_not_ready = true,
if swarm1_step == Step::Start {
if swarm1_dial_start.poll_unpin(cx).is_ready() {
let handler = TestHandler::default().into_node_handler_builder();
swarm1.peer(swarm2.local_peer_id().clone())
.into_not_connected()
.unwrap()
.connect(swarm2_listen_addr.clone(), handler);
swarm1_step = Step::Dialing;
} else {
swarm1_not_ready = true
}
}
if swarm2_step == 0 {
match swarm2_dial_start.poll().unwrap() {
Async::Ready(_) => {
let handler = TestHandler::default().into_node_handler_builder();
swarm2.peer(swarm1.local_peer_id().clone())
.into_not_connected()
.unwrap()
.connect(swarm1_listen_addr.clone(), handler);
swarm2_step = 1;
},
Async::NotReady => swarm2_not_ready = true,
if swarm2_step == Step::Start {
if swarm2_dial_start.poll_unpin(cx).is_ready() {
let handler = TestHandler::default().into_node_handler_builder();
swarm2.peer(swarm1.local_peer_id().clone())
.into_not_connected()
.unwrap()
.connect(swarm1_listen_addr.clone(), handler);
swarm2_step = Step::Dialing;
} else {
swarm2_not_ready = true
}
}
if rand::random::<f32>() < 0.1 {
match swarm1.poll() {
Async::Ready(NetworkEvent::IncomingConnectionError {
match swarm1.poll(cx) {
Poll::Ready(NetworkEvent::IncomingConnectionError {
error: IncomingError::DeniedLowerPriority, ..
}) => {
assert_eq!(swarm1_step, 2);
swarm1_step = 3;
},
Async::Ready(NetworkEvent::Connected { conn_info, .. }) => {
assert_eq!(swarm1_step, Step::Connected);
swarm1_step = Step::Denied
}
Poll::Ready(NetworkEvent::Connected { conn_info, .. }) => {
assert_eq!(conn_info, *swarm2.local_peer_id());
if swarm1_step == 0 {
if swarm1_step == Step::Start {
// The connection was established before
// swarm1 started dialing; discard the test run.
return Ok(Async::Ready(false))
return Poll::Ready(false)
}
assert_eq!(swarm1_step, 1);
swarm1_step = 2;
},
Async::Ready(NetworkEvent::Replaced { new_info, .. }) => {
assert_eq!(swarm1_step, Step::Dialing);
swarm1_step = Step::Connected
}
Poll::Ready(NetworkEvent::Replaced { new_info, .. }) => {
assert_eq!(new_info, *swarm2.local_peer_id());
assert_eq!(swarm1_step, 2);
swarm1_step = 3;
},
Async::Ready(NetworkEvent::IncomingConnection(inc)) => {
inc.accept(TestHandler::default().into_node_handler_builder());
},
Async::Ready(ev) => panic!("swarm1: unexpected event: {:?}", ev),
Async::NotReady => swarm1_not_ready = true,
assert_eq!(swarm1_step, Step::Connected);
swarm1_step = Step::Replaced
}
Poll::Ready(NetworkEvent::IncomingConnection(inc)) => {
inc.accept(TestHandler::default().into_node_handler_builder())
}
Poll::Ready(ev) => panic!("swarm1: unexpected event: {:?}", ev),
Poll::Pending => swarm1_not_ready = true
}
}
if rand::random::<f32>() < 0.1 {
match swarm2.poll() {
Async::Ready(NetworkEvent::IncomingConnectionError {
match swarm2.poll(cx) {
Poll::Ready(NetworkEvent::IncomingConnectionError {
error: IncomingError::DeniedLowerPriority, ..
}) => {
assert_eq!(swarm2_step, 2);
swarm2_step = 3;
},
Async::Ready(NetworkEvent::Connected { conn_info, .. }) => {
assert_eq!(swarm2_step, Step::Connected);
swarm2_step = Step::Denied
}
Poll::Ready(NetworkEvent::Connected { conn_info, .. }) => {
assert_eq!(conn_info, *swarm1.local_peer_id());
if swarm2_step == 0 {
if swarm2_step == Step::Start {
// The connection was established before
// swarm2 started dialing; discard the test run.
return Ok(Async::Ready(false))
return Poll::Ready(false)
}
assert_eq!(swarm2_step, 1);
swarm2_step = 2;
},
Async::Ready(NetworkEvent::Replaced { new_info, .. }) => {
assert_eq!(swarm2_step, Step::Dialing);
swarm2_step = Step::Connected
}
Poll::Ready(NetworkEvent::Replaced { new_info, .. }) => {
assert_eq!(new_info, *swarm1.local_peer_id());
assert_eq!(swarm2_step, 2);
swarm2_step = 3;
},
Async::Ready(NetworkEvent::IncomingConnection(inc)) => {
inc.accept(TestHandler::default().into_node_handler_builder());
},
Async::Ready(ev) => panic!("swarm2: unexpected event: {:?}", ev),
Async::NotReady => swarm2_not_ready = true,
assert_eq!(swarm2_step, Step::Connected);
swarm2_step = Step::Replaced
}
Poll::Ready(NetworkEvent::IncomingConnection(inc)) => {
inc.accept(TestHandler::default().into_node_handler_builder())
}
Poll::Ready(ev) => panic!("swarm2: unexpected event: {:?}", ev),
Poll::Pending => swarm2_not_ready = true
}
}
// TODO: make sure that >= 5 is correct
if swarm1_step + swarm2_step >= 5 {
return Ok(Async::Ready(true));
match (swarm1_step, swarm2_step) {
| (Step::Connected, Step::Replaced)
| (Step::Connected, Step::Denied)
| (Step::Replaced, Step::Connected)
| (Step::Replaced, Step::Denied)
| (Step::Replaced, Step::Replaced)
| (Step::Denied, Step::Connected)
| (Step::Denied, Step::Replaced) => return Poll::Ready(true),
_else => ()
}
if swarm1_not_ready && swarm2_not_ready {
return Ok(Async::NotReady);
return Poll::Pending
}
}
});
if reactor.block_on(future).unwrap() {
if async_std::task::block_on(future) {
// The test exercised what we wanted to exercise: a simultaneous connect.
break
} else {
// The test did not trigger a simultaneous connect; ensure the nodes
// are disconnected and re-run the test.
match swarm1.peer(swarm2.local_peer_id().clone()) {
Peer::Connected(p) => p.close(),
Peer::PendingConnect(p) => p.interrupt(),
x => panic!("Unexpected state for swarm1: {:?}", x)
}
match swarm2.peer(swarm1.local_peer_id().clone()) {
Peer::Connected(p) => p.close(),
Peer::PendingConnect(p) => p.interrupt(),
x => panic!("Unexpected state for swarm2: {:?}", x)
}
}
// The test did not trigger a simultaneous connect; ensure the nodes
// are disconnected and re-run the test.
match swarm1.peer(swarm2.local_peer_id().clone()) {
Peer::Connected(p) => p.close(),
Peer::PendingConnect(p) => p.interrupt(),
x => panic!("Unexpected state for swarm1: {:?}", x)
}
match swarm2.peer(swarm1.local_peer_id().clone()) {
Peer::Connected(p) => p.close(),
Peer::PendingConnect(p) => p.interrupt(),
x => panic!("Unexpected state for swarm2: {:?}", x)
}
}
}

79
core/tests/transport_upgrade.rs
View File

@ -20,17 +20,15 @@
mod util;
use futures::future::Future;
use futures::stream::Stream;
use futures::prelude::*;
use libp2p_core::identity;
use libp2p_core::transport::{Transport, MemoryTransport, ListenerEvent};
use libp2p_core::transport::{Transport, MemoryTransport};
use libp2p_core::upgrade::{self, UpgradeInfo, Negotiated, InboundUpgrade, OutboundUpgrade};
use libp2p_mplex::MplexConfig;
use libp2p_secio::SecioConfig;
use multiaddr::Multiaddr;
use multiaddr::{Multiaddr, Protocol};
use rand::random;
use std::io;
use tokio_io::{io as nio, AsyncWrite, AsyncRead};
use std::{io, pin::Pin};
#[derive(Clone)]
struct HelloUpgrade {}
@ -46,30 +44,36 @@ impl UpgradeInfo for HelloUpgrade {
impl<C> InboundUpgrade<C> for HelloUpgrade
where
C: AsyncRead + AsyncWrite + Send + 'static
C: AsyncRead + AsyncWrite + Send + Unpin + 'static
{
type Output = Negotiated<C>;
type Error = io::Error;
type Future = Box<dyn Future<Item = Self::Output, Error = Self::Error> + Send>;
type Future = Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send>>;
fn upgrade_inbound(self, socket: Negotiated<C>, _: Self::Info) -> Self::Future {
Box::new(nio::read_exact(socket, [0u8; 5]).map(|(io, buf)| {
fn upgrade_inbound(self, mut socket: Negotiated<C>, _: Self::Info) -> Self::Future {
Box::pin(async move {
let mut buf = [0u8; 5];
socket.read_exact(&mut buf).await.unwrap();
assert_eq!(&buf[..], "hello".as_bytes());
io
}))
Ok(socket)
})
}
}
impl<C> OutboundUpgrade<C> for HelloUpgrade
where
C: AsyncWrite + AsyncRead + Send + 'static,
C: AsyncWrite + AsyncRead + Send + Unpin + 'static,
{
type Output = Negotiated<C>;
type Error = io::Error;
type Future = Box<dyn Future<Item = Self::Output, Error = Self::Error> + Send>;
type Future = Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send>>;
fn upgrade_outbound(self, socket: Negotiated<C>, _: Self::Info) -> Self::Future {
Box::new(nio::write_all(socket, "hello").map(|(io, _)| io))
fn upgrade_outbound(self, mut socket: Negotiated<C>, _: Self::Info) -> Self::Future {
Box::pin(async move {
socket.write_all(b"hello").await.unwrap();
socket.flush().await.unwrap();
Ok(socket)
})
}
}
@ -87,7 +91,7 @@ fn upgrade_pipeline() {
.and_then(|(peer, mplex), _| {
// Gracefully close the connection to allow protocol
// negotiation to complete.
util::CloseMuxer::new(mplex).map(move |mplex| (peer, mplex))
util::CloseMuxer::new(mplex).map_ok(move |mplex| (peer, mplex))
});
let dialer_keys = identity::Keypair::generate_ed25519();
@ -102,27 +106,32 @@ fn upgrade_pipeline() {
.and_then(|(peer, mplex), _| {
// Gracefully close the connection to allow protocol
// negotiation to complete.
util::CloseMuxer::new(mplex).map(move |mplex| (peer, mplex))
util::CloseMuxer::new(mplex).map_ok(move |mplex| (peer, mplex))
});
let listen_addr: Multiaddr = format!("/memory/{}", random::<u64>()).parse().unwrap();
let listener = listener_transport.listen_on(listen_addr.clone()).unwrap()
.filter_map(ListenerEvent::into_upgrade)
.for_each(move |(upgrade, _remote_addr)| {
let dialer = dialer_id.clone();
upgrade.map(move |(peer, _mplex)| {
assert_eq!(peer, dialer)
})
})
.map_err(|e| panic!("Listener error: {}", e));
let listen_addr1 = Multiaddr::from(Protocol::Memory(random::<u64>()));
let listen_addr2 = listen_addr1.clone();
let dialer = dialer_transport.dial(listen_addr).unwrap()
.map(move |(peer, _mplex)| {
assert_eq!(peer, listener_id)
});
let mut listener = listener_transport.listen_on(listen_addr1).unwrap();
let mut rt = tokio::runtime::Runtime::new().unwrap();
rt.spawn(listener);
rt.block_on(dialer).unwrap()
let server = async move {
loop {
let (upgrade, _remote_addr) =
match listener.next().await.unwrap().unwrap().into_upgrade() {
Some(u) => u,
None => continue
};
let (peer, _mplex) = upgrade.await.unwrap();
assert_eq!(peer, dialer_id);
}
};
let client = async move {
let (peer, _mplex) = dialer_transport.dial(listen_addr2).unwrap().await.unwrap();
assert_eq!(peer, listener_id);
};
async_std::task::spawn(server);
async_std::task::block_on(client);
}

14
core/tests/util.rs
View File

@ -3,6 +3,7 @@
use futures::prelude::*;
use libp2p_core::muxing::StreamMuxer;
use std::{pin::Pin, task::Context, task::Poll};
pub struct CloseMuxer<M> {
state: CloseMuxerState<M>,
@ -26,18 +27,17 @@ where
M: StreamMuxer,
M::Error: From<std::io::Error>
{
type Item = M;
type Error = M::Error;
type Output = Result<M, M::Error>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
loop {
match std::mem::replace(&mut self.state, CloseMuxerState::Done) {
CloseMuxerState::Close(muxer) => {
if muxer.close()?.is_not_ready() {
if !muxer.close(cx)?.is_ready() {
self.state = CloseMuxerState::Close(muxer);
return Ok(Async::NotReady)
return Poll::Pending
}
return Ok(Async::Ready(muxer))
return Poll::Ready(Ok(muxer))
}
CloseMuxerState::Done => panic!()
}
@ -45,3 +45,5 @@ where
}
}
impl<M> Unpin for CloseMuxer<M> {
}

65
examples/chat.rs
View File

@ -49,20 +49,21 @@
//!
//! The two nodes then connect.
use futures::prelude::*;
use async_std::{io, task};
use futures::{future, prelude::*};
use libp2p::{
Multiaddr,
PeerId,
Swarm,
NetworkBehaviour,
identity,
tokio_codec::{FramedRead, LinesCodec},
tokio_io::{AsyncRead, AsyncWrite},
floodsub::{self, Floodsub, FloodsubEvent},
mdns::{Mdns, MdnsEvent},
swarm::NetworkBehaviourEventProcess
};
use std::{error::Error, task::{Context, Poll}};
fn main() {
fn main() -> Result<(), Box<dyn Error>> {
env_logger::init();
// Create a random PeerId
@ -71,7 +72,7 @@ fn main() {
println!("Local peer id: {:?}", local_peer_id);
// Set up a an encrypted DNS-enabled TCP Transport over the Mplex and Yamux protocols
let transport = libp2p::build_development_transport(local_key);
let transport = libp2p::build_development_transport(local_key)?;
// Create a Floodsub topic
let floodsub_topic = floodsub::TopicBuilder::new("chat").build();
@ -87,18 +88,16 @@ fn main() {
impl<TSubstream: AsyncRead + AsyncWrite> NetworkBehaviourEventProcess<MdnsEvent> for MyBehaviour<TSubstream> {
fn inject_event(&mut self, event: MdnsEvent) {
match event {
MdnsEvent::Discovered(list) => {
MdnsEvent::Discovered(list) =>
for (peer, _) in list {
self.floodsub.add_node_to_partial_view(peer);
}
},
MdnsEvent::Expired(list) => {
MdnsEvent::Expired(list) =>
for (peer, _) in list {
if !self.mdns.has_node(&peer) {
self.floodsub.remove_node_from_partial_view(&peer);
}
}
}
}
}
}
@ -114,9 +113,10 @@ fn main() {
// Create a Swarm to manage peers and events
let mut swarm = {
let mdns = task::block_on(Mdns::new())?;
let mut behaviour = MyBehaviour {
floodsub: Floodsub::new(local_peer_id.clone()),
mdns: Mdns::new().expect("Failed to create mDNS service"),
mdns
};
behaviour.floodsub.subscribe(floodsub_topic.clone());
@ -125,42 +125,32 @@ fn main() {
// Reach out to another node if specified
if let Some(to_dial) = std::env::args().nth(1) {
let dialing = to_dial.clone();
match to_dial.parse() {
Ok(to_dial) => {
match libp2p::Swarm::dial_addr(&mut swarm, to_dial) {
Ok(_) => println!("Dialed {:?}", dialing),
Err(e) => println!("Dial {:?} failed: {:?}", dialing, e)
}
},
Err(err) => println!("Failed to parse address to dial: {:?}", err),
}
let addr: Multiaddr = to_dial.parse()?;
Swarm::dial_addr(&mut swarm, addr)?;
println!("Dialed {:?}", to_dial)
}
// Read full lines from stdin
let stdin = tokio_stdin_stdout::stdin(0);
let mut framed_stdin = FramedRead::new(stdin, LinesCodec::new());
let mut stdin = io::BufReader::new(io::stdin()).lines();
// Listen on all interfaces and whatever port the OS assigns
Swarm::listen_on(&mut swarm, "/ip4/0.0.0.0/tcp/0".parse().unwrap()).unwrap();
Swarm::listen_on(&mut swarm, "/ip4/0.0.0.0/tcp/0".parse()?)?;
// Kick it off
let mut listening = false;
tokio::run(futures::future::poll_fn(move || -> Result<_, ()> {
task::block_on(future::poll_fn(move |cx: &mut Context| {
loop {
match framed_stdin.poll().expect("Error while polling stdin") {
Async::Ready(Some(line)) => swarm.floodsub.publish(&floodsub_topic, line.as_bytes()),
Async::Ready(None) => panic!("Stdin closed"),
Async::NotReady => break,
};
match stdin.try_poll_next_unpin(cx)? {
Poll::Ready(Some(line)) => swarm.floodsub.publish(&floodsub_topic, line.as_bytes()),
Poll::Ready(None) => panic!("Stdin closed"),
Poll::Pending => break
}
}
loop {
match swarm.poll().expect("Error while polling swarm") {
Async::Ready(Some(_)) => {
},
Async::Ready(None) | Async::NotReady => {
match swarm.poll_next_unpin(cx) {
Poll::Ready(Some(event)) => println!("{:?}", event),
Poll::Ready(None) => return Poll::Ready(Ok(())),
Poll::Pending => {
if !listening {
if let Some(a) = Swarm::listeners(&swarm).next() {
println!("Listening on {:?}", a);
@ -171,7 +161,6 @@ fn main() {
}
}
}
Ok(Async::NotReady)
}));
Poll::Pending
}))
}

81
examples/distributed-key-value-store.rs
View File

@ -29,19 +29,22 @@
//!
//! 4. Close with Ctrl-c.
use async_std::{io, task};
use futures::prelude::*;
use libp2p::kad::record::store::MemoryStore;
use libp2p::kad::{record::Key, Kademlia, KademliaEvent, PutRecordOk, Quorum, Record};
use libp2p::{
build_development_transport, identity,
NetworkBehaviour,
PeerId,
Swarm,
build_development_transport,
identity,
mdns::{Mdns, MdnsEvent},
swarm::NetworkBehaviourEventProcess,
tokio_codec::{FramedRead, LinesCodec},
tokio_io::{AsyncRead, AsyncWrite},
NetworkBehaviour, PeerId, Swarm,
swarm::NetworkBehaviourEventProcess
};
use std::{error::Error, task::{Context, Poll}};
fn main() {
fn main() -> Result<(), Box<dyn Error>> {
env_logger::init();
// Create a random key for ourselves.
@ -49,17 +52,18 @@ fn main() {
let local_peer_id = PeerId::from(local_key.public());
// Set up a an encrypted DNS-enabled TCP Transport over the Mplex protocol.
let transport = build_development_transport(local_key);
let transport = build_development_transport(local_key)?;
// We create a custom network behaviour that combines Kademlia and mDNS.
#[derive(NetworkBehaviour)]
struct MyBehaviour<TSubstream: AsyncRead + AsyncWrite> {
kademlia: Kademlia<TSubstream, MemoryStore>,
mdns: Mdns<TSubstream>,
mdns: Mdns<TSubstream>
}
impl<TSubstream: AsyncRead + AsyncWrite> NetworkBehaviourEventProcess<MdnsEvent>
for MyBehaviour<TSubstream>
impl<T> NetworkBehaviourEventProcess<MdnsEvent> for MyBehaviour<T>
where
T: AsyncRead + AsyncWrite
{
// Called when `mdns` produces an event.
fn inject_event(&mut self, event: MdnsEvent) {
@ -71,8 +75,9 @@ fn main() {
}
}
impl<TSubstream: AsyncRead + AsyncWrite> NetworkBehaviourEventProcess<KademliaEvent>
for MyBehaviour<TSubstream>
impl<T> NetworkBehaviourEventProcess<KademliaEvent> for MyBehaviour<T>
where
T: AsyncRead + AsyncWrite
{
// Called when `kademlia` produces an event.
fn inject_event(&mut self, message: KademliaEvent) {
@ -108,58 +113,50 @@ fn main() {
// Create a Kademlia behaviour.
let store = MemoryStore::new(local_peer_id.clone());
let kademlia = Kademlia::new(local_peer_id.clone(), store);
let behaviour = MyBehaviour {
kademlia,
mdns: Mdns::new().expect("Failed to create mDNS service"),
};
let mdns = task::block_on(Mdns::new())?;
let behaviour = MyBehaviour { kademlia, mdns };
Swarm::new(transport, behaviour, local_peer_id)
};
// Read full lines from stdin.
let stdin = tokio_stdin_stdout::stdin(0);
let mut framed_stdin = FramedRead::new(stdin, LinesCodec::new());
// Read full lines from stdin
let mut stdin = io::BufReader::new(io::stdin()).lines();
// Listen on all interfaces and whatever port the OS assigns.
Swarm::listen_on(&mut swarm, "/ip4/0.0.0.0/tcp/0".parse().unwrap()).unwrap();
Swarm::listen_on(&mut swarm, "/ip4/0.0.0.0/tcp/0".parse()?)?;
// Kick it off.
let mut listening = false;
tokio::run(futures::future::poll_fn(move || {
task::block_on(future::poll_fn(move |cx: &mut Context| {
loop {
match framed_stdin.poll().expect("Error while polling stdin") {
Async::Ready(Some(line)) => {
handle_input_line(&mut swarm.kademlia, line);
}
Async::Ready(None) => panic!("Stdin closed"),
Async::NotReady => break,
};
match stdin.try_poll_next_unpin(cx)? {
Poll::Ready(Some(line)) => handle_input_line(&mut swarm.kademlia, line),
Poll::Ready(None) => panic!("Stdin closed"),
Poll::Pending => break
}
}
loop {
match swarm.poll().expect("Error while polling swarm") {
Async::Ready(Some(_)) => {}
Async::Ready(None) | Async::NotReady => {
match swarm.poll_next_unpin(cx) {
Poll::Ready(Some(event)) => println!("{:?}", event),
Poll::Ready(None) => return Poll::Ready(Ok(())),
Poll::Pending => {
if !listening {
if let Some(a) = Swarm::listeners(&swarm).next() {
println!("Listening on {:?}", a);
listening = true;
}
}
break;
break
}
}
}
Ok(Async::NotReady)
}));
Poll::Pending
}))
}
fn handle_input_line<TSubstream: AsyncRead + AsyncWrite>(
kademlia: &mut Kademlia<TSubstream, MemoryStore>,
line: String,
) {
fn handle_input_line<T>(kademlia: &mut Kademlia<T, MemoryStore>, line: String)
where
T: AsyncRead + AsyncWrite
{
let mut args = line.split(" ");
match args.next() {

64
examples/ipfs-kad.rs
View File

@ -23,6 +23,7 @@
//! You can pass as parameter a base58 peer ID to search for. If you don't pass any parameter, a
//! peer ID will be generated randomly.
use async_std::task;
use futures::prelude::*;
use libp2p::{
Swarm,
@ -32,10 +33,9 @@ use libp2p::{
};
use libp2p::kad::{Kademlia, KademliaConfig, KademliaEvent, GetClosestPeersError};
use libp2p::kad::record::store::MemoryStore;
use std::env;
use std::time::Duration;
use std::{env, error::Error, time::Duration};
fn main() {
fn main() -> Result<(), Box<dyn Error>> {
env_logger::init();
// Create a random key for ourselves.
@ -43,7 +43,7 @@ fn main() {
let local_peer_id = PeerId::from(local_key.public());
// Set up a an encrypted DNS-enabled TCP Transport over the Mplex protocol
let transport = build_development_transport(local_key);
let transport = build_development_transport(local_key)?;
// Create a swarm to manage peers and events.
let mut swarm = {
@ -60,7 +60,7 @@ fn main() {
behaviour.add_address(&"QmcZf59bWwK5XFi76CZX8cbJ4BhTzzA3gU1ZjYZcYW3dwt".parse().unwrap(), "/dnsaddr/bootstrap.libp2p.io".parse().unwrap());*/
// The only address that currently works.
behaviour.add_address(&"QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ".parse().unwrap(), "/ip4/104.131.131.82/tcp/4001".parse().unwrap());
behaviour.add_address(&"QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ".parse()?, "/ip4/104.131.131.82/tcp/4001".parse()?);
// The following addresses always fail signature verification, possibly due to
// RSA keys with < 2048 bits.
@ -80,7 +80,7 @@ fn main() {
// Order Kademlia to search for a peer.
let to_search: PeerId = if let Some(peer_id) = env::args().nth(1) {
peer_id.parse().expect("Failed to parse peer ID to find")
peer_id.parse()?
} else {
identity::Keypair::generate_ed25519().public().into()
};
@ -89,38 +89,32 @@ fn main() {
swarm.get_closest_peers(to_search);
// Kick it off!
tokio::run(futures::future::poll_fn(move || {
loop {
match swarm.poll().expect("Error while polling swarm") {
Async::Ready(Some(KademliaEvent::GetClosestPeersResult(res))) => {
match res {
Ok(ok) => {
if !ok.peers.is_empty() {
println!("Query finished with closest peers: {:#?}", ok.peers);
return Ok(Async::Ready(()));
} else {
// The example is considered failed as there
// should always be at least 1 reachable peer.
panic!("Query finished with no closest peers.");
}
task::block_on(async move {
while let Some(event) = swarm.try_next().await? {
if let KademliaEvent::GetClosestPeersResult(result) = event {
match result {
Ok(ok) =>
if !ok.peers.is_empty() {
println!("Query finished with closest peers: {:#?}", ok.peers)
} else {
// The example is considered failed as there
// should always be at least 1 reachable peer.
println!("Query finished with no closest peers.")
}
Err(GetClosestPeersError::Timeout { peers, .. }) => {
if !peers.is_empty() {
println!("Query timed out with closest peers: {:#?}", peers);
return Ok(Async::Ready(()));
} else {
// The example is considered failed as there
// should always be at least 1 reachable peer.
panic!("Query timed out with no closest peers.");
}
Err(GetClosestPeersError::Timeout { peers, .. }) =>
if !peers.is_empty() {
println!("Query timed out with closest peers: {:#?}", peers)
} else {
// The example is considered failed as there
// should always be at least 1 reachable peer.
println!("Query timed out with no closest peers.");
}
}
},
Async::Ready(Some(_)) => {},
Async::Ready(None) | Async::NotReady => break,
};
break;
}
}
Ok(Async::NotReady)
}));
Ok(())
})
}

31
examples/mdns-passive-discovery.rs
View File

@ -18,26 +18,17 @@
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
use futures::prelude::*;
use async_std::task;
use libp2p::mdns::service::{MdnsPacket, MdnsService};
use std::io;
use std::error::Error;
fn main() {
// This example provides passive discovery of the libp2p nodes on the network that send
// mDNS queries and answers.
// We start by creating the service.
let mut service = MdnsService::new().expect("Error while creating mDNS service");
// Create a never-ending `Future` that polls the service for events.
let future = futures::future::poll_fn(move || -> Poll<(), io::Error> {
fn main() -> Result<(), Box<dyn Error>> {
// This example provides passive discovery of the libp2p nodes on the
// network that send mDNS queries and answers.
task::block_on(async move {
let mut service = MdnsService::new().await?;
loop {
// Grab the next available packet from the service.
let packet = match service.poll() {
Async::Ready(packet) => packet,
Async::NotReady => return Ok(Async::NotReady),
};
let (srv, packet) = service.next().await;
match packet {
MdnsPacket::Query(query) => {
// We detected a libp2p mDNS query on the network. In a real application, you
@ -63,9 +54,7 @@ fn main() {
println!("Detected service query from {:?}", query.remote_addr());
}
}
service = srv
}
});
// Blocks the thread until the future runs to completion (which will never happen).
tokio::run(future.map_err(|err| panic!("{:?}", err)));
})
}

46
examples/ping.rs
View File

@ -38,11 +38,12 @@
//! The two nodes establish a connection, negotiate the ping protocol
//! and begin pinging each other.
use futures::{prelude::*, future};
use libp2p::{ identity, PeerId, ping::{Ping, PingConfig}, Swarm };
use std::env;
use async_std::task;
use futures::{future, prelude::*};
use libp2p::{identity, PeerId, ping::{Ping, PingConfig}, Swarm};
use std::{error::Error, task::{Context, Poll}};
fn main() {
fn main() -> Result<(), Box<dyn Error>> {
env_logger::init();
// Create a random PeerId.
@ -51,7 +52,7 @@ fn main() {
println!("Local peer id: {:?}", peer_id);
// Create a transport.
let transport = libp2p::build_development_transport(id_keys);
let transport = libp2p::build_development_transport(id_keys)?;
// Create a ping network behaviour.
//
@ -66,38 +67,33 @@ fn main() {
// Dial the peer identified by the multi-address given as the second
// command-line argument, if any.
if let Some(addr) = env::args().nth(1) {
let remote_addr = addr.clone();
match addr.parse() {
Ok(remote) => {
match Swarm::dial_addr(&mut swarm, remote) {
Ok(()) => println!("Dialed {:?}", remote_addr),
Err(e) => println!("Dialing {:?} failed with: {:?}", remote_addr, e)
}
},
Err(err) => println!("Failed to parse address to dial: {:?}", err),
}
if let Some(addr) = std::env::args().nth(1) {
let remote = addr.parse()?;
Swarm::dial_addr(&mut swarm, remote)?;
println!("Dialed {}", addr)
}
// Tell the swarm to listen on all interfaces and a random, OS-assigned port.
Swarm::listen_on(&mut swarm, "/ip4/0.0.0.0/tcp/0".parse().unwrap()).unwrap();
Swarm::listen_on(&mut swarm, "/ip4/0.0.0.0/tcp/0".parse()?)?;
// Use tokio to drive the `Swarm`.
let mut listening = false;
tokio::run(future::poll_fn(move || -> Result<_, ()> {
task::block_on(future::poll_fn(move |cx: &mut Context| {
loop {
match swarm.poll().expect("Error while polling swarm") {
Async::Ready(Some(e)) => println!("{:?}", e),
Async::Ready(None) | Async::NotReady => {
match swarm.poll_next_unpin(cx) {
Poll::Ready(Some(event)) => println!("{:?}", event),
Poll::Ready(None) => return Poll::Ready(()),
Poll::Pending => {
if !listening {
if let Some(a) = Swarm::listeners(&swarm).next() {
println!("Listening on {:?}", a);
for addr in Swarm::listeners(&swarm) {
println!("Listening on {}", addr);
listening = true;
}
}
return Ok(Async::NotReady)
return Poll::Pending
}
}
}
}));
Ok(())
}

2
misc/core-derive/Cargo.toml
View File

@ -13,7 +13,7 @@ categories = ["network-programming", "asynchronous"]
proc-macro = true
[dependencies]
syn = { version = "1.0", default-features = false, features = ["clone-impls", "derive", "parsing", "printing", "proc-macro"] }
syn = { version = "1.0.8", default-features = false, features = ["clone-impls", "derive", "parsing", "printing", "proc-macro"] }
quote = "1.0"
[dev-dependencies]

41
misc/core-derive/src/lib.rs
View File

@ -96,8 +96,9 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> TokenStream {
})
.collect::<Vec<_>>();
additional.push(quote!{#substream_generic: ::libp2p::tokio_io::AsyncRead});
additional.push(quote!{#substream_generic: ::libp2p::tokio_io::AsyncWrite});
additional.push(quote!{#substream_generic: ::libp2p::futures::io::AsyncRead});
additional.push(quote!{#substream_generic: ::libp2p::futures::io::AsyncWrite});
additional.push(quote!{#substream_generic: Unpin});
if let Some(where_clause) = where_clause {
if where_clause.predicates.trailing_punct() {
@ -381,14 +382,14 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> TokenStream {
// If we find a `#[behaviour(poll_method = "poll")]` attribute on the struct, we call
// `self.poll()` at the end of the polling.
let poll_method = {
let mut poll_method = quote!{Async::NotReady};
let mut poll_method = quote!{std::task::Poll::Pending};
for meta_items in ast.attrs.iter().filter_map(get_meta_items) {
for meta_item in meta_items {
match meta_item {
syn::NestedMeta::Meta(syn::Meta::NameValue(ref m)) if m.path.is_ident("poll_method") => {
if let syn::Lit::Str(ref s) = m.lit {
let ident: Ident = syn::parse_str(&s.value()).unwrap();
poll_method = quote!{#name::#ident(self)};
poll_method = quote!{#name::#ident(self, cx)};
}
}
_ => ()
@ -418,26 +419,26 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> TokenStream {
Some(quote!{
loop {
match #field_name.poll(poll_params) {
Async::Ready(#network_behaviour_action::GenerateEvent(event)) => {
match #field_name.poll(cx, poll_params) {
std::task::Poll::Ready(#network_behaviour_action::GenerateEvent(event)) => {
#net_behv_event_proc::inject_event(self, event)
}
Async::Ready(#network_behaviour_action::DialAddress { address }) => {
return Async::Ready(#network_behaviour_action::DialAddress { address });
std::task::Poll::Ready(#network_behaviour_action::DialAddress { address }) => {
return std::task::Poll::Ready(#network_behaviour_action::DialAddress { address });
}
Async::Ready(#network_behaviour_action::DialPeer { peer_id }) => {
return Async::Ready(#network_behaviour_action::DialPeer { peer_id });
std::task::Poll::Ready(#network_behaviour_action::DialPeer { peer_id }) => {
return std::task::Poll::Ready(#network_behaviour_action::DialPeer { peer_id });
}
Async::Ready(#network_behaviour_action::SendEvent { peer_id, event }) => {
return Async::Ready(#network_behaviour_action::SendEvent {
std::task::Poll::Ready(#network_behaviour_action::SendEvent { peer_id, event }) => {
return std::task::Poll::Ready(#network_behaviour_action::SendEvent {
peer_id,
event: #wrapped_event,
});
}
Async::Ready(#network_behaviour_action::ReportObservedAddr { address }) => {
return Async::Ready(#network_behaviour_action::ReportObservedAddr { address });
std::task::Poll::Ready(#network_behaviour_action::ReportObservedAddr { address }) => {
return std::task::Poll::Ready(#network_behaviour_action::ReportObservedAddr { address });
}
Async::NotReady => break,
std::task::Poll::Pending => break,
}
}
})
@ -512,10 +513,10 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> TokenStream {
}
}
fn poll(&mut self, poll_params: &mut impl #poll_parameters) -> ::libp2p::futures::Async<#network_behaviour_action<<<Self::ProtocolsHandler as #into_protocols_handler>::Handler as #protocols_handler>::InEvent, Self::OutEvent>> {
fn poll(&mut self, cx: &mut std::task::Context, poll_params: &mut impl #poll_parameters) -> std::task::Poll<#network_behaviour_action<<<Self::ProtocolsHandler as #into_protocols_handler>::Handler as #protocols_handler>::InEvent, Self::OutEvent>> {
use libp2p::futures::prelude::*;
#(#poll_stmts)*
let f: ::libp2p::futures::Async<#network_behaviour_action<<<Self::ProtocolsHandler as #into_protocols_handler>::Handler as #protocols_handler>::InEvent, Self::OutEvent>> = #poll_method;
let f: std::task::Poll<#network_behaviour_action<<<Self::ProtocolsHandler as #into_protocols_handler>::Handler as #protocols_handler>::InEvent, Self::OutEvent>> = #poll_method;
f
}
}
@ -525,10 +526,12 @@ fn build_struct(ast: &DeriveInput, data_struct: &DataStruct) -> TokenStream {
}
fn get_meta_items(attr: &syn::Attribute) -> Option<Vec<syn::NestedMeta>> {
if attr.path.is_ident("behaviour") {
if attr.path.segments.len() == 1 && attr.path.segments[0].ident == "behaviour" {
match attr.parse_meta() {
Ok(syn::Meta::List(ref meta)) => Some(meta.nested.iter().cloned().collect()),
_ => {
Ok(_) => None,
Err(e) => {
eprintln!("error parsing attribute metadata: {}", e);
None
}
}

16
misc/core-derive/tests/test.rs
View File

@ -46,7 +46,7 @@ fn one_field() {
}
#[allow(dead_code)]
fn foo<TSubstream: libp2p::tokio_io::AsyncRead + libp2p::tokio_io::AsyncWrite>() {
fn foo<TSubstream: libp2p::futures::AsyncRead + libp2p::futures::AsyncWrite + Send + Unpin + 'static>() {
require_net_behaviour::<Foo<TSubstream>>();
}
}
@ -71,7 +71,7 @@ fn two_fields() {
}
#[allow(dead_code)]
fn foo<TSubstream: libp2p::tokio_io::AsyncRead + libp2p::tokio_io::AsyncWrite>() {
fn foo<TSubstream: libp2p::futures::AsyncRead + libp2p::futures::AsyncWrite + Send + Unpin + 'static>() {
require_net_behaviour::<Foo<TSubstream>>();
}
}
@ -104,7 +104,7 @@ fn three_fields() {
}
#[allow(dead_code)]
fn foo<TSubstream: libp2p::tokio_io::AsyncRead + libp2p::tokio_io::AsyncWrite>() {
fn foo<TSubstream: libp2p::futures::AsyncRead + libp2p::futures::AsyncWrite + Send + Unpin + 'static>() {
require_net_behaviour::<Foo<TSubstream>>();
}
}
@ -130,11 +130,11 @@ fn custom_polling() {
}
impl<TSubstream> Foo<TSubstream> {
fn foo<T>(&mut self) -> libp2p::futures::Async<libp2p::swarm::NetworkBehaviourAction<T, ()>> { libp2p::futures::Async::NotReady }
fn foo<T>(&mut self, _: &mut std::task::Context) -> std::task::Poll<libp2p::swarm::NetworkBehaviourAction<T, ()>> { std::task::Poll::Pending }
}
#[allow(dead_code)]
fn foo<TSubstream: libp2p::tokio_io::AsyncRead + libp2p::tokio_io::AsyncWrite>() {
fn foo<TSubstream: libp2p::futures::AsyncRead + libp2p::futures::AsyncWrite + Send + Unpin + 'static>() {
require_net_behaviour::<Foo<TSubstream>>();
}
}
@ -160,7 +160,7 @@ fn custom_event_no_polling() {
}
#[allow(dead_code)]
fn foo<TSubstream: libp2p::tokio_io::AsyncRead + libp2p::tokio_io::AsyncWrite>() {
fn foo<TSubstream: libp2p::futures::AsyncRead + libp2p::futures::AsyncWrite + Send + Unpin + 'static>() {
require_net_behaviour::<Foo<TSubstream>>();
}
}
@ -186,11 +186,11 @@ fn custom_event_and_polling() {
}
impl<TSubstream> Foo<TSubstream> {
fn foo<T>(&mut self) -> libp2p::futures::Async<libp2p::swarm::NetworkBehaviourAction<T, String>> { libp2p::futures::Async::NotReady }
fn foo<T>(&mut self, _: &mut std::task::Context) -> std::task::Poll<libp2p::swarm::NetworkBehaviourAction<T, String>> { std::task::Poll::Pending }
}
#[allow(dead_code)]
fn foo<TSubstream: libp2p::tokio_io::AsyncRead + libp2p::tokio_io::AsyncWrite>() {
fn foo<TSubstream: libp2p::futures::AsyncRead + libp2p::futures::AsyncWrite + Send + Unpin + 'static>() {
require_net_behaviour::<Foo<TSubstream>>();
}
}

14
misc/mdns/Cargo.toml
View File

@ -10,21 +10,21 @@ keywords = ["peer-to-peer", "libp2p", "networking"]
categories = ["network-programming", "asynchronous"]
[dependencies]
async-std = "1.0"
data-encoding = "2.0"
dns-parser = "0.8"
futures = "0.1"
either = "1.5.3"
futures = "0.3.1"
lazy_static = "1.2"
libp2p-core = { version = "0.13.0", path = "../../core" }
libp2p-swarm = { version = "0.3.0", path = "../../swarm" }
log = "0.4"
multiaddr = { package = "parity-multiaddr", version = "0.6.0", path = "../multiaddr" }
net2 = "0.2"
rand = "0.6"
smallvec = "0.6"
tokio-io = "0.1"
tokio-reactor = "0.1"
wasm-timer = "0.1"
tokio-udp = "0.1"
smallvec = "1.0"
void = "1.0"
wasm-timer = "0.2.4"
[dev-dependencies]
tokio = "0.1"
get_if_addrs = "0.5.3"

126
misc/mdns/src/behaviour.rs
View File

@ -18,7 +18,7 @@
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
use crate::service::{MdnsService, MdnsPacket};
use crate::service::{MdnsService, MdnsPacket, build_query_response, build_service_discovery_response};
use futures::prelude::*;
use libp2p_core::{address_translation, ConnectedPoint, Multiaddr, PeerId, multiaddr::Protocol};
use libp2p_swarm::{
@ -30,15 +30,16 @@ use libp2p_swarm::{
};
use log::warn;
use smallvec::SmallVec;
use std::{cmp, fmt, io, iter, marker::PhantomData, time::Duration};
use tokio_io::{AsyncRead, AsyncWrite};
use std::{cmp, fmt, io, iter, marker::PhantomData, mem, pin::Pin, time::Duration, task::Context, task::Poll};
use wasm_timer::{Delay, Instant};
const MDNS_RESPONSE_TTL: std::time::Duration = Duration::from_secs(5 * 60);
/// A `NetworkBehaviour` for mDNS. Automatically discovers peers on the local network and adds
/// them to the topology.
pub struct Mdns<TSubstream> {
/// The inner service.
service: MdnsService,
service: MaybeBusyMdnsService,
/// List of nodes that we have discovered, the address, and when their TTL expires.
///
@ -46,7 +47,7 @@ pub struct Mdns<TSubstream> {
/// can appear multiple times.
discovered_nodes: SmallVec<[(PeerId, Multiaddr, Instant); 8]>,
/// Future that fires when the TTL at least one node in `discovered_nodes` expires.
/// Future that fires when the TTL of at least one node in `discovered_nodes` expires.
///
/// `None` if `discovered_nodes` is empty.
closest_expiration: Option<Delay>,
@ -55,11 +56,41 @@ pub struct Mdns<TSubstream> {
marker: PhantomData<TSubstream>,
}
/// `MdnsService::next` takes ownership of `self`, returning a future that resolves with both itself
/// and a `MdnsPacket` (similar to the old Tokio socket send style). The two states are thus `Free`
/// with an `MdnsService` or `Busy` with a future returning the original `MdnsService` and an
/// `MdnsPacket`.
enum MaybeBusyMdnsService {
Free(MdnsService),
Busy(Pin<Box<dyn Future<Output = (MdnsService, MdnsPacket)> + Send>>),
Poisoned,
}
impl fmt::Debug for MaybeBusyMdnsService {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
MaybeBusyMdnsService::Free(service) => {
fmt.debug_struct("MaybeBusyMdnsService::Free")
.field("service", service)
.finish()
},
MaybeBusyMdnsService::Busy(_) => {
fmt.debug_struct("MaybeBusyMdnsService::Busy")
.finish()
}
MaybeBusyMdnsService::Poisoned => {
fmt.debug_struct("MaybeBusyMdnsService::Poisoned")
.finish()
}
}
}
}
impl<TSubstream> Mdns<TSubstream> {
/// Builds a new `Mdns` behaviour.
pub fn new() -> io::Result<Mdns<TSubstream>> {
pub async fn new() -> io::Result<Mdns<TSubstream>> {
Ok(Mdns {
service: MdnsService::new()?,
service: MaybeBusyMdnsService::Free(MdnsService::new().await?),
discovered_nodes: SmallVec::new(),
closest_expiration: None,
marker: PhantomData,
@ -81,7 +112,7 @@ pub enum MdnsEvent {
/// The given combinations of `PeerId` and `Multiaddr` have expired.
///
/// Each discovered record has a time-to-live. When this TTL expires and the address hasn't
/// been refreshed, we remove it from the list emit it as an `Expired` event.
/// been refreshed, we remove it from the list and emit it as an `Expired` event.
Expired(ExpiredAddrsIter),
}
@ -145,7 +176,7 @@ impl fmt::Debug for ExpiredAddrsIter {
impl<TSubstream> NetworkBehaviour for Mdns<TSubstream>
where
TSubstream: AsyncRead + AsyncWrite,
TSubstream: AsyncRead + AsyncWrite + Unpin,
{
type ProtocolsHandler = DummyProtocolsHandler<TSubstream>;
type OutEvent = MdnsEvent;
@ -177,8 +208,9 @@ where
fn poll(
&mut self,
cx: &mut Context,
params: &mut impl PollParameters,
) -> Async<
) -> Poll<
NetworkBehaviourAction<
<Self::ProtocolsHandler as ProtocolsHandler>::InEvent,
Self::OutEvent,
@ -186,8 +218,8 @@ where
> {
// Remove expired peers.
if let Some(ref mut closest_expiration) = self.closest_expiration {
match closest_expiration.poll() {
Ok(Async::Ready(())) => {
match Future::poll(Pin::new(closest_expiration), cx) {
Poll::Ready(Ok(())) => {
let now = Instant::now();
let mut expired = SmallVec::<[(PeerId, Multiaddr); 4]>::new();
while let Some(pos) = self.discovered_nodes.iter().position(|(_, _, exp)| *exp < now) {
@ -200,28 +232,50 @@ where
inner: expired.into_iter(),
});
return Async::Ready(NetworkBehaviourAction::GenerateEvent(event));
return Poll::Ready(NetworkBehaviourAction::GenerateEvent(event));
}
},
Ok(Async::NotReady) => (),
Err(err) => warn!("tokio timer has errored: {:?}", err),
Poll::Pending => (),
Poll::Ready(Err(err)) => warn!("timer has errored: {:?}", err),
}
}
// Polling the mDNS service, and obtain the list of nodes discovered this round.
let discovered = loop {
let event = match self.service.poll() {
Async::Ready(ev) => ev,
Async::NotReady => return Async::NotReady,
let service = mem::replace(&mut self.service, MaybeBusyMdnsService::Poisoned);
let packet = match service {
MaybeBusyMdnsService::Free(service) => {
self.service = MaybeBusyMdnsService::Busy(Box::pin(service.next()));
continue;
},
MaybeBusyMdnsService::Busy(mut fut) => {
match fut.as_mut().poll(cx) {
Poll::Ready((service, packet)) => {
self.service = MaybeBusyMdnsService::Free(service);
packet
},
Poll::Pending => {
self.service = MaybeBusyMdnsService::Busy(fut);
return Poll::Pending;
}
}
},
MaybeBusyMdnsService::Poisoned => panic!("Mdns poisoned"),
};
match event {
match packet {
MdnsPacket::Query(query) => {
let _ = query.respond(
params.local_peer_id().clone(),
params.listened_addresses(),
Duration::from_secs(5 * 60)
);
// MaybeBusyMdnsService should always be Free.
if let MaybeBusyMdnsService::Free(ref mut service) = self.service {
let resp = build_query_response(
query.query_id(),
params.local_peer_id().clone(),
params.listened_addresses().into_iter(),
MDNS_RESPONSE_TTL,
);
service.enqueue_response(resp.unwrap());
} else { debug_assert!(false); }
},
MdnsPacket::Response(response) => {
// We replace the IP address with the address we observe the
@ -240,12 +294,12 @@ where
let new_expiration = Instant::now() + peer.ttl();
let mut addrs = Vec::new();
let mut addrs: Vec<Multiaddr> = Vec::new();
for addr in peer.addresses() {
if let Some(new_addr) = address_translation(&addr, &observed) {
addrs.push(new_addr)
addrs.push(new_addr.clone())
}
addrs.push(addr)
addrs.push(addr.clone())
}
for addr in addrs {
@ -264,18 +318,27 @@ where
break discovered;
},
MdnsPacket::ServiceDiscovery(disc) => {
disc.respond(Duration::from_secs(5 * 60));
// MaybeBusyMdnsService should always be Free.
if let MaybeBusyMdnsService::Free(ref mut service) = self.service {
let resp = build_service_discovery_response(
disc.query_id(),
MDNS_RESPONSE_TTL,
);
service.enqueue_response(resp);
} else { debug_assert!(false); }
},
}
};
// As the final step, we need to refresh `closest_expiration`.
// Getting this far implies that we discovered new nodes. As the final step, we need to
// refresh `closest_expiration`.
self.closest_expiration = self.discovered_nodes.iter()
.fold(None, |exp, &(_, _, elem_exp)| {
Some(exp.map(|exp| cmp::min(exp, elem_exp)).unwrap_or(elem_exp))
})
.map(Delay::new);
Async::Ready(NetworkBehaviourAction::GenerateEvent(MdnsEvent::Discovered(DiscoveredAddrsIter {
.map(Delay::new_at);
Poll::Ready(NetworkBehaviourAction::GenerateEvent(MdnsEvent::Discovered(DiscoveredAddrsIter {
inner: discovered.into_iter(),
})))
}
@ -288,4 +351,3 @@ impl<TSubstream> fmt::Debug for Mdns<TSubstream> {
.finish()
}
}

609
misc/mdns/src/service.rs
View File

@ -19,16 +19,24 @@
// DEALINGS IN THE SOFTWARE.
use crate::{SERVICE_NAME, META_QUERY_SERVICE, dns};
use async_std::net::UdpSocket;
use dns_parser::{Packet, RData};
use futures::{prelude::*, task};
use either::Either::{Left, Right};
use futures::{future, prelude::*};
use libp2p_core::{Multiaddr, PeerId};
use multiaddr::Protocol;
use std::{fmt, io, net::Ipv4Addr, net::SocketAddr, str, time::Duration};
use tokio_reactor::Handle;
use wasm_timer::{Instant, Interval};
use tokio_udp::UdpSocket;
use std::{fmt, io, net::Ipv4Addr, net::SocketAddr, str, time::{Duration, Instant}};
use wasm_timer::Interval;
use lazy_static::lazy_static;
pub use dns::MdnsResponseError;
pub use dns::{MdnsResponseError, build_query_response, build_service_discovery_response};
lazy_static! {
static ref IPV4_MDNS_MULTICAST_ADDRESS: SocketAddr = SocketAddr::from((
Ipv4Addr::new(224, 0, 0, 251),
5353,
));
}
/// A running service that discovers libp2p peers and responds to other libp2p peers' queries on
/// the local network.
@ -53,43 +61,47 @@ pub use dns::MdnsResponseError;
///
/// ```rust
/// # use futures::prelude::*;
/// # use libp2p_core::{identity, PeerId};
/// # use libp2p_mdns::service::{MdnsService, MdnsPacket};
/// # use std::{io, time::Duration};
/// # use futures::executor::block_on;
/// # use libp2p_core::{identity, Multiaddr, PeerId};
/// # use libp2p_mdns::service::{MdnsService, MdnsPacket, build_query_response, build_service_discovery_response};
/// # use std::{io, time::Duration, task::Poll};
/// # fn main() {
/// # let my_peer_id = PeerId::from(identity::Keypair::generate_ed25519().public());
/// # let my_listened_addrs = Vec::new();
/// let mut service = MdnsService::new().expect("Error while creating mDNS service");
/// let _future_to_poll = futures::stream::poll_fn(move || -> Poll<Option<()>, io::Error> {
/// loop {
/// let packet = match service.poll() {
/// Async::Ready(packet) => packet,
/// Async::NotReady => return Ok(Async::NotReady),
/// };
/// # let my_listened_addrs: Vec<Multiaddr> = vec![];
/// # block_on(async {
/// let mut service = MdnsService::new().await.expect("Error while creating mDNS service");
/// let _future_to_poll = async {
/// let (mut service, packet) = service.next().await;
///
/// match packet {
/// MdnsPacket::Query(query) => {
/// println!("Query from {:?}", query.remote_addr());
/// query.respond(
/// my_peer_id.clone(),
/// my_listened_addrs.clone(),
/// Duration::from_secs(120),
/// );
/// }
/// MdnsPacket::Response(response) => {
/// for peer in response.discovered_peers() {
/// println!("Discovered peer {:?}", peer.id());
/// for addr in peer.addresses() {
/// println!("Address = {:?}", addr);
/// }
/// match packet {
/// MdnsPacket::Query(query) => {
/// println!("Query from {:?}", query.remote_addr());
/// let resp = build_query_response(
/// query.query_id(),
/// my_peer_id.clone(),
/// vec![].into_iter(),
/// Duration::from_secs(120),
/// ).unwrap();
/// service.enqueue_response(resp);
/// }
/// MdnsPacket::Response(response) => {
/// for peer in response.discovered_peers() {
/// println!("Discovered peer {:?}", peer.id());
/// for addr in peer.addresses() {
/// println!("Address = {:?}", addr);
/// }
/// }
/// MdnsPacket::ServiceDiscovery(query) => {
/// query.respond(std::time::Duration::from_secs(120));
/// }
/// }
/// MdnsPacket::ServiceDiscovery(disc) => {
/// let resp = build_service_discovery_response(
/// disc.query_id(),
/// Duration::from_secs(120),
/// );
/// service.enqueue_response(resp);
/// }
/// }
/// }).for_each(|_| Ok(()));
/// };
/// # })
/// # }
pub struct MdnsService {
/// Main socket for listening.
@ -113,18 +125,18 @@ pub struct MdnsService {
impl MdnsService {
/// Starts a new mDNS service.
#[inline]
pub fn new() -> io::Result<MdnsService> {
Self::new_inner(false)
pub async fn new() -> io::Result<MdnsService> {
Self::new_inner(false).await
}
/// Same as `new`, but we don't send automatically send queries on the network.
#[inline]
pub fn silent() -> io::Result<MdnsService> {
Self::new_inner(true)
pub async fn silent() -> io::Result<MdnsService> {
Self::new_inner(true).await
}
/// Starts a new mDNS service.
fn new_inner(silent: bool) -> io::Result<MdnsService> {
async fn new_inner(silent: bool) -> io::Result<MdnsService> {
let socket = {
#[cfg(unix)]
fn platform_specific(s: &net2::UdpBuilder) -> io::Result<()> {
@ -139,16 +151,16 @@ impl MdnsService {
builder.bind(("0.0.0.0", 5353))?
};
let socket = UdpSocket::from_std(socket, &Handle::default())?;
let socket = UdpSocket::from(socket);
socket.set_multicast_loop_v4(true)?;
socket.set_multicast_ttl_v4(255)?;
// TODO: correct interfaces?
socket.join_multicast_v4(&From::from([224, 0, 0, 251]), &Ipv4Addr::UNSPECIFIED)?;
socket.join_multicast_v4(From::from([224, 0, 0, 251]), Ipv4Addr::UNSPECIFIED)?;
Ok(MdnsService {
socket,
query_socket: UdpSocket::bind(&From::from(([0, 0, 0, 0], 0)))?,
query_interval: Interval::new(Instant::now(), Duration::from_secs(20)),
query_socket: UdpSocket::bind((Ipv4Addr::from([0u8, 0, 0, 0]), 0u16)).await?,
query_interval: Interval::new_at(Instant::now(), Duration::from_secs(20)),
silent,
recv_buffer: [0; 2048],
send_buffers: Vec::new(),
@ -156,132 +168,102 @@ impl MdnsService {
})
}
/// Polls the service for packets.
pub fn poll(&mut self) -> Async<MdnsPacket<'_>> {
// Send a query every time `query_interval` fires.
// Note that we don't use a loop here—it is pretty unlikely that we need it, and there is
// no point in sending multiple requests in a row.
match self.query_interval.poll() {
Ok(Async::Ready(_)) => {
if !self.silent {
let query = dns::build_query();
self.query_send_buffers.push(query.to_vec());
}
}
Ok(Async::NotReady) => (),
_ => unreachable!("A wasm_timer::Interval never errors"), // TODO: is that true?
};
pub fn enqueue_response(&mut self, rsp: Vec<u8>) {
self.send_buffers.push(rsp);
}
// Flush the send buffer of the main socket.
while !self.send_buffers.is_empty() {
let to_send = self.send_buffers.remove(0);
match self
.socket
.poll_send_to(&to_send, &From::from(([224, 0, 0, 251], 5353)))
{
Ok(Async::Ready(bytes_written)) => {
debug_assert_eq!(bytes_written, to_send.len());
}
Ok(Async::NotReady) => {
self.send_buffers.insert(0, to_send);
break;
}
Err(_) => {
// Errors are non-fatal because they can happen for example if we lose
// connection to the network.
self.send_buffers.clear();
break;
}
}
}
/// Returns a future resolving to itself and the next received `MdnsPacket`.
//
// **Note**: Why does `next` take ownership of itself?
//
// `MdnsService::next` needs to be called from within `NetworkBehaviour`
// implementations. Given that traits cannot have async methods the
// respective `NetworkBehaviour` implementation needs to somehow keep the
// Future returned by `MdnsService::next` across classic `poll`
// invocations. The instance method `next` can either take a reference or
// ownership of itself:
//
// 1. Taking a reference - If `MdnsService::poll` takes a reference to
// `&self` the respective `NetworkBehaviour` implementation would need to
// keep both the Future as well as its `MdnsService` instance across poll
// invocations. Given that in this case the Future would have a reference
// to `MdnsService`, the `NetworkBehaviour` implementation struct would
// need to be self-referential which is not possible without unsafe code in
// Rust.
//
// 2. Taking ownership - Instead `MdnsService::next` takes ownership of
// self and returns it alongside an `MdnsPacket` once the actual future
// resolves, not forcing self-referential structures on the caller.
pub async fn next(mut self) -> (Self, MdnsPacket) {
loop {
// Flush the send buffer of the main socket.
while !self.send_buffers.is_empty() {
let to_send = self.send_buffers.remove(0);
// Flush the query send buffer.
// This has to be after the push to `query_send_buffers`.
while !self.query_send_buffers.is_empty() {
let to_send = self.query_send_buffers.remove(0);
match self
.query_socket
.poll_send_to(&to_send, &From::from(([224, 0, 0, 251], 5353)))
{
Ok(Async::Ready(bytes_written)) => {
debug_assert_eq!(bytes_written, to_send.len());
}
Ok(Async::NotReady) => {
self.query_send_buffers.insert(0, to_send);
break;
}
Err(_) => {
// Errors are non-fatal because they can happen for example if we lose
// connection to the network.
self.query_send_buffers.clear();
break;
}
}
}
// Check for any incoming packet.
match self.socket.poll_recv_from(&mut self.recv_buffer) {
Ok(Async::Ready((len, from))) => {
match Packet::parse(&self.recv_buffer[..len]) {
Ok(packet) => {
if packet.header.query {
if packet
.questions
.iter()
.any(|q| q.qname.to_string().as_bytes() == SERVICE_NAME)
{
return Async::Ready(MdnsPacket::Query(MdnsQuery {
from,
query_id: packet.header.id,
send_buffers: &mut self.send_buffers,
}));
} else if packet
.questions
.iter()
.any(|q| q.qname.to_string().as_bytes() == META_QUERY_SERVICE)
{
// TODO: what if multiple questions, one with SERVICE_NAME and one with META_QUERY_SERVICE?
return Async::Ready(MdnsPacket::ServiceDiscovery(
MdnsServiceDiscovery {
from,
query_id: packet.header.id,
send_buffers: &mut self.send_buffers,
},
));
} else {
// Note that ideally we would use a loop instead. However as of the
// writing of this code non-lexical lifetimes haven't been merged
// yet, and I can't manage to write this code without having borrow
// issues.
task::current().notify();
return Async::NotReady;
}
} else {
return Async::Ready(MdnsPacket::Response(MdnsResponse {
packet,
from,
}));
}
match self.socket.send_to(&to_send, *IPV4_MDNS_MULTICAST_ADDRESS).await {
Ok(bytes_written) => {
debug_assert_eq!(bytes_written, to_send.len());
}
Err(_) => {
// Ignore errors while parsing the packet. We need to poll again for the
// next packet.
// Note that ideally we would use a loop instead. However as of the writing
// of this code non-lexical lifetimes haven't been merged yet, and I can't
// manage to write this code without having borrow issues.
task::current().notify();
return Async::NotReady;
// Errors are non-fatal because they can happen for example if we lose
// connection to the network.
self.send_buffers.clear();
break;
}
}
}
Ok(Async::NotReady) => (),
Err(_) => {
// Error are non-fatal and can happen if we get disconnected from example.
// The query interval will wake up the task at some point so that we can try again.
}
};
Async::NotReady
// Flush the query send buffer.
while !self.query_send_buffers.is_empty() {
let to_send = self.query_send_buffers.remove(0);
match self.query_socket.send_to(&to_send, *IPV4_MDNS_MULTICAST_ADDRESS).await {
Ok(bytes_written) => {
debug_assert_eq!(bytes_written, to_send.len());
}
Err(_) => {
// Errors are non-fatal because they can happen for example if we lose
// connection to the network.
self.query_send_buffers.clear();
break;
}
}
}
// Either (left) listen for incoming packets or (right) send query packets whenever the
// query interval fires.
let selected_output = match futures::future::select(
Box::pin(self.socket.recv_from(&mut self.recv_buffer)),
Box::pin(self.query_interval.next()),
).await {
future::Either::Left((recved, _)) => Left(recved),
future::Either::Right(_) => Right(()),
};
match selected_output {
Left(left) => match left {
Ok((len, from)) => {
match MdnsPacket::new_from_bytes(&self.recv_buffer[..len], from) {
Some(packet) => return (self, packet),
None => {},
}
},
Err(_) => {
// Errors are non-fatal and can happen if we get disconnected from the network.
// The query interval will wake up the task at some point so that we can try again.
},
},
Right(_) => {
// Ensure underlying task is woken up on the next interval tick.
while let Some(_) = self.query_interval.next().now_or_never() {};
if !self.silent {
let query = dns::build_query();
self.query_send_buffers.push(query.to_vec());
}
}
};
}
}
}
@ -295,58 +277,82 @@ impl fmt::Debug for MdnsService {
/// A valid mDNS packet received by the service.
#[derive(Debug)]
pub enum MdnsPacket<'a> {
pub enum MdnsPacket {
/// A query made by a remote.
Query(MdnsQuery<'a>),
Query(MdnsQuery),
/// A response sent by a remote in response to one of our queries.
Response(MdnsResponse<'a>),
Response(MdnsResponse),
/// A request for service discovery.
ServiceDiscovery(MdnsServiceDiscovery<'a>),
ServiceDiscovery(MdnsServiceDiscovery),
}
impl MdnsPacket {
fn new_from_bytes(buf: &[u8], from: SocketAddr) -> Option<MdnsPacket> {
match Packet::parse(buf) {
Ok(packet) => {
if packet.header.query {
if packet
.questions
.iter()
.any(|q| q.qname.to_string().as_bytes() == SERVICE_NAME)
{
let query = MdnsPacket::Query(MdnsQuery {
from,
query_id: packet.header.id,
});
return Some(query);
} else if packet
.questions
.iter()
.any(|q| q.qname.to_string().as_bytes() == META_QUERY_SERVICE)
{
// TODO: what if multiple questions, one with SERVICE_NAME and one with META_QUERY_SERVICE?
let discovery = MdnsPacket::ServiceDiscovery(
MdnsServiceDiscovery {
from,
query_id: packet.header.id,
},
);
return Some(discovery);
} else {
return None;
}
} else {
let resp = MdnsPacket::Response(MdnsResponse::new (
packet,
from,
));
return Some(resp);
}
}
Err(_) => {
return None;
}
}
}
}
/// A received mDNS query.
pub struct MdnsQuery<'a> {
pub struct MdnsQuery {
/// Sender of the address.
from: SocketAddr,
/// Id of the received DNS query. We need to pass this ID back in the results.
query_id: u16,
/// Queue of pending buffers.
send_buffers: &'a mut Vec<Vec<u8>>,
}
impl<'a> MdnsQuery<'a> {
/// Respond to the query.
///
/// Pass the ID of the local peer, and the list of addresses we're listening on.
///
/// If there are more than 2^16-1 addresses, ignores the others.
///
/// > **Note**: Keep in mind that we will also receive this response in an `MdnsResponse`.
#[inline]
pub fn respond<TAddresses>(
self,
peer_id: PeerId,
addresses: TAddresses,
ttl: Duration,
) -> Result<(), MdnsResponseError>
where
TAddresses: IntoIterator<Item = Multiaddr>,
TAddresses::IntoIter: ExactSizeIterator,
{
let response =
dns::build_query_response(self.query_id, peer_id, addresses.into_iter(), ttl)?;
self.send_buffers.push(response);
Ok(())
}
impl MdnsQuery {
/// Source address of the packet.
#[inline]
pub fn remote_addr(&self) -> &SocketAddr {
&self.from
}
/// Query id of the packet.
pub fn query_id(&self) -> u16 {
self.query_id
}
}
impl<'a> fmt::Debug for MdnsQuery<'a> {
impl fmt::Debug for MdnsQuery {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("MdnsQuery")
.field("from", self.remote_addr())
@ -356,31 +362,26 @@ impl<'a> fmt::Debug for MdnsQuery<'a> {
}
/// A received mDNS service discovery query.
pub struct MdnsServiceDiscovery<'a> {
pub struct MdnsServiceDiscovery {
/// Sender of the address.
from: SocketAddr,
/// Id of the received DNS query. We need to pass this ID back in the results.
query_id: u16,
/// Queue of pending buffers.
send_buffers: &'a mut Vec<Vec<u8>>,
}
impl<'a> MdnsServiceDiscovery<'a> {
/// Respond to the query.
#[inline]
pub fn respond(self, ttl: Duration) {
let response = dns::build_service_discovery_response(self.query_id, ttl);
self.send_buffers.push(response);
}
impl MdnsServiceDiscovery {
/// Source address of the packet.
#[inline]
pub fn remote_addr(&self) -> &SocketAddr {
&self.from
}
/// Query id of the packet.
pub fn query_id(&self) -> u16 {
self.query_id
}
}
impl<'a> fmt::Debug for MdnsServiceDiscovery<'a> {
impl fmt::Debug for MdnsServiceDiscovery {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("MdnsServiceDiscovery")
.field("from", self.remote_addr())
@ -390,18 +391,15 @@ impl<'a> fmt::Debug for MdnsServiceDiscovery<'a> {
}
/// A received mDNS response.
pub struct MdnsResponse<'a> {
packet: Packet<'a>,
pub struct MdnsResponse {
peers: Vec<MdnsPeer>,
from: SocketAddr,
}
impl<'a> MdnsResponse<'a> {
/// Returns the list of peers that have been reported in this packet.
///
/// > **Note**: Keep in mind that this will also contain the responses we sent ourselves.
pub fn discovered_peers<'b>(&'b self) -> impl Iterator<Item = MdnsPeer<'b>> {
let packet = &self.packet;
self.packet.answers.iter().filter_map(move |record| {
impl MdnsResponse {
/// Creates a new `MdnsResponse` based on the provided `Packet`.
fn new(packet: Packet, from: SocketAddr) -> MdnsResponse {
let peers = packet.answers.iter().filter_map(|record| {
if record.name.to_string().as_bytes() != SERVICE_NAME {
return None;
}
@ -427,13 +425,25 @@ impl<'a> MdnsResponse<'a> {
Err(_) => return None,
};
Some(MdnsPeer {
packet,
Some(MdnsPeer::new (
&packet,
record_value,
peer_id,
ttl: record.ttl,
})
})
record.ttl,
))
}).collect();
MdnsResponse {
peers,
from,
}
}
/// Returns the list of peers that have been reported in this packet.
///
/// > **Note**: Keep in mind that this will also contain the responses we sent ourselves.
pub fn discovered_peers(&self) -> impl Iterator<Item = &MdnsPeer> {
self.peers.iter()
}
/// Source address of the packet.
@ -443,7 +453,7 @@ impl<'a> MdnsResponse<'a> {
}
}
impl<'a> fmt::Debug for MdnsResponse<'a> {
impl fmt::Debug for MdnsResponse {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("MdnsResponse")
.field("from", self.remote_addr())
@ -452,41 +462,22 @@ impl<'a> fmt::Debug for MdnsResponse<'a> {
}
/// A peer discovered by the service.
pub struct MdnsPeer<'a> {
/// The original packet which will be used to determine the addresses.
packet: &'a Packet<'a>,
/// Cached value of `concat(base32(peer_id), service name)`.
record_value: String,
pub struct MdnsPeer {
addrs: Vec<Multiaddr>,
/// Id of the peer.
peer_id: PeerId,
/// TTL of the record in seconds.
ttl: u32,
}
impl<'a> MdnsPeer<'a> {
/// Returns the id of the peer.
#[inline]
pub fn id(&self) -> &PeerId {
&self.peer_id
}
/// Returns the requested time-to-live for the record.
#[inline]
pub fn ttl(&self) -> Duration {
Duration::from_secs(u64::from(self.ttl))
}
/// Returns the list of addresses the peer says it is listening on.
///
/// Filters out invalid addresses.
pub fn addresses<'b>(&'b self) -> impl Iterator<Item = Multiaddr> + 'b {
let my_peer_id = &self.peer_id;
let record_value = &self.record_value;
self.packet
impl MdnsPeer {
/// Creates a new `MdnsPeer` based on the provided `Packet`.
pub fn new(packet: &Packet, record_value: String, my_peer_id: PeerId, ttl: u32) -> MdnsPeer {
let addrs = packet
.additional
.iter()
.filter_map(move |add_record| {
if &add_record.name.to_string() != record_value {
.filter_map(|add_record| {
if add_record.name.to_string() != record_value {
return None;
}
@ -497,7 +488,7 @@ impl<'a> MdnsPeer<'a> {
}
})
.flat_map(|txt| txt.iter())
.filter_map(move |txt| {
.filter_map(|txt| {
// TODO: wrong, txt can be multiple character strings
let addr = match dns::decode_character_string(txt) {
Ok(a) => a,
@ -515,15 +506,40 @@ impl<'a> MdnsPeer<'a> {
Err(_) => return None,
};
match addr.pop() {
Some(Protocol::P2p(ref peer_id)) if peer_id == my_peer_id => (),
Some(Protocol::P2p(ref peer_id)) if peer_id == &my_peer_id => (),
_ => return None,
};
Some(addr)
})
}).collect();
MdnsPeer {
addrs,
peer_id: my_peer_id.clone(),
ttl,
}
}
/// Returns the id of the peer.
#[inline]
pub fn id(&self) -> &PeerId {
&self.peer_id
}
/// Returns the requested time-to-live for the record.
#[inline]
pub fn ttl(&self) -> Duration {
Duration::from_secs(u64::from(self.ttl))
}
/// Returns the list of addresses the peer says it is listening on.
///
/// Filters out invalid addresses.
pub fn addresses(&self) -> &Vec<Multiaddr> {
&self.addrs
}
}
impl<'a> fmt::Debug for MdnsPeer<'a> {
impl fmt::Debug for MdnsPeer {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("MdnsPeer")
.field("peer_id", &self.peer_id)
@ -533,42 +549,87 @@ impl<'a> fmt::Debug for MdnsPeer<'a> {
#[cfg(test)]
mod tests {
use futures::executor::block_on;
use libp2p_core::PeerId;
use std::{io, time::Duration};
use tokio::{self, prelude::*};
use std::{io::{Error, ErrorKind}, time::Duration};
use wasm_timer::ext::TryFutureExt;
use crate::service::{MdnsPacket, MdnsService};
use multiaddr::multihash::*;
fn discover(peer_id: PeerId) {
let mut service = MdnsService::new().unwrap();
let stream = stream::poll_fn(move || -> Poll<Option<()>, io::Error> {
block_on(async {
let mut service = MdnsService::new().await.unwrap();
loop {
let packet = match service.poll() {
Async::Ready(packet) => packet,
Async::NotReady => return Ok(Async::NotReady),
};
let next = service.next().await;
service = next.0;
match packet {
match next.1 {
MdnsPacket::Query(query) => {
query.respond(peer_id.clone(), None, Duration::from_secs(120)).unwrap();
let resp = crate::dns::build_query_response(
query.query_id(),
peer_id.clone(),
vec![].into_iter(),
Duration::from_secs(120),
).unwrap();
service.enqueue_response(resp);
}
MdnsPacket::Response(response) => {
for peer in response.discovered_peers() {
if peer.id() == &peer_id {
return Ok(Async::Ready(None));
return;
}
}
}
MdnsPacket::ServiceDiscovery(_) => {}
MdnsPacket::ServiceDiscovery(_) => panic!("did not expect a service discovery packet")
}
}
});
})
}
tokio::run(
stream
.map_err(|err| panic!("{:?}", err))
.for_each(|_| Ok(())),
);
// As of today the underlying UDP socket is not stubbed out. Thus tests run in parallel to this
// unit tests inter fear with it. Test needs to be run in sequence to ensure test properties.
#[test]
fn respect_query_interval() {
let own_ips: Vec<std::net::IpAddr> = get_if_addrs::get_if_addrs().unwrap()
.into_iter()
.map(|i| i.addr.ip())
.collect();
let fut = async {
let mut service = MdnsService::new().await.unwrap();
let mut sent_queries = vec![];
loop {
let next = service.next().await;
service = next.0;
match next.1 {
MdnsPacket::Query(query) => {
// Ignore queries from other nodes.
let source_ip = query.remote_addr().ip();
if !own_ips.contains(&source_ip) {
continue;
}
sent_queries.push(query);
if sent_queries.len() > 1 {
return Ok(())
}
}
// Ignore response packets. We don't stub out the UDP socket, thus this is
// either random noise from the network, or noise from other unit tests running
// in parallel.
MdnsPacket::Response(_) => {},
MdnsPacket::ServiceDiscovery(_) => {
return Err(Error::new(ErrorKind::Other, "did not expect a service discovery packet"));
},
}
}
};
// TODO: This might be too long for a unit test.
block_on(fut.timeout(Duration::from_secs(41))).unwrap();
}
#[test]

2
misc/multiaddr/Cargo.toml
View File

@ -17,7 +17,7 @@ data-encoding = "2.1"
multihash = { package = "parity-multihash", version = "0.2.0", path = "../multihash" }
percent-encoding = "2.1.0"
serde = "1.0.70"
unsigned-varint = "0.2"
unsigned-varint = "0.3"
url = { version = "2.1.0", default-features = false }
[dev-dependencies]

22
misc/multiaddr/src/lib.rs
View File

@ -7,7 +7,7 @@ mod errors;
mod from_url;
mod util;
use bytes::{Bytes, BytesMut};
use bytes::Bytes;
use serde::{
Deserialize,
Deserializer,
@ -290,10 +290,10 @@ impl From<Ipv6Addr> for Multiaddr {
}
}
impl TryFrom<Bytes> for Multiaddr {
impl TryFrom<Vec<u8>> for Multiaddr {
type Error = Error;
fn try_from(v: Bytes) -> Result<Self> {
fn try_from(v: Vec<u8>) -> Result<Self> {
// Check if the argument is a valid `Multiaddr` by reading its protocols.
let mut slice = &v[..];
while !slice.is_empty() {
@ -304,22 +304,6 @@ impl TryFrom<Bytes> for Multiaddr {
}
}
impl TryFrom<BytesMut> for Multiaddr {
type Error = Error;
fn try_from(v: BytesMut) -> Result<Self> {
Multiaddr::try_from(v.freeze())
}
}
impl TryFrom<Vec<u8>> for Multiaddr {
type Error = Error;
fn try_from(v: Vec<u8>) -> Result<Self> {
Multiaddr::try_from(Bytes::from(v))
}
}
impl TryFrom<String> for Multiaddr {
type Error = Error;

6
misc/multihash/Cargo.toml
View File

@ -11,9 +11,9 @@ documentation = "https://docs.rs/parity-multihash/"
[dependencies]
blake2 = { version = "0.8", default-features = false }
bytes = "0.4.12"
rand = { version = "0.6", default-features = false, features = ["std"] }
bytes = "0.5"
rand = { version = "0.7", default-features = false, features = ["std"] }
sha-1 = { version = "0.8", default-features = false }
sha2 = { version = "0.8", default-features = false }
sha3 = { version = "0.8", default-features = false }
unsigned-varint = "0.2"
unsigned-varint = "0.3"

2
misc/multihash/src/lib.rs
View File

@ -247,7 +247,7 @@ impl<'a> MultihashRef<'a> {
/// This operation allocates.
pub fn into_owned(self) -> Multihash {
Multihash {
bytes: Bytes::from(self.bytes)
bytes: Bytes::copy_from_slice(self.bytes)
}
}

6
misc/multistream-select/Cargo.toml
View File

@ -10,12 +10,12 @@ categories = ["network-programming", "asynchronous"]
edition = "2018"
[dependencies]
bytes = "0.4"
bytes = "0.5"
futures = "0.1"
log = "0.4"
smallvec = "0.6"
smallvec = "1.0"
tokio-io = "0.1"
unsigned-varint = "0.2.2"
unsigned-varint = "0.3"
[dev-dependencies]
tokio = "0.1"

4
misc/multistream-select/src/length_delimited.rs
View File

@ -18,7 +18,7 @@
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
use bytes::{Bytes, BytesMut, BufMut};
use bytes::{Bytes, BytesMut, Buf, BufMut};
use futures::{try_ready, Async, Poll, Sink, StartSend, Stream, AsyncSink};
use std::{io, u16};
use tokio_io::{AsyncRead, AsyncWrite};
@ -136,7 +136,7 @@ impl<R> LengthDelimited<R> {
"Failed to write buffered frame."))
}
self.write_buffer.split_to(n);
self.write_buffer.advance(n);
}
Ok(Async::Ready(()))

10
misc/multistream-select/src/negotiated.rs
View File

@ -18,7 +18,7 @@
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
use bytes::BytesMut;
use bytes::{BytesMut, Buf};
use crate::protocol::{Protocol, MessageReader, Message, Version, ProtocolError};
use futures::{prelude::*, Async, try_ready};
use log::debug;
@ -93,7 +93,7 @@ impl<TInner> Negotiated<TInner> {
}
if let State::Completed { remaining, .. } = &mut self.state {
let _ = remaining.take(); // Drop remaining data flushed above.
let _ = remaining.split_to(remaining.len()); // Drop remaining data flushed above.
return Ok(Async::Ready(()))
}
@ -232,7 +232,7 @@ where
if n == 0 {
return Err(io::ErrorKind::WriteZero.into())
}
remaining.split_to(n);
remaining.advance(n);
}
io.write(buf)
},
@ -251,7 +251,7 @@ where
io::ErrorKind::WriteZero,
"Failed to write remaining buffer."))
}
remaining.split_to(n);
remaining.advance(n);
}
io.flush()
},
@ -363,7 +363,7 @@ mod tests {
let cap = rem.len() + free as usize;
let step = u8::min(free, step) as usize + 1;
let buf = Capped { buf: Vec::with_capacity(cap), step };
let rem = BytesMut::from(rem);
let rem = BytesMut::from(&rem[..]);
let mut io = Negotiated::completed(buf, rem.clone());
let mut written = 0;
loop {

6
misc/multistream-select/src/protocol.rs
View File

@ -143,7 +143,7 @@ impl TryFrom<&[u8]> for Protocol {
type Error = ProtocolError;
fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
Self::try_from(Bytes::from(value))
Self::try_from(Bytes::copy_from_slice(value))
}
}
@ -208,7 +208,7 @@ impl Message {
out_msg.push(b'\n')
}
dest.reserve(out_msg.len());
dest.put(out_msg);
dest.put(out_msg.as_ref());
Ok(())
}
Message::NotAvailable => {
@ -254,7 +254,7 @@ impl Message {
if len == 0 || len > rem.len() || rem[len - 1] != b'\n' {
return Err(ProtocolError::InvalidMessage)
}
let p = Protocol::try_from(Bytes::from(&rem[.. len - 1]))?;
let p = Protocol::try_from(Bytes::copy_from_slice(&rem[.. len - 1]))?;
protocols.push(p);
remaining = &rem[len ..]
}

8
misc/rw-stream-sink/Cargo.toml
View File

@ -10,6 +10,8 @@ keywords = ["networking"]
categories = ["network-programming", "asynchronous"]
[dependencies]
bytes = "0.4"
futures = "0.1"
tokio-io = "0.1"
futures = "0.3.1"
static_assertions = "1"
[dev-dependencies]
async-std = "1.0"

254
misc/rw-stream-sink/src/lib.rs
View File

@ -18,202 +18,180 @@
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//! This crate provides the `RwStreamSink` type. It wraps around a `Stream + Sink` that produces
//! and accepts byte arrays, and implements `AsyncRead` and `AsyncWrite`.
//! This crate provides the [`RwStreamSink`] type. It wraps around a [`Stream`]
//! and [`Sink`] that produces and accepts byte arrays, and implements
//! [`AsyncRead`] and [`AsyncWrite`].
//!
//! Each call to `write()` will send one packet on the sink. Calls to `read()` will read from
//! incoming packets.
//!
//! > **Note**: Although this crate is hosted in the libp2p repo, it is purely a utility crate and
//! > not at all specific to libp2p.
//! Each call to [`AsyncWrite::poll_write`] will send one packet to the sink.
//! Calls to [`AsyncRead::read`] will read from the stream's incoming packets.
use bytes::{Buf, IntoBuf};
use futures::{Async, AsyncSink, Poll, Sink, Stream};
use std::cmp;
use std::io::Error as IoError;
use std::io::ErrorKind as IoErrorKind;
use std::io::{Read, Write};
use tokio_io::{AsyncRead, AsyncWrite};
use futures::{prelude::*, ready};
use std::{io::{self, Read}, pin::Pin, task::{Context, Poll}};
/// Wraps around a `Stream + Sink` whose items are buffers. Implements `AsyncRead` and `AsyncWrite`.
pub struct RwStreamSink<S>
where
S: Stream,
S::Item: IntoBuf,
{
static_assertions::const_assert!(std::mem::size_of::<usize>() <= std::mem::size_of::<u64>());
/// Wraps a [`Stream`] and [`Sink`] whose items are buffers.
/// Implements [`AsyncRead`] and [`AsyncWrite`].
pub struct RwStreamSink<S: TryStream> {
inner: S,
current_item: Option<<S::Item as IntoBuf>::Buf>,
current_item: Option<std::io::Cursor<<S as TryStream>::Ok>>
}
impl<S> RwStreamSink<S>
where
S: Stream,
S::Item: IntoBuf,
{
impl<S: TryStream> RwStreamSink<S> {
/// Wraps around `inner`.
pub fn new(inner: S) -> RwStreamSink<S> {
pub fn new(inner: S) -> Self {
RwStreamSink { inner, current_item: None }
}
}
impl<S> Read for RwStreamSink<S>
where
S: Stream<Error = IoError>,
S::Item: IntoBuf,
{
fn read(&mut self, buf: &mut [u8]) -> Result<usize, IoError> {
// Grab the item to copy from.
let item_to_copy = loop {
if let Some(ref mut i) = self.current_item {
if i.has_remaining() {
break i;
}
}
self.current_item = Some(match self.inner.poll()? {
Async::Ready(Some(i)) => i.into_buf(),
Async::Ready(None) => return Ok(0), // EOF
Async::NotReady => return Err(IoErrorKind::WouldBlock.into()),
});
};
// Copy it!
debug_assert!(item_to_copy.has_remaining());
let to_copy = cmp::min(buf.len(), item_to_copy.remaining());
item_to_copy.take(to_copy).copy_to_slice(&mut buf[..to_copy]);
Ok(to_copy)
}
}
impl<S> AsyncRead for RwStreamSink<S>
where
S: Stream<Error = IoError>,
S::Item: IntoBuf,
S: TryStream<Error = io::Error> + Unpin,
<S as TryStream>::Ok: AsRef<[u8]>
{
unsafe fn prepare_uninitialized_buffer(&self, _: &mut [u8]) -> bool {
false
}
}
fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context, buf: &mut [u8]) -> Poll<io::Result<usize>> {
// Grab the item to copy from.
let item_to_copy = loop {
if let Some(ref mut i) = self.current_item {
if i.position() < i.get_ref().as_ref().len() as u64 {
break i
}
}
self.current_item = Some(match ready!(self.inner.try_poll_next_unpin(cx)) {
Some(Ok(i)) => std::io::Cursor::new(i),
Some(Err(e)) => return Poll::Ready(Err(e)),
None => return Poll::Ready(Ok(0)) // EOF
});
};
impl<S> Write for RwStreamSink<S>
where
S: Stream + Sink<SinkError = IoError>,
S::SinkItem: for<'r> From<&'r [u8]>,
S::Item: IntoBuf,
{
fn write(&mut self, buf: &[u8]) -> Result<usize, IoError> {
let len = buf.len();
match self.inner.start_send(buf.into())? {
AsyncSink::Ready => Ok(len),
AsyncSink::NotReady(_) => Err(IoError::new(IoErrorKind::WouldBlock, "not ready")),
}
}
fn flush(&mut self) -> Result<(), IoError> {
match self.inner.poll_complete()? {
Async::Ready(()) => Ok(()),
Async::NotReady => Err(IoError::new(IoErrorKind::WouldBlock, "not ready"))
}
// Copy it!
Poll::Ready(Ok(item_to_copy.read(buf)?))
}
}
impl<S> AsyncWrite for RwStreamSink<S>
where
S: Stream + Sink<SinkError = IoError>,
S::SinkItem: for<'r> From<&'r [u8]>,
S::Item: IntoBuf,
S: TryStream + Sink<<S as TryStream>::Ok, Error = io::Error> + Unpin,
<S as TryStream>::Ok: for<'r> From<&'r [u8]>
{
fn shutdown(&mut self) -> Poll<(), IoError> {
self.inner.close()
fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) -> Poll<io::Result<usize>> {
ready!(Pin::new(&mut self.inner).poll_ready(cx)?);
let n = buf.len();
if let Err(e) = Pin::new(&mut self.inner).start_send(buf.into()) {
return Poll::Ready(Err(e))
}
Poll::Ready(Ok(n))
}
fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
Pin::new(&mut self.inner).poll_flush(cx)
}
fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
Pin::new(&mut self.inner).poll_close(cx)
}
}
impl<S: TryStream> Unpin for RwStreamSink<S> {}
#[cfg(test)]
mod tests {
use bytes::Bytes;
use crate::RwStreamSink;
use futures::{prelude::*, stream, sync::mpsc::channel};
use std::io::Read;
use async_std::task;
use futures::{channel::mpsc, prelude::*, stream};
use std::{pin::Pin, task::{Context, Poll}};
use super::RwStreamSink;
// This struct merges a stream and a sink and is quite useful for tests.
struct Wrapper<St, Si>(St, Si);
impl<St, Si> Stream for Wrapper<St, Si>
where
St: Stream,
St: Stream + Unpin,
Si: Unpin
{
type Item = St::Item;
type Error = St::Error;
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
self.0.poll()
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
self.0.poll_next_unpin(cx)
}
}
impl<St, Si> Sink for Wrapper<St, Si>
impl<St, Si, T> Sink<T> for Wrapper<St, Si>
where
Si: Sink,
St: Unpin,
Si: Sink<T> + Unpin,
{
type SinkItem = Si::SinkItem;
type SinkError = Si::SinkError;
fn start_send(
&mut self,
item: Self::SinkItem,
) -> StartSend<Self::SinkItem, Self::SinkError> {
self.1.start_send(item)
type Error = Si::Error;
fn poll_ready(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
Pin::new(&mut self.1).poll_ready(cx)
}
fn poll_complete(&mut self) -> Poll<(), Self::SinkError> {
self.1.poll_complete()
fn start_send(mut self: Pin<&mut Self>, item: T) -> Result<(), Self::Error> {
Pin::new(&mut self.1).start_send(item)
}
fn close(&mut self) -> Poll<(), Self::SinkError> {
self.1.close()
fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
Pin::new(&mut self.1).poll_flush(cx)
}
fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
Pin::new(&mut self.1).poll_close(cx)
}
}
#[test]
fn basic_reading() {
let (tx1, _) = channel::<Vec<u8>>(10);
let (tx2, rx2) = channel(10);
let (tx1, _) = mpsc::channel::<Vec<u8>>(10);
let (mut tx2, rx2) = mpsc::channel(10);
let mut wrapper = RwStreamSink::new(Wrapper(rx2.map_err(|_| panic!()), tx1));
let mut wrapper = RwStreamSink::new(Wrapper(rx2.map(Ok), tx1));
tx2.send(Bytes::from("hel"))
.and_then(|tx| tx.send(Bytes::from("lo wor")))
.and_then(|tx| tx.send(Bytes::from("ld")))
.wait()
.unwrap();
task::block_on(async move {
tx2.send(Vec::from("hel")).await.unwrap();
tx2.send(Vec::from("lo wor")).await.unwrap();
tx2.send(Vec::from("ld")).await.unwrap();
tx2.close().await.unwrap();
let mut data = Vec::new();
wrapper.read_to_end(&mut data).unwrap();
assert_eq!(data, b"hello world");
let mut data = Vec::new();
wrapper.read_to_end(&mut data).await.unwrap();
assert_eq!(data, b"hello world");
})
}
#[test]
fn skip_empty_stream_items() {
let data: Vec<&[u8]> = vec![b"", b"foo", b"", b"bar", b"", b"baz", b""];
let mut rws = RwStreamSink::new(stream::iter_ok::<_, std::io::Error>(data));
let mut rws = RwStreamSink::new(stream::iter(data).map(Ok));
let mut buf = [0; 9];
assert_eq!(3, rws.read(&mut buf).unwrap());
assert_eq!(3, rws.read(&mut buf[3..]).unwrap());
assert_eq!(3, rws.read(&mut buf[6..]).unwrap());
assert_eq!(0, rws.read(&mut buf).unwrap());
assert_eq!(b"foobarbaz", &buf[..]);
task::block_on(async move {
assert_eq!(3, rws.read(&mut buf).await.unwrap());
assert_eq!(3, rws.read(&mut buf[3..]).await.unwrap());
assert_eq!(3, rws.read(&mut buf[6..]).await.unwrap());
assert_eq!(0, rws.read(&mut buf).await.unwrap());
assert_eq!(b"foobarbaz", &buf[..])
})
}
#[test]
fn partial_read() {
let data: Vec<&[u8]> = vec![b"hell", b"o world"];
let mut rws = RwStreamSink::new(stream::iter_ok::<_, std::io::Error>(data));
let mut rws = RwStreamSink::new(stream::iter(data).map(Ok));
let mut buf = [0; 3];
assert_eq!(3, rws.read(&mut buf).unwrap());
assert_eq!(b"hel", &buf[..3]);
assert_eq!(0, rws.read(&mut buf[..0]).unwrap());
assert_eq!(1, rws.read(&mut buf).unwrap());
assert_eq!(b"l", &buf[..1]);
assert_eq!(3, rws.read(&mut buf).unwrap());
assert_eq!(b"o w", &buf[..3]);
assert_eq!(0, rws.read(&mut buf[..0]).unwrap());
assert_eq!(3, rws.read(&mut buf).unwrap());
assert_eq!(b"orl", &buf[..3]);
assert_eq!(1, rws.read(&mut buf).unwrap());
assert_eq!(b"d", &buf[..1]);
assert_eq!(0, rws.read(&mut buf).unwrap());
task::block_on(async move {
assert_eq!(3, rws.read(&mut buf).await.unwrap());
assert_eq!(b"hel", &buf[..3]);
assert_eq!(0, rws.read(&mut buf[..0]).await.unwrap());
assert_eq!(1, rws.read(&mut buf).await.unwrap());
assert_eq!(b"l", &buf[..1]);
assert_eq!(3, rws.read(&mut buf).await.unwrap());
assert_eq!(b"o w", &buf[..3]);
assert_eq!(0, rws.read(&mut buf[..0]).await.unwrap());
assert_eq!(3, rws.read(&mut buf).await.unwrap());
assert_eq!(b"orl", &buf[..3]);
assert_eq!(1, rws.read(&mut buf).await.unwrap());
assert_eq!(b"d", &buf[..1]);
assert_eq!(0, rws.read(&mut buf).await.unwrap());
})
}
}

11
muxers/mplex/Cargo.toml
View File

@ -10,16 +10,15 @@ keywords = ["peer-to-peer", "libp2p", "networking"]
categories = ["network-programming", "asynchronous"]
[dependencies]
bytes = "0.4.5"
bytes = "0.5"
fnv = "1.0"
futures = "0.1"
futures = "0.3.1"
futures_codec = "0.3.4"
libp2p-core = { version = "0.13.0", path = "../../core" }
log = "0.4"
parking_lot = "0.9"
tokio-codec = "0.1"
tokio-io = "0.1"
unsigned-varint = { version = "0.2.1", features = ["codec"] }
unsigned-varint = { version = "0.3", features = ["futures-codec"] }
[dev-dependencies]
async-std = "1.0"
libp2p-tcp = { version = "0.13.0", path = "../../transports/tcp" }
tokio = "0.1"

2
muxers/mplex/src/codec.rs
View File

@ -19,10 +19,10 @@
// DEALINGS IN THE SOFTWARE.
use libp2p_core::Endpoint;
use futures_codec::{Decoder, Encoder};
use std::io::{Error as IoError, ErrorKind as IoErrorKind};
use std::mem;
use bytes::{BufMut, Bytes, BytesMut};
use tokio_io::codec::{Decoder, Encoder};
use unsigned_varint::{codec, encode};
// Maximum size for a packet: 1MB as per the spec.

243
muxers/mplex/src/lib.rs
View File

@ -20,9 +20,10 @@
mod codec;
use std::{cmp, iter, mem};
use std::{cmp, iter, mem, pin::Pin, task::Context, task::Poll};
use std::io::{Error as IoError, ErrorKind as IoErrorKind};
use std::sync::{atomic::AtomicUsize, atomic::Ordering, Arc};
use std::sync::Arc;
use std::task::Waker;
use bytes::Bytes;
use libp2p_core::{
Endpoint,
@ -31,10 +32,10 @@ use libp2p_core::{
};
use log::{debug, trace};
use parking_lot::Mutex;
use fnv::{FnvHashMap, FnvHashSet};
use futures::{prelude::*, executor, future, stream::Fuse, task, task_local, try_ready};
use tokio_codec::Framed;
use tokio_io::{AsyncRead, AsyncWrite};
use fnv::FnvHashSet;
use futures::{prelude::*, future, ready, stream::Fuse};
use futures::task::{ArcWake, waker_ref};
use futures_codec::Framed;
/// Configuration for the multiplexer.
#[derive(Debug, Clone)]
@ -96,22 +97,22 @@ impl MplexConfig {
#[inline]
fn upgrade<C>(self, i: C) -> Multiplex<C>
where
C: AsyncRead + AsyncWrite
C: AsyncRead + AsyncWrite + Unpin
{
let max_buffer_len = self.max_buffer_len;
Multiplex {
inner: Mutex::new(MultiplexInner {
error: Ok(()),
inner: executor::spawn(Framed::new(i, codec::Codec::new()).fuse()),
inner: Framed::new(i, codec::Codec::new()).fuse(),
config: self,
buffer: Vec::with_capacity(cmp::min(max_buffer_len, 512)),
opened_substreams: Default::default(),
next_outbound_stream_id: 0,
notifier_read: Arc::new(Notifier {
to_notify: Mutex::new(Default::default()),
to_wake: Mutex::new(Default::default()),
}),
notifier_write: Arc::new(Notifier {
to_notify: Mutex::new(Default::default()),
to_wake: Mutex::new(Default::default()),
}),
is_shutdown: false,
is_acknowledged: false,
@ -156,27 +157,27 @@ impl UpgradeInfo for MplexConfig {
impl<C> InboundUpgrade<C> for MplexConfig
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
{
type Output = Multiplex<Negotiated<C>>;
type Error = IoError;
type Future = future::FutureResult<Self::Output, IoError>;
type Future = future::Ready<Result<Self::Output, IoError>>;
fn upgrade_inbound(self, socket: Negotiated<C>, _: Self::Info) -> Self::Future {
future::ok(self.upgrade(socket))
future::ready(Ok(self.upgrade(socket)))
}
}
impl<C> OutboundUpgrade<C> for MplexConfig
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
{
type Output = Multiplex<Negotiated<C>>;
type Error = IoError;
type Future = future::FutureResult<Self::Output, IoError>;
type Future = future::Ready<Result<Self::Output, IoError>>;
fn upgrade_outbound(self, socket: Negotiated<C>, _: Self::Info) -> Self::Future {
future::ok(self.upgrade(socket))
future::ready(Ok(self.upgrade(socket)))
}
}
@ -190,7 +191,7 @@ struct MultiplexInner<C> {
// Error that happened earlier. Should poison any attempt to use this `MultiplexError`.
error: Result<(), IoError>,
// Underlying stream.
inner: executor::Spawn<Fuse<Framed<C, codec::Codec>>>,
inner: Fuse<Framed<C, codec::Codec>>,
/// The original configuration.
config: MplexConfig,
// Buffer of elements pulled from the stream but not processed yet.
@ -202,9 +203,9 @@ struct MultiplexInner<C> {
opened_substreams: FnvHashSet<(u32, Endpoint)>,
// Id of the next outgoing substream.
next_outbound_stream_id: u32,
/// List of tasks to notify when a read event happens on the underlying stream.
/// List of wakers to wake when a read event happens on the underlying stream.
notifier_read: Arc<Notifier>,
/// List of tasks to notify when a write event happens on the underlying stream.
/// List of wakers to wake when a write event happens on the underlying stream.
notifier_write: Arc<Notifier>,
/// If true, the connection has been shut down. We need to be careful not to accidentally
/// call `Sink::poll_complete` or `Sink::start_send` after `Sink::close`.
@ -214,23 +215,26 @@ struct MultiplexInner<C> {
}
struct Notifier {
/// List of tasks to notify.
to_notify: Mutex<FnvHashMap<usize, task::Task>>,
/// List of wakers to wake.
to_wake: Mutex<Vec<Waker>>,
}
impl executor::Notify for Notifier {
fn notify(&self, _: usize) {
let tasks = mem::replace(&mut *self.to_notify.lock(), Default::default());
for (_, task) in tasks {
task.notify();
impl Notifier {
fn insert(&self, waker: &Waker) {
let mut to_wake = self.to_wake.lock();
if to_wake.iter().all(|w| !w.will_wake(waker)) {
to_wake.push(waker.clone());
}
}
}
// TODO: replace with another system
static NEXT_TASK_ID: AtomicUsize = AtomicUsize::new(0);
task_local!{
static TASK_ID: usize = NEXT_TASK_ID.fetch_add(1, Ordering::Relaxed)
impl ArcWake for Notifier {
fn wake_by_ref(arc_self: &Arc<Self>) {
let wakers = mem::replace(&mut *arc_self.to_wake.lock(), Default::default());
for waker in wakers {
waker.wake();
}
}
}
// Note [StreamId]: mplex no longer partitions stream IDs into odd (for initiators) and
@ -245,25 +249,27 @@ task_local!{
/// Processes elements in `inner` until one matching `filter` is found.
///
/// If `NotReady` is returned, the current task is scheduled for later, just like with any `Poll`.
/// `Ready(Some())` is almost always returned. An error is returned if the stream is EOF.
fn next_match<C, F, O>(inner: &mut MultiplexInner<C>, mut filter: F) -> Poll<O, IoError>
where C: AsyncRead + AsyncWrite,
/// If `Pending` is returned, the waker is kept and notified later, just like with any `Poll`.
/// `Ready(Ok())` is almost always returned. An error is returned if the stream is EOF.
fn next_match<C, F, O>(inner: &mut MultiplexInner<C>, cx: &mut Context, mut filter: F) -> Poll<Result<O, IoError>>
where C: AsyncRead + AsyncWrite + Unpin,
F: FnMut(&codec::Elem) -> Option<O>,
{
// If an error happened earlier, immediately return it.
if let Err(ref err) = inner.error {
return Err(IoError::new(err.kind(), err.to_string()));
return Poll::Ready(Err(IoError::new(err.kind(), err.to_string())));
}
if let Some((offset, out)) = inner.buffer.iter().enumerate().filter_map(|(n, v)| filter(v).map(|v| (n, v))).next() {
// Found a matching entry in the existing buffer!
// The buffer was full and no longer is, so let's notify everything.
if inner.buffer.len() == inner.config.max_buffer_len {
executor::Notify::notify(&*inner.notifier_read, 0);
ArcWake::wake_by_ref(&inner.notifier_read);
}
inner.buffer.remove(offset);
return Ok(Async::Ready(out));
return Poll::Ready(Ok(out));
}
loop {
@ -274,24 +280,24 @@ where C: AsyncRead + AsyncWrite,
match inner.config.max_buffer_behaviour {
MaxBufferBehaviour::CloseAll => {
inner.error = Err(IoError::new(IoErrorKind::Other, "reached maximum buffer length"));
return Err(IoError::new(IoErrorKind::Other, "reached maximum buffer length"));
return Poll::Ready(Err(IoError::new(IoErrorKind::Other, "reached maximum buffer length")));
},
MaxBufferBehaviour::Block => {
inner.notifier_read.to_notify.lock().insert(TASK_ID.with(|&t| t), task::current());
return Ok(Async::NotReady);
inner.notifier_read.insert(cx.waker());
return Poll::Pending
},
}
}
inner.notifier_read.to_notify.lock().insert(TASK_ID.with(|&t| t), task::current());
let elem = match inner.inner.poll_stream_notify(&inner.notifier_read, 0) {
Ok(Async::Ready(Some(item))) => item,
Ok(Async::Ready(None)) => return Err(IoErrorKind::BrokenPipe.into()),
Ok(Async::NotReady) => return Ok(Async::NotReady),
Err(err) => {
inner.notifier_read.insert(cx.waker());
let elem = match Stream::poll_next(Pin::new(&mut inner.inner), &mut Context::from_waker(&waker_ref(&inner.notifier_read))) {
Poll::Ready(Some(Ok(item))) => item,
Poll::Ready(None) => return Poll::Ready(Err(IoErrorKind::BrokenPipe.into())),
Poll::Pending => return Poll::Pending,
Poll::Ready(Some(Err(err))) => {
let err2 = IoError::new(err.kind(), err.to_string());
inner.error = Err(err);
return Err(err2);
return Poll::Ready(Err(err2));
},
};
@ -312,7 +318,7 @@ where C: AsyncRead + AsyncWrite,
}
if let Some(out) = filter(&elem) {
return Ok(Async::Ready(out));
return Poll::Ready(Ok(out));
} else {
let endpoint = elem.endpoint().unwrap_or(Endpoint::Dialer);
if inner.opened_substreams.contains(&(elem.substream_id(), !endpoint)) || elem.is_open_msg() {
@ -325,45 +331,57 @@ where C: AsyncRead + AsyncWrite,
}
// Small convenience function that tries to write `elem` to the stream.
fn poll_send<C>(inner: &mut MultiplexInner<C>, elem: codec::Elem) -> Poll<(), IoError>
where C: AsyncRead + AsyncWrite
fn poll_send<C>(inner: &mut MultiplexInner<C>, cx: &mut Context, elem: codec::Elem) -> Poll<Result<(), IoError>>
where C: AsyncRead + AsyncWrite + Unpin
{
if inner.is_shutdown {
return Err(IoError::new(IoErrorKind::Other, "connection is shut down"))
return Poll::Ready(Err(IoError::new(IoErrorKind::Other, "connection is shut down")))
}
inner.notifier_write.to_notify.lock().insert(TASK_ID.with(|&t| t), task::current());
match inner.inner.start_send_notify(elem, &inner.notifier_write, 0) {
Ok(AsyncSink::Ready) => Ok(Async::Ready(())),
Ok(AsyncSink::NotReady(_)) => Ok(Async::NotReady),
Err(err) => Err(err)
inner.notifier_write.insert(cx.waker());
match Sink::poll_ready(Pin::new(&mut inner.inner), &mut Context::from_waker(&waker_ref(&inner.notifier_write))) {
Poll::Ready(Ok(())) => {
match Sink::start_send(Pin::new(&mut inner.inner), elem) {
Ok(()) => Poll::Ready(Ok(())),
Err(err) => Poll::Ready(Err(err))
}
},
Poll::Pending => Poll::Pending,
Poll::Ready(Err(err)) => Poll::Ready(Err(err))
}
}
impl<C> StreamMuxer for Multiplex<C>
where C: AsyncRead + AsyncWrite
where C: AsyncRead + AsyncWrite + Unpin
{
type Substream = Substream;
type OutboundSubstream = OutboundSubstream;
type Error = IoError;
fn poll_inbound(&self) -> Poll<Self::Substream, IoError> {
fn poll_inbound(&self, cx: &mut Context) -> Poll<Result<Self::Substream, IoError>> {
let mut inner = self.inner.lock();
if inner.opened_substreams.len() >= inner.config.max_substreams {
debug!("Refused substream; reached maximum number of substreams {}", inner.config.max_substreams);
return Err(IoError::new(IoErrorKind::ConnectionRefused,
"exceeded maximum number of open substreams"));
return Poll::Ready(Err(IoError::new(IoErrorKind::ConnectionRefused,
"exceeded maximum number of open substreams")));
}
let num = try_ready!(next_match(&mut inner, |elem| {
let num = ready!(next_match(&mut inner, cx, |elem| {
match elem {
codec::Elem::Open { substream_id } => Some(*substream_id),
_ => None,
}
}));
let num = match num {
Ok(n) => n,
Err(err) => return Poll::Ready(Err(err)),
};
debug!("Successfully opened inbound substream {}", num);
Ok(Async::Ready(Substream {
Poll::Ready(Ok(Substream {
current_data: Bytes::new(),
num,
endpoint: Endpoint::Listener,
@ -391,21 +409,21 @@ where C: AsyncRead + AsyncWrite
}
}
fn poll_outbound(&self, substream: &mut Self::OutboundSubstream) -> Poll<Self::Substream, IoError> {
fn poll_outbound(&self, cx: &mut Context, substream: &mut Self::OutboundSubstream) -> Poll<Result<Self::Substream, IoError>> {
loop {
let mut inner = self.inner.lock();
let polling = match substream.state {
OutboundSubstreamState::SendElem(ref elem) => {
poll_send(&mut inner, elem.clone())
poll_send(&mut inner, cx, elem.clone())
},
OutboundSubstreamState::Flush => {
if inner.is_shutdown {
return Err(IoError::new(IoErrorKind::Other, "connection is shut down"))
return Poll::Ready(Err(IoError::new(IoErrorKind::Other, "connection is shut down")))
}
let inner = &mut *inner; // Avoids borrow errors
inner.notifier_write.to_notify.lock().insert(TASK_ID.with(|&t| t), task::current());
inner.inner.poll_flush_notify(&inner.notifier_write, 0)
inner.notifier_write.insert(cx.waker());
Sink::poll_flush(Pin::new(&mut inner.inner), &mut Context::from_waker(&waker_ref(&inner.notifier_write)))
},
OutboundSubstreamState::Done => {
panic!("Polling outbound substream after it's been succesfully open");
@ -413,16 +431,14 @@ where C: AsyncRead + AsyncWrite
};
match polling {
Ok(Async::Ready(())) => (),
Ok(Async::NotReady) => {
return Ok(Async::NotReady)
},
Err(err) => {
Poll::Ready(Ok(())) => (),
Poll::Pending => return Poll::Pending,
Poll::Ready(Err(err)) => {
debug!("Failed to open outbound substream {}", substream.num);
inner.buffer.retain(|elem| {
elem.substream_id() != substream.num || elem.endpoint() == Some(Endpoint::Dialer)
});
return Err(err)
return Poll::Ready(Err(err));
},
};
@ -436,7 +452,7 @@ where C: AsyncRead + AsyncWrite
OutboundSubstreamState::Flush => {
debug!("Successfully opened outbound substream {}", substream.num);
substream.state = OutboundSubstreamState::Done;
return Ok(Async::Ready(Substream {
return Poll::Ready(Ok(Substream {
num: substream.num,
current_data: Bytes::new(),
endpoint: Endpoint::Dialer,
@ -454,27 +470,23 @@ where C: AsyncRead + AsyncWrite
// Nothing to do.
}
unsafe fn prepare_uninitialized_buffer(&self, _: &mut [u8]) -> bool {
false
}
fn read_substream(&self, substream: &mut Self::Substream, buf: &mut [u8]) -> Poll<usize, IoError> {
fn read_substream(&self, cx: &mut Context, substream: &mut Self::Substream, buf: &mut [u8]) -> Poll<Result<usize, IoError>> {
loop {
// First, transfer from `current_data`.
if !substream.current_data.is_empty() {
let len = cmp::min(substream.current_data.len(), buf.len());
buf[..len].copy_from_slice(&substream.current_data.split_to(len));
return Ok(Async::Ready(len));
return Poll::Ready(Ok(len));
}
// If the remote writing side is closed, return EOF.
if !substream.remote_open {
return Ok(Async::Ready(0));
return Poll::Ready(Ok(0));
}
// Try to find a packet of data in the buffer.
let mut inner = self.inner.lock();
let next_data_poll = next_match(&mut inner, |elem| {
let next_data_poll = next_match(&mut inner, cx, |elem| {
match elem {
codec::Elem::Data { substream_id, endpoint, data, .. }
if *substream_id == substream.num && *endpoint != substream.endpoint => // see note [StreamId]
@ -492,28 +504,29 @@ where C: AsyncRead + AsyncWrite
// We're in a loop, so all we need to do is set `substream.current_data` to the data we
// just read and wait for the next iteration.
match next_data_poll? {
Async::Ready(Some(data)) => substream.current_data = data,
Async::Ready(None) => {
match next_data_poll {
Poll::Ready(Ok(Some(data))) => substream.current_data = data,
Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
Poll::Ready(Ok(None)) => {
substream.remote_open = false;
return Ok(Async::Ready(0));
return Poll::Ready(Ok(0));
},
Async::NotReady => {
Poll::Pending => {
// There was no data packet in the buffer about this substream; maybe it's
// because it has been closed.
if inner.opened_substreams.contains(&(substream.num, substream.endpoint)) {
return Ok(Async::NotReady)
return Poll::Pending
} else {
return Ok(Async::Ready(0))
return Poll::Ready(Ok(0))
}
},
}
}
}
fn write_substream(&self, substream: &mut Self::Substream, buf: &[u8]) -> Poll<usize, IoError> {
fn write_substream(&self, cx: &mut Context, substream: &mut Self::Substream, buf: &[u8]) -> Poll<Result<usize, IoError>> {
if !substream.local_open {
return Err(IoErrorKind::BrokenPipe.into());
return Poll::Ready(Err(IoErrorKind::BrokenPipe.into()));
}
let mut inner = self.inner.lock();
@ -522,30 +535,31 @@ where C: AsyncRead + AsyncWrite
let elem = codec::Elem::Data {
substream_id: substream.num,
data: From::from(&buf[..to_write]),
data: Bytes::copy_from_slice(&buf[..to_write]),
endpoint: substream.endpoint,
};
match poll_send(&mut inner, elem)? {
Async::Ready(()) => Ok(Async::Ready(to_write)),
Async::NotReady => Ok(Async::NotReady)
match poll_send(&mut inner, cx, elem) {
Poll::Ready(Ok(())) => Poll::Ready(Ok(to_write)),
Poll::Ready(Err(err)) => Poll::Ready(Err(err)),
Poll::Pending => Poll::Pending,
}
}
fn flush_substream(&self, _substream: &mut Self::Substream) -> Poll<(), IoError> {
fn flush_substream(&self, cx: &mut Context, _substream: &mut Self::Substream) -> Poll<Result<(), IoError>> {
let mut inner = self.inner.lock();
if inner.is_shutdown {
return Err(IoError::new(IoErrorKind::Other, "connection is shut down"))
return Poll::Ready(Err(IoError::new(IoErrorKind::Other, "connection is shut down")))
}
let inner = &mut *inner; // Avoids borrow errors
inner.notifier_write.to_notify.lock().insert(TASK_ID.with(|&t| t), task::current());
inner.inner.poll_flush_notify(&inner.notifier_write, 0)
inner.notifier_write.insert(cx.waker());
Sink::poll_flush(Pin::new(&mut inner.inner), &mut Context::from_waker(&waker_ref(&inner.notifier_write)))
}
fn shutdown_substream(&self, sub: &mut Self::Substream) -> Poll<(), IoError> {
fn shutdown_substream(&self, cx: &mut Context, sub: &mut Self::Substream) -> Poll<Result<(), IoError>> {
if !sub.local_open {
return Ok(Async::Ready(()));
return Poll::Ready(Ok(()));
}
let elem = codec::Elem::Close {
@ -554,8 +568,8 @@ where C: AsyncRead + AsyncWrite
};
let mut inner = self.inner.lock();
let result = poll_send(&mut inner, elem);
if let Ok(Async::Ready(())) = result {
let result = poll_send(&mut inner, cx, elem);
if let Poll::Ready(Ok(())) = result {
sub.local_open = false;
}
result
@ -572,22 +586,27 @@ where C: AsyncRead + AsyncWrite
}
#[inline]
fn close(&self) -> Poll<(), IoError> {
fn close(&self, cx: &mut Context) -> Poll<Result<(), IoError>> {
let inner = &mut *self.inner.lock();
inner.notifier_write.to_notify.lock().insert(TASK_ID.with(|&t| t), task::current());
try_ready!(inner.inner.close_notify(&inner.notifier_write, 0));
inner.is_shutdown = true;
Ok(Async::Ready(()))
inner.notifier_write.insert(cx.waker());
match Sink::poll_close(Pin::new(&mut inner.inner), &mut Context::from_waker(&waker_ref(&inner.notifier_write))) {
Poll::Ready(Ok(())) => {
inner.is_shutdown = true;
Poll::Ready(Ok(()))
}
Poll::Ready(Err(err)) => Poll::Ready(Err(err)),
Poll::Pending => Poll::Pending,
}
}
#[inline]
fn flush_all(&self) -> Poll<(), IoError> {
fn flush_all(&self, cx: &mut Context) -> Poll<Result<(), IoError>> {
let inner = &mut *self.inner.lock();
if inner.is_shutdown {
return Ok(Async::Ready(()))
return Poll::Ready(Ok(()))
}
inner.notifier_write.to_notify.lock().insert(TASK_ID.with(|&t| t), task::current());
inner.inner.poll_flush_notify(&inner.notifier_write, 0)
inner.notifier_write.insert(cx.waker());
Sink::poll_flush(Pin::new(&mut inner.inner), &mut Context::from_waker(&waker_ref(&inner.notifier_write)))
}
}

71
muxers/mplex/tests/async_write.rs
View File

@ -18,20 +18,18 @@
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
use libp2p_core::{muxing, upgrade, Transport, transport::ListenerEvent};
use libp2p_core::{muxing, upgrade, Transport};
use libp2p_tcp::TcpConfig;
use futures::prelude::*;
use std::sync::{Arc, mpsc};
use std::thread;
use tokio::runtime::current_thread::Runtime;
use futures::{prelude::*, channel::oneshot};
use std::sync::Arc;
#[test]
fn async_write() {
// Tests that `AsyncWrite::shutdown` implies flush.
// Tests that `AsyncWrite::close` implies flush.
let (tx, rx) = mpsc::channel();
let (tx, rx) = oneshot::channel();
let bg_thread = thread::spawn(move || {
let bg_thread = async_std::task::spawn(async move {
let mplex = libp2p_mplex::MplexConfig::new();
let transport = TcpConfig::new().and_then(move |c, e|
@ -41,8 +39,7 @@ fn async_write() {
.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap())
.unwrap();
let addr = listener.by_ref().wait()
.next()
let addr = listener.next().await
.expect("some event")
.expect("no error")
.into_new_address()
@ -50,41 +47,31 @@ fn async_write() {
tx.send(addr).unwrap();
let future = listener
.filter_map(ListenerEvent::into_upgrade)
.into_future()
.map_err(|(err, _)| panic!("{:?}", err))
.and_then(|(client, _)| client.unwrap().0)
.map_err(|err| panic!("{:?}", err))
.and_then(|client| muxing::outbound_from_ref_and_wrap(Arc::new(client)))
.and_then(|client| {
tokio::io::read_to_end(client, vec![])
})
.and_then(|(_, msg)| {
assert_eq!(msg, b"hello world");
Ok(())
});
let client = listener
.next().await
.unwrap()
.unwrap()
.into_upgrade().unwrap().0.await.unwrap();
let mut outbound = muxing::outbound_from_ref_and_wrap(Arc::new(client)).await.unwrap();
let mut rt = Runtime::new().unwrap();
let _ = rt.block_on(future).unwrap();
let mut buf = Vec::new();
outbound.read_to_end(&mut buf).await.unwrap();
assert_eq!(buf, b"hello world");
});
let mplex = libp2p_mplex::MplexConfig::new();
let transport = TcpConfig::new().and_then(move |c, e|
upgrade::apply(c, mplex, e, upgrade::Version::V1));
async_std::task::block_on(async {
let mplex = libp2p_mplex::MplexConfig::new();
let transport = TcpConfig::new().and_then(move |c, e|
upgrade::apply(c, mplex, e, upgrade::Version::V1));
let client = transport.dial(rx.await.unwrap()).unwrap().await.unwrap();
let mut inbound = muxing::inbound_from_ref_and_wrap(Arc::new(client)).await.unwrap();
inbound.write_all(b"hello world").await.unwrap();
let future = transport
.dial(rx.recv().unwrap())
.unwrap()
.map_err(|err| panic!("{:?}", err))
.and_then(|client| muxing::inbound_from_ref_and_wrap(Arc::new(client)))
.and_then(|server| tokio::io::write_all(server, b"hello world"))
.and_then(|(server, _)| {
tokio::io::shutdown(server)
})
.map(|_| ());
// The test consists in making sure that this flushes the substream.
inbound.close().await.unwrap();
let mut rt = Runtime::new().unwrap();
let _ = rt.block_on(future).unwrap();
bg_thread.join().unwrap();
bg_thread.await;
});
}

141
muxers/mplex/tests/two_peers.rs
View File

@ -18,23 +18,18 @@
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
use libp2p_core::{muxing, upgrade, Transport, transport::ListenerEvent};
use libp2p_core::{muxing, upgrade, Transport};
use libp2p_tcp::TcpConfig;
use futures::prelude::*;
use std::sync::{Arc, mpsc};
use std::thread;
use tokio::{
codec::length_delimited::Builder,
runtime::current_thread::Runtime
};
use futures::{channel::oneshot, prelude::*};
use std::sync::Arc;
#[test]
fn client_to_server_outbound() {
// Simulate a client sending a message to a server through a multiplex upgrade.
let (tx, rx) = mpsc::channel();
let (tx, rx) = oneshot::channel();
let bg_thread = thread::spawn(move || {
let bg_thread = async_std::task::spawn(async move {
let mplex = libp2p_mplex::MplexConfig::new();
let transport = TcpConfig::new().and_then(move |c, e|
@ -44,8 +39,7 @@ fn client_to_server_outbound() {
.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap())
.unwrap();
let addr = listener.by_ref().wait()
.next()
let addr = listener.next().await
.expect("some event")
.expect("no error")
.into_new_address()
@ -53,56 +47,42 @@ fn client_to_server_outbound() {
tx.send(addr).unwrap();
let future = listener
.filter_map(ListenerEvent::into_upgrade)
.into_future()
.map_err(|(err, _)| panic!("{:?}", err))
.and_then(|(client, _)| client.unwrap().0)
.map_err(|err| panic!("{:?}", err))
.and_then(|client| muxing::outbound_from_ref_and_wrap(Arc::new(client)))
.map(|client| Builder::new().new_read(client))
.and_then(|client| {
client
.into_future()
.map_err(|(err, _)| err)
.map(|(msg, _)| msg)
})
.and_then(|msg| {
let msg = msg.unwrap();
assert_eq!(msg, "hello world");
Ok(())
});
let client = listener
.next().await
.unwrap()
.unwrap()
.into_upgrade().unwrap().0.await.unwrap();
let mut outbound = muxing::outbound_from_ref_and_wrap(Arc::new(client)).await.unwrap();
let mut rt = Runtime::new().unwrap();
let _ = rt.block_on(future).unwrap();
let mut buf = Vec::new();
outbound.read_to_end(&mut buf).await.unwrap();
assert_eq!(buf, b"hello world");
});
let mplex = libp2p_mplex::MplexConfig::new();
let transport = TcpConfig::new().and_then(move |c, e|
upgrade::apply(c, mplex, e, upgrade::Version::V1));
async_std::task::block_on(async {
let mplex = libp2p_mplex::MplexConfig::new();
let transport = TcpConfig::new().and_then(move |c, e|
upgrade::apply(c, mplex, e, upgrade::Version::V1));
let client = transport.dial(rx.await.unwrap()).unwrap().await.unwrap();
let mut inbound = muxing::inbound_from_ref_and_wrap(Arc::new(client)).await.unwrap();
inbound.write_all(b"hello world").await.unwrap();
inbound.close().await.unwrap();
let future = transport
.dial(rx.recv().unwrap())
.unwrap()
.map_err(|err| panic!("{:?}", err))
.and_then(|client| muxing::inbound_from_ref_and_wrap(Arc::new(client)))
.map(|server| Builder::new().new_write(server))
.and_then(|server| server.send("hello world".into()))
.map(|_| ());
let mut rt = Runtime::new().unwrap();
let _ = rt.block_on(future).unwrap();
bg_thread.join().unwrap();
bg_thread.await;
});
}
#[test]
fn client_to_server_inbound() {
// Simulate a client sending a message to a server through a multiplex upgrade.
let (tx, rx) = mpsc::channel();
let (tx, rx) = oneshot::channel();
let bg_thread = thread::spawn(move || {
let bg_thread = async_std::task::spawn(async move {
let mplex = libp2p_mplex::MplexConfig::new();
let transport = TcpConfig::new().and_then(move |c, e|
upgrade::apply(c, mplex, e, upgrade::Version::V1));
@ -110,54 +90,37 @@ fn client_to_server_inbound() {
.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap())
.unwrap();
let addr = listener.by_ref().wait()
.next()
let addr = listener.next().await
.expect("some event")
.expect("no error")
.into_new_address()
.expect("listen address");
tx.send(addr).unwrap();
let future = listener
.filter_map(ListenerEvent::into_upgrade)
.into_future()
.map_err(|(err, _)| panic!("{:?}", err))
.and_then(|(client, _)| client.unwrap().0)
.map_err(|err| panic!("{:?}", err))
.and_then(|client| muxing::inbound_from_ref_and_wrap(Arc::new(client)))
.map(|client| Builder::new().new_read(client))
.and_then(|client| {
client
.into_future()
.map_err(|(err, _)| err)
.map(|(msg, _)| msg)
})
.and_then(|msg| {
let msg = msg.unwrap();
assert_eq!(msg, "hello world");
Ok(())
});
let client = listener
.next().await
.unwrap()
.unwrap()
.into_upgrade().unwrap().0.await.unwrap();
let mut inbound = muxing::inbound_from_ref_and_wrap(Arc::new(client)).await.unwrap();
let mut rt = Runtime::new().unwrap();
let _ = rt.block_on(future).unwrap();
let mut buf = Vec::new();
inbound.read_to_end(&mut buf).await.unwrap();
assert_eq!(buf, b"hello world");
});
let mplex = libp2p_mplex::MplexConfig::new();
let transport = TcpConfig::new().and_then(move |c, e|
upgrade::apply(c, mplex, e, upgrade::Version::V1));
async_std::task::block_on(async {
let mplex = libp2p_mplex::MplexConfig::new();
let transport = TcpConfig::new().and_then(move |c, e|
upgrade::apply(c, mplex, e, upgrade::Version::V1));
let client = transport.dial(rx.await.unwrap()).unwrap().await.unwrap();
let mut outbound = muxing::outbound_from_ref_and_wrap(Arc::new(client)).await.unwrap();
outbound.write_all(b"hello world").await.unwrap();
outbound.close().await.unwrap();
let future = transport
.dial(rx.recv().unwrap())
.unwrap()
.map_err(|err| panic!("{:?}", err))
.and_then(|client| muxing::outbound_from_ref_and_wrap(Arc::new(client)))
.map(|server| Builder::new().new_write(server))
.and_then(|server| server.send("hello world".into()))
.map(|_| ());
let mut rt = Runtime::new().unwrap();
let _ = rt.block_on(future).unwrap();
bg_thread.join().unwrap();
bg_thread.await;
});
}

9
muxers/yamux/Cargo.toml
View File

@ -10,8 +10,9 @@ keywords = ["peer-to-peer", "libp2p", "networking"]
categories = ["network-programming", "asynchronous"]
[dependencies]
futures = "0.1"
futures = "0.3.1"
libp2p-core = { version = "0.13.0", path = "../../core" }
log = "0.4"
tokio-io = "0.1"
yamux = "0.2.1"
log = "0.4.8"
parking_lot = "0.9"
thiserror = "1.0"
yamux = "0.4"

287
muxers/yamux/src/lib.rs
View File

@ -21,112 +21,160 @@
//! Implements the Yamux multiplexing protocol for libp2p, see also the
//! [specification](https://github.com/hashicorp/yamux/blob/master/spec.md).
use futures::{future::{self, FutureResult}, prelude::*};
use futures::{future, prelude::*, ready, stream::{BoxStream, LocalBoxStream}};
use libp2p_core::upgrade::{InboundUpgrade, OutboundUpgrade, UpgradeInfo, Negotiated};
use log::debug;
use std::{io, iter, sync::atomic};
use std::io::{Error as IoError};
use tokio_io::{AsyncRead, AsyncWrite};
use parking_lot::Mutex;
use std::{fmt, io, iter, pin::Pin, task::Context};
use thiserror::Error;
// TODO: add documentation and field names
pub struct Yamux<C>(yamux::Connection<C>, atomic::AtomicBool);
/// A Yamux connection.
pub struct Yamux<S>(Mutex<Inner<S>>);
impl<C> Yamux<C>
where
C: AsyncRead + AsyncWrite + 'static
{
pub fn new(c: C, mut cfg: yamux::Config, mode: yamux::Mode) -> Self {
cfg.set_read_after_close(false);
Yamux(yamux::Connection::new(c, cfg, mode), atomic::AtomicBool::new(false))
impl<S> fmt::Debug for Yamux<S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str("Yamux")
}
}
impl<C> libp2p_core::StreamMuxer for Yamux<C>
where
C: AsyncRead + AsyncWrite + 'static
{
type Substream = yamux::StreamHandle<C>;
type OutboundSubstream = FutureResult<Option<Self::Substream>, io::Error>;
type Error = IoError;
struct Inner<S> {
/// The `futures::stream::Stream` of incoming substreams.
incoming: S,
/// Handle to control the connection.
control: yamux::Control,
/// True, once we have received an inbound substream.
acknowledged: bool
}
fn poll_inbound(&self) -> Poll<Self::Substream, IoError> {
match self.0.poll() {
Err(e) => {
debug!("connection error: {}", e);
Err(io::Error::new(io::ErrorKind::Other, e))
}
Ok(Async::NotReady) => Ok(Async::NotReady),
Ok(Async::Ready(None)) => Err(io::ErrorKind::BrokenPipe.into()),
Ok(Async::Ready(Some(stream))) => {
self.1.store(true, atomic::Ordering::Release);
Ok(Async::Ready(stream))
/// A token to poll for an outbound substream.
#[derive(Debug)]
pub struct OpenSubstreamToken(());
impl<C> Yamux<Incoming<C>>
where
C: AsyncRead + AsyncWrite + Send + Unpin + 'static
{
/// Create a new Yamux connection.
pub fn new(io: C, mut cfg: yamux::Config, mode: yamux::Mode) -> Self {
cfg.set_read_after_close(false);
let conn = yamux::Connection::new(io, cfg, mode);
let ctrl = conn.control();
let inner = Inner {
incoming: Incoming {
stream: yamux::into_stream(conn).err_into().boxed(),
_marker: std::marker::PhantomData
},
control: ctrl,
acknowledged: false
};
Yamux(Mutex::new(inner))
}
}
impl<C> Yamux<LocalIncoming<C>>
where
C: AsyncRead + AsyncWrite + Unpin + 'static
{
/// Create a new Yamux connection (which is ![`Send`]).
pub fn local(io: C, mut cfg: yamux::Config, mode: yamux::Mode) -> Self {
cfg.set_read_after_close(false);
let conn = yamux::Connection::new(io, cfg, mode);
let ctrl = conn.control();
let inner = Inner {
incoming: LocalIncoming {
stream: yamux::into_stream(conn).err_into().boxed_local(),
_marker: std::marker::PhantomData
},
control: ctrl,
acknowledged: false
};
Yamux(Mutex::new(inner))
}
}
type Poll<T> = std::task::Poll<Result<T, YamuxError>>;
impl<S> libp2p_core::StreamMuxer for Yamux<S>
where
S: Stream<Item = Result<yamux::Stream, YamuxError>> + Unpin
{
type Substream = yamux::Stream;
type OutboundSubstream = OpenSubstreamToken;
type Error = YamuxError;
fn poll_inbound(&self, c: &mut Context) -> Poll<Self::Substream> {
let mut inner = self.0.lock();
match ready!(inner.incoming.poll_next_unpin(c)) {
Some(Ok(s)) => {
inner.acknowledged = true;
Poll::Ready(Ok(s))
}
Some(Err(e)) => Poll::Ready(Err(e)),
None => Poll::Ready(Err(yamux::ConnectionError::Closed.into()))
}
}
fn open_outbound(&self) -> Self::OutboundSubstream {
let stream = self.0.open_stream().map_err(|e| io::Error::new(io::ErrorKind::Other, e));
future::result(stream)
OpenSubstreamToken(())
}
fn poll_outbound(&self, substream: &mut Self::OutboundSubstream) -> Poll<Self::Substream, IoError> {
match substream.poll()? {
Async::Ready(Some(s)) => Ok(Async::Ready(s)),
Async::Ready(None) => Err(io::ErrorKind::BrokenPipe.into()),
Async::NotReady => Ok(Async::NotReady),
}
fn poll_outbound(&self, c: &mut Context, _: &mut OpenSubstreamToken) -> Poll<Self::Substream> {
let mut inner = self.0.lock();
Pin::new(&mut inner.control).poll_open_stream(c).map_err(YamuxError)
}
fn destroy_outbound(&self, _: Self::OutboundSubstream) {
self.0.lock().control.abort_open_stream()
}
unsafe fn prepare_uninitialized_buffer(&self, _: &mut [u8]) -> bool {
false
fn read_substream(&self, c: &mut Context, s: &mut Self::Substream, b: &mut [u8]) -> Poll<usize> {
Pin::new(s).poll_read(c, b).map_err(|e| YamuxError(e.into()))
}
fn read_substream(&self, sub: &mut Self::Substream, buf: &mut [u8]) -> Poll<usize, IoError> {
let result = sub.poll_read(buf);
if let Ok(Async::Ready(_)) = result {
self.1.store(true, atomic::Ordering::Release);
}
result
fn write_substream(&self, c: &mut Context, s: &mut Self::Substream, b: &[u8]) -> Poll<usize> {
Pin::new(s).poll_write(c, b).map_err(|e| YamuxError(e.into()))
}
fn write_substream(&self, sub: &mut Self::Substream, buf: &[u8]) -> Poll<usize, IoError> {
sub.poll_write(buf)
fn flush_substream(&self, c: &mut Context, s: &mut Self::Substream) -> Poll<()> {
Pin::new(s).poll_flush(c).map_err(|e| YamuxError(e.into()))
}
fn flush_substream(&self, sub: &mut Self::Substream) -> Poll<(), IoError> {
sub.poll_flush()
fn shutdown_substream(&self, c: &mut Context, s: &mut Self::Substream) -> Poll<()> {
Pin::new(s).poll_close(c).map_err(|e| YamuxError(e.into()))
}
fn shutdown_substream(&self, sub: &mut Self::Substream) -> Poll<(), IoError> {
sub.shutdown()
}
fn destroy_substream(&self, _: Self::Substream) {
}
fn destroy_substream(&self, _: Self::Substream) { }
fn is_remote_acknowledged(&self) -> bool {
self.1.load(atomic::Ordering::Acquire)
self.0.lock().acknowledged
}
fn close(&self) -> Poll<(), IoError> {
self.0.close().map_err(|e| io::Error::new(io::ErrorKind::Other, e))
fn close(&self, c: &mut Context) -> Poll<()> {
let mut inner = self.0.lock();
Pin::new(&mut inner.control).poll_close(c).map_err(YamuxError)
}
fn flush_all(&self) -> Poll<(), IoError> {
self.0.flush().map_err(|e| io::Error::new(io::ErrorKind::Other, e))
fn flush_all(&self, _: &mut Context) -> Poll<()> {
Poll::Ready(Ok(()))
}
}
/// The yamux configuration.
#[derive(Clone)]
pub struct Config(yamux::Config);
/// The yamux configuration for upgrading I/O resources which are ![`Send`].
#[derive(Clone)]
pub struct LocalConfig(Config);
impl Config {
pub fn new(cfg: yamux::Config) -> Self {
Config(cfg)
}
/// Turn this into a `LocalConfig` for use with upgrades of !Send resources.
pub fn local(self) -> LocalConfig {
LocalConfig(self)
}
}
impl Default for Config {
@ -144,29 +192,122 @@ impl UpgradeInfo for Config {
}
}
impl UpgradeInfo for LocalConfig {
type Info = &'static [u8];
type InfoIter = iter::Once<Self::Info>;
fn protocol_info(&self) -> Self::InfoIter {
iter::once(b"/yamux/1.0.0")
}
}
impl<C> InboundUpgrade<C> for Config
where
C: AsyncRead + AsyncWrite + 'static,
C: AsyncRead + AsyncWrite + Send + Unpin + 'static
{
type Output = Yamux<Negotiated<C>>;
type Output = Yamux<Incoming<Negotiated<C>>>;
type Error = io::Error;
type Future = FutureResult<Yamux<Negotiated<C>>, io::Error>;
type Future = future::Ready<Result<Self::Output, Self::Error>>;
fn upgrade_inbound(self, i: Negotiated<C>, _: Self::Info) -> Self::Future {
future::ok(Yamux::new(i, self.0, yamux::Mode::Server))
fn upgrade_inbound(self, io: Negotiated<C>, _: Self::Info) -> Self::Future {
future::ready(Ok(Yamux::new(io, self.0, yamux::Mode::Server)))
}
}
impl<C> InboundUpgrade<C> for LocalConfig
where
C: AsyncRead + AsyncWrite + Unpin + 'static
{
type Output = Yamux<LocalIncoming<Negotiated<C>>>;
type Error = io::Error;
type Future = future::Ready<Result<Self::Output, Self::Error>>;
fn upgrade_inbound(self, io: Negotiated<C>, _: Self::Info) -> Self::Future {
future::ready(Ok(Yamux::local(io, (self.0).0, yamux::Mode::Server)))
}
}
impl<C> OutboundUpgrade<C> for Config
where
C: AsyncRead + AsyncWrite + 'static,
C: AsyncRead + AsyncWrite + Send + Unpin + 'static
{
type Output = Yamux<Negotiated<C>>;
type Output = Yamux<Incoming<Negotiated<C>>>;
type Error = io::Error;
type Future = FutureResult<Yamux<Negotiated<C>>, io::Error>;
type Future = future::Ready<Result<Self::Output, Self::Error>>;
fn upgrade_outbound(self, i: Negotiated<C>, _: Self::Info) -> Self::Future {
future::ok(Yamux::new(i, self.0, yamux::Mode::Client))
fn upgrade_outbound(self, io: Negotiated<C>, _: Self::Info) -> Self::Future {
future::ready(Ok(Yamux::new(io, self.0, yamux::Mode::Client)))
}
}
impl<C> OutboundUpgrade<C> for LocalConfig
where
C: AsyncRead + AsyncWrite + Unpin + 'static
{
type Output = Yamux<LocalIncoming<Negotiated<C>>>;
type Error = io::Error;
type Future = future::Ready<Result<Self::Output, Self::Error>>;
fn upgrade_outbound(self, io: Negotiated<C>, _: Self::Info) -> Self::Future {
future::ready(Ok(Yamux::local(io, (self.0).0, yamux::Mode::Client)))
}
}
/// The Yamux [`StreamMuxer`] error type.
#[derive(Debug, Error)]
#[error("yamux error: {0}")]
pub struct YamuxError(#[from] pub yamux::ConnectionError);
impl Into<io::Error> for YamuxError {
fn into(self: YamuxError) -> io::Error {
io::Error::new(io::ErrorKind::Other, self.to_string())
}
}
/// The [`futures::stream::Stream`] of incoming substreams.
pub struct Incoming<T> {
stream: BoxStream<'static, Result<yamux::Stream, YamuxError>>,
_marker: std::marker::PhantomData<T>
}
impl<T> fmt::Debug for Incoming<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str("Incoming")
}
}
/// The [`futures::stream::Stream`] of incoming substreams (`!Send`).
pub struct LocalIncoming<T> {
stream: LocalBoxStream<'static, Result<yamux::Stream, YamuxError>>,
_marker: std::marker::PhantomData<T>
}
impl<T> fmt::Debug for LocalIncoming<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str("LocalIncoming")
}
}
impl<T: Unpin> Stream for Incoming<T> {
type Item = Result<yamux::Stream, YamuxError>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> std::task::Poll<Option<Self::Item>> {
self.stream.as_mut().poll_next_unpin(cx)
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.stream.size_hint()
}
}
impl<T: Unpin> Stream for LocalIncoming<T> {
type Item = Result<yamux::Stream, YamuxError>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> std::task::Poll<Option<Self::Item>> {
self.stream.as_mut().poll_next_unpin(cx)
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.stream.size_hint()
}
}

11
protocols/deflate/Cargo.toml
View File

@ -10,14 +10,13 @@ keywords = ["peer-to-peer", "libp2p", "networking"]
categories = ["network-programming", "asynchronous"]
[dependencies]
futures = "0.1"
futures = "0.3.1"
libp2p-core = { version = "0.13.0", path = "../../core" }
tokio-io = "0.1.12"
flate2 = { version = "1.0", features = ["tokio"] }
flate2 = "1.0"
[dev-dependencies]
async-std = "1.0"
env_logger = "0.7.1"
libp2p-tcp = { version = "0.13.0", path = "../../transports/tcp" }
quickcheck = "0.9.0"
tokio = "0.1"
log = "0.4"
rand = "0.7"
quickcheck = "0.9"

221
protocols/deflate/src/lib.rs
View File

@ -18,21 +18,22 @@
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
use flate2::read::DeflateDecoder;
use flate2::write::DeflateEncoder;
use flate2::Compression;
use std::io;
use futures::future::{self, FutureResult};
use libp2p_core::{upgrade::Negotiated, InboundUpgrade, OutboundUpgrade, UpgradeInfo};
use std::iter;
use tokio_io::{AsyncRead, AsyncWrite};
use futures::{prelude::*, ready};
use libp2p_core::{Negotiated, InboundUpgrade, OutboundUpgrade, UpgradeInfo};
use std::{io, iter, pin::Pin, task::Context, task::Poll};
#[derive(Debug, Copy, Clone)]
pub struct DeflateConfig;
pub struct DeflateConfig {
compression: flate2::Compression,
}
/// Output of the deflate protocol.
pub type DeflateOutput<S> = DeflateDecoder<DeflateEncoder<S>>;
impl Default for DeflateConfig {
fn default() -> Self {
DeflateConfig {
compression: flate2::Compression::fast(),
}
}
}
impl UpgradeInfo for DeflateConfig {
type Info = &'static [u8];
@ -49,13 +50,10 @@ where
{
type Output = DeflateOutput<Negotiated<C>>;
type Error = io::Error;
type Future = FutureResult<Self::Output, Self::Error>;
type Future = future::Ready<Result<Self::Output, Self::Error>>;
fn upgrade_inbound(self, r: Negotiated<C>, _: Self::Info) -> Self::Future {
future::ok(DeflateDecoder::new(DeflateEncoder::new(
r,
Compression::default(),
)))
future::ok(DeflateOutput::new(r, self.compression))
}
}
@ -65,12 +63,191 @@ where
{
type Output = DeflateOutput<Negotiated<C>>;
type Error = io::Error;
type Future = FutureResult<Self::Output, Self::Error>;
type Future = future::Ready<Result<Self::Output, Self::Error>>;
fn upgrade_outbound(self, w: Negotiated<C>, _: Self::Info) -> Self::Future {
future::ok(DeflateDecoder::new(DeflateEncoder::new(
w,
Compression::default(),
)))
future::ok(DeflateOutput::new(w, self.compression))
}
}
/// Decodes and encodes traffic using DEFLATE.
#[derive(Debug)]
pub struct DeflateOutput<S> {
/// Inner stream where we read compressed data from and write compressed data to.
inner: S,
/// Internal object used to hold the state of the compression.
compress: flate2::Compress,
/// Internal object used to hold the state of the decompression.
decompress: flate2::Decompress,
/// Temporary buffer between `compress` and `inner`. Stores compressed bytes that need to be
/// sent out once `inner` is ready to accept more.
write_out: Vec<u8>,
/// Temporary buffer between `decompress` and `inner`. Stores compressed bytes that need to be
/// given to `decompress`.
read_interm: Vec<u8>,
/// When we read from `inner` and `Ok(0)` is returned, we set this to `true` so that we don't
/// read from it again.
inner_read_eof: bool,
}
impl<S> DeflateOutput<S> {
fn new(inner: S, compression: flate2::Compression) -> Self {
DeflateOutput {
inner,
compress: flate2::Compress::new(compression, false),
decompress: flate2::Decompress::new(false),
write_out: Vec::with_capacity(256),
read_interm: Vec::with_capacity(256),
inner_read_eof: false,
}
}
/// Tries to write the content of `self.write_out` to `self.inner`.
/// Returns `Ready(Ok(()))` if `self.write_out` is empty.
fn flush_write_out(&mut self, cx: &mut Context) -> Poll<Result<(), io::Error>>
where S: AsyncWrite + Unpin
{
loop {
if self.write_out.is_empty() {
return Poll::Ready(Ok(()))
}
match AsyncWrite::poll_write(Pin::new(&mut self.inner), cx, &self.write_out) {
Poll::Ready(Ok(0)) => return Poll::Ready(Err(io::ErrorKind::WriteZero.into())),
Poll::Ready(Ok(n)) => self.write_out = self.write_out.split_off(n),
Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
Poll::Pending => return Poll::Pending,
};
}
}
}
impl<S> AsyncRead for DeflateOutput<S>
where S: AsyncRead + Unpin
{
fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context, buf: &mut [u8]) -> Poll<Result<usize, io::Error>> {
// We use a `this` variable because the compiler doesn't allow multiple mutable borrows
// across a `Deref`.
let this = &mut *self;
loop {
// Read from `self.inner` into `self.read_interm` if necessary.
if this.read_interm.is_empty() && !this.inner_read_eof {
unsafe {
this.read_interm.reserve(256);
this.read_interm.set_len(this.read_interm.capacity());
}
match AsyncRead::poll_read(Pin::new(&mut this.inner), cx, &mut this.read_interm) {
Poll::Ready(Ok(0)) => {
this.inner_read_eof = true;
this.read_interm.clear();
}
Poll::Ready(Ok(n)) => {
this.read_interm.truncate(n)
},
Poll::Ready(Err(err)) => {
this.read_interm.clear();
return Poll::Ready(Err(err))
},
Poll::Pending => {
this.read_interm.clear();
return Poll::Pending
},
}
}
debug_assert!(!this.read_interm.is_empty() || this.inner_read_eof);
let before_out = this.decompress.total_out();
let before_in = this.decompress.total_in();
let ret = this.decompress.decompress(&this.read_interm, buf, if this.inner_read_eof { flate2::FlushDecompress::Finish } else { flate2::FlushDecompress::None })?;
// Remove from `self.read_interm` the bytes consumed by the decompressor.
let consumed = (this.decompress.total_in() - before_in) as usize;
this.read_interm = this.read_interm.split_off(consumed);
let read = (this.decompress.total_out() - before_out) as usize;
if read != 0 || ret == flate2::Status::StreamEnd {
return Poll::Ready(Ok(read))
}
}
}
}
impl<S> AsyncWrite for DeflateOutput<S>
where S: AsyncWrite + Unpin
{
fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context, buf: &[u8])
-> Poll<Result<usize, io::Error>>
{
// We use a `this` variable because the compiler doesn't allow multiple mutable borrows
// across a `Deref`.
let this = &mut *self;
// We don't want to accumulate too much data in `self.write_out`, so we only proceed if it
// is empty.
ready!(this.flush_write_out(cx))?;
// We special-case this, otherwise an empty buffer would make the loop below infinite.
if buf.is_empty() {
return Poll::Ready(Ok(0));
}
// Unfortunately, the compressor might be in a "flushing mode", not accepting any input
// data. We don't want to return `Ok(0)` in that situation, as that would be wrong.
// Instead, we invoke the compressor in a loop until it accepts some of our data.
loop {
let before_in = this.compress.total_in();
this.write_out.reserve(256); // compress_vec uses the Vec's capacity
let ret = this.compress.compress_vec(buf, &mut this.write_out, flate2::FlushCompress::None)?;
let written = (this.compress.total_in() - before_in) as usize;
if written != 0 || ret == flate2::Status::StreamEnd {
return Poll::Ready(Ok(written));
}
}
}
fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), io::Error>> {
// We use a `this` variable because the compiler doesn't allow multiple mutable borrows
// across a `Deref`.
let this = &mut *self;
ready!(this.flush_write_out(cx))?;
this.compress.compress_vec(&[], &mut this.write_out, flate2::FlushCompress::Sync)?;
loop {
ready!(this.flush_write_out(cx))?;
debug_assert!(this.write_out.is_empty());
// We ask the compressor to flush everything into `self.write_out`.
this.write_out.reserve(256); // compress_vec uses the Vec's capacity
this.compress.compress_vec(&[], &mut this.write_out, flate2::FlushCompress::None)?;
if this.write_out.is_empty() {
break;
}
}
AsyncWrite::poll_flush(Pin::new(&mut this.inner), cx)
}
fn poll_close(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<(), io::Error>> {
// We use a `this` variable because the compiler doesn't allow multiple mutable borrows
// across a `Deref`.
let this = &mut *self;
loop {
ready!(this.flush_write_out(cx))?;
// We ask the compressor to flush everything into `self.write_out`.
debug_assert!(this.write_out.is_empty());
this.write_out.reserve(256); // compress_vec uses the Vec's capacity
this.compress.compress_vec(&[], &mut this.write_out, flate2::FlushCompress::Finish)?;
if this.write_out.is_empty() {
break;
}
}
AsyncWrite::poll_close(Pin::new(&mut this.inner), cx)
}
}

123
protocols/deflate/tests/test.rs
View File

@ -18,82 +18,77 @@
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
use futures::prelude::*;
use libp2p_core::transport::{ListenerEvent, Transport};
use libp2p_core::upgrade::{self, Negotiated};
use libp2p_deflate::{DeflateConfig, DeflateOutput};
use libp2p_tcp::{TcpConfig, TcpTransStream};
use log::info;
use quickcheck::QuickCheck;
use tokio::{self, io};
use futures::{future, prelude::*};
use libp2p_core::{transport::Transport, upgrade};
use libp2p_deflate::DeflateConfig;
use libp2p_tcp::TcpConfig;
use quickcheck::{QuickCheck, RngCore, TestResult};
#[test]
fn deflate() {
let _ = env_logger::try_init();
fn prop(message: Vec<u8>) -> bool {
let client = TcpConfig::new().and_then(|c, e|
upgrade::apply(c, DeflateConfig {}, e, upgrade::Version::V1));
let server = client.clone();
run(server, client, message);
true
fn prop(message: Vec<u8>) -> TestResult {
if message.is_empty() {
return TestResult::discard()
}
async_std::task::block_on(run(message));
TestResult::passed()
}
QuickCheck::new()
.max_tests(30)
.quickcheck(prop as fn(Vec<u8>) -> bool)
QuickCheck::new().quickcheck(prop as fn(Vec<u8>) -> TestResult)
}
type Output = DeflateOutput<Negotiated<TcpTransStream>>;
#[test]
fn lot_of_data() {
let mut v = vec![0; 2 * 1024 * 1024];
rand::thread_rng().fill_bytes(&mut v);
async_std::task::block_on(run(v))
}
fn run<T>(server_transport: T, client_transport: T, message1: Vec<u8>)
where
T: Transport<Output = Output>,
T::Dial: Send + 'static,
T::Listener: Send + 'static,
T::ListenerUpgrade: Send + 'static,
{
let message2 = message1.clone();
async fn run(message1: Vec<u8>) {
let transport = TcpConfig::new()
.and_then(|conn, endpoint| {
upgrade::apply(conn, DeflateConfig::default(), endpoint, upgrade::Version::V1)
});
let mut server = server_transport
.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap())
.unwrap();
let server_address = server
.by_ref()
.wait()
.next()
let mut listener = transport.clone()
.listen_on("/ip4/0.0.0.0/tcp/0".parse().expect("multiaddr"))
.expect("listener");
let listen_addr = listener.by_ref().next().await
.expect("some event")
.expect("no error")
.into_new_address()
.expect("listen address");
let server = server
.take(1)
.filter_map(ListenerEvent::into_upgrade)
.and_then(|(client, _)| client)
.map_err(|e| panic!("server error: {}", e))
.and_then(|client| {
info!("server: reading message");
io::read_to_end(client, Vec::new())
})
.for_each(move |(_, msg)| {
info!("server: read message: {:?}", msg);
assert_eq!(msg, message1);
Ok(())
});
.expect("new address");
let client = client_transport
.dial(server_address.clone())
.unwrap()
.map_err(|e| panic!("client error: {}", e))
.and_then(move |server| {
io::write_all(server, message2).and_then(|(client, _)| io::shutdown(client))
})
.map(|_| ());
let message2 = message1.clone();
let future = client
.join(server)
.map_err(|e| panic!("{:?}", e))
.map(|_| ());
let listener_task = async_std::task::spawn(async move {
let mut conn = listener
.filter(|e| future::ready(e.as_ref().map(|e| e.is_upgrade()).unwrap_or(false)))
.next()
.await
.expect("some event")
.expect("no error")
.into_upgrade()
.expect("upgrade")
.0
.await
.expect("connection");
tokio::run(future)
let mut buf = vec![0; message2.len()];
conn.read_exact(&mut buf).await.expect("read_exact");
assert_eq!(&buf[..], &message2[..]);
conn.write_all(&message2).await.expect("write_all");
conn.close().await.expect("close")
});
let mut conn = transport.dial(listen_addr).expect("dialer").await.expect("connection");
conn.write_all(&message1).await.expect("write_all");
conn.close().await.expect("close");
let mut buf = Vec::new();
conn.read_to_end(&mut buf).await.expect("read_to_end");
assert_eq!(&buf[..], &message1[..]);
listener_task.await
}

9
protocols/floodsub/Cargo.toml
View File

@ -11,13 +11,12 @@ categories = ["network-programming", "asynchronous"]
[dependencies]
bs58 = "0.3.0"
bytes = "0.4"
bytes = "0.5"
cuckoofilter = "0.3.2"
fnv = "1.0"
futures = "0.1"
futures = "0.3.1"
libp2p-core = { version = "0.13.0", path = "../../core" }
libp2p-swarm = { version = "0.3.0", path = "../../swarm" }
protobuf = "=2.8.1" # note: see https://github.com/libp2p/rust-libp2p/issues/1363
rand = "0.6"
smallvec = "0.6.5"
tokio-io = "0.1"
rand = "0.7"
smallvec = "1.0"

11
protocols/floodsub/src/layer.rs
View File

@ -35,7 +35,7 @@ use rand;
use smallvec::SmallVec;
use std::{collections::VecDeque, iter, marker::PhantomData};
use std::collections::hash_map::{DefaultHasher, HashMap};
use tokio_io::{AsyncRead, AsyncWrite};
use std::task::{Context, Poll};
/// Network behaviour that automatically identifies nodes periodically, and returns information
/// about them.
@ -230,7 +230,7 @@ impl<TSubstream> Floodsub<TSubstream> {
impl<TSubstream> NetworkBehaviour for Floodsub<TSubstream>
where
TSubstream: AsyncRead + AsyncWrite,
TSubstream: AsyncRead + AsyncWrite + Send + Unpin + 'static,
{
type ProtocolsHandler = OneShotHandler<TSubstream, FloodsubConfig, FloodsubRpc, InnerMessage>;
type OutEvent = FloodsubEvent;
@ -359,18 +359,19 @@ where
fn poll(
&mut self,
_: &mut Context,
_: &mut impl PollParameters,
) -> Async<
) -> Poll<
NetworkBehaviourAction<
<Self::ProtocolsHandler as ProtocolsHandler>::InEvent,
Self::OutEvent,
>,
> {
if let Some(event) = self.events.pop_front() {
return Async::Ready(event);
return Poll::Ready(event);
}
Async::NotReady
Poll::Pending
}
}

27
protocols/floodsub/src/protocol.rs
View File

@ -20,10 +20,10 @@
use crate::rpc_proto;
use crate::topic::TopicHash;
use futures::prelude::*;
use libp2p_core::{InboundUpgrade, OutboundUpgrade, UpgradeInfo, PeerId, upgrade};
use protobuf::{ProtobufError, Message as ProtobufMessage};
use std::{error, fmt, io, iter};
use tokio_io::{AsyncRead, AsyncWrite};
use std::{error, fmt, io, iter, pin::Pin};
/// Implementation of `ConnectionUpgrade` for the floodsub protocol.
#[derive(Debug, Clone, Default)]
@ -49,15 +49,15 @@ impl UpgradeInfo for FloodsubConfig {
impl<TSocket> InboundUpgrade<TSocket> for FloodsubConfig
where
TSocket: AsyncRead + AsyncWrite,
TSocket: AsyncRead + AsyncWrite + Send + Unpin + 'static,
{
type Output = FloodsubRpc;
type Error = FloodsubDecodeError;
type Future = upgrade::ReadOneThen<upgrade::Negotiated<TSocket>, (), fn(Vec<u8>, ()) -> Result<FloodsubRpc, FloodsubDecodeError>>;
type Future = Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send>>;
#[inline]
fn upgrade_inbound(self, socket: upgrade::Negotiated<TSocket>, _: Self::Info) -> Self::Future {
upgrade::read_one_then(socket, 2048, (), |packet, ()| {
fn upgrade_inbound(self, mut socket: upgrade::Negotiated<TSocket>, _: Self::Info) -> Self::Future {
Box::pin(async move {
let packet = upgrade::read_one(&mut socket, 2048).await?;
let mut rpc: rpc_proto::RPC = protobuf::parse_from_bytes(&packet)?;
let mut messages = Vec::with_capacity(rpc.get_publish().len());
@ -164,16 +164,19 @@ impl UpgradeInfo for FloodsubRpc {
impl<TSocket> OutboundUpgrade<TSocket> for FloodsubRpc
where
TSocket: AsyncWrite + AsyncRead,
TSocket: AsyncWrite + AsyncRead + Send + Unpin + 'static,
{
type Output = ();
type Error = io::Error;
type Future = upgrade::WriteOne<upgrade::Negotiated<TSocket>>;
type Future = Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send>>;
#[inline]
fn upgrade_outbound(self, socket: upgrade::Negotiated<TSocket>, _: Self::Info) -> Self::Future {
let bytes = self.into_bytes();
upgrade::write_one(socket, bytes)
fn upgrade_outbound(self, mut socket: upgrade::Negotiated<TSocket>, _: Self::Info) -> Self::Future {
Box::pin(async move {
let bytes = self.into_bytes();
upgrade::write_one(&mut socket, bytes).await?;
Ok(())
})
}
}

15
protocols/identify/Cargo.toml
View File

@ -10,22 +10,21 @@ keywords = ["peer-to-peer", "libp2p", "networking"]
categories = ["network-programming", "asynchronous"]
[dependencies]
bytes = "0.4"
futures = "0.1"
bytes = "0.5"
futures_codec = "0.3.4"
futures = "0.3.1"
libp2p-core = { version = "0.13.0", path = "../../core" }
libp2p-swarm = { version = "0.3.0", path = "../../swarm" }
log = "0.4.1"
multiaddr = { package = "parity-multiaddr", version = "0.6.0", path = "../../misc/multiaddr" }
protobuf = "=2.8.1" # note: see https://github.com/libp2p/rust-libp2p/issues/1363
smallvec = "0.6"
tokio-codec = "0.1"
tokio-io = "0.1.0"
wasm-timer = "0.1"
unsigned-varint = { version = "0.2.1", features = ["codec"] }
smallvec = "1.0"
wasm-timer = "0.2"
unsigned-varint = { version = "0.3", features = ["futures-codec"] }
[dev-dependencies]
async-std = "1.0"
libp2p-mplex = { version = "0.13.0", path = "../../muxers/mplex" }
libp2p-secio = { version = "0.13.0", path = "../../protocols/secio" }
libp2p-tcp = { version = "0.13.0", path = "../../transports/tcp" }
rand = "0.6"
tokio = "0.1"

35
protocols/identify/src/handler.rs
View File

@ -23,6 +23,7 @@ use futures::prelude::*;
use libp2p_core::upgrade::{
InboundUpgrade,
OutboundUpgrade,
ReadOneError,
Negotiated
};
use libp2p_swarm::{
@ -33,9 +34,8 @@ use libp2p_swarm::{
ProtocolsHandlerUpgrErr
};
use smallvec::SmallVec;
use std::{io, marker::PhantomData, time::Duration};
use tokio_io::{AsyncRead, AsyncWrite};
use wasm_timer::{Delay, Instant};
use std::{marker::PhantomData, pin::Pin, task::Context, task::Poll, time::Duration};
use wasm_timer::Delay;
/// Delay between the moment we connect and the first time we identify.
const DELAY_TO_FIRST_ID: Duration = Duration::from_millis(500);
@ -74,7 +74,7 @@ pub enum IdentifyHandlerEvent<TSubstream> {
/// We received a request for identification.
Identify(ReplySubstream<Negotiated<TSubstream>>),
/// Failed to identify the remote.
IdentificationError(ProtocolsHandlerUpgrErr<io::Error>),
IdentificationError(ProtocolsHandlerUpgrErr<ReadOneError>),
}
impl<TSubstream> IdentifyHandler<TSubstream> {
@ -83,7 +83,7 @@ impl<TSubstream> IdentifyHandler<TSubstream> {
IdentifyHandler {
config: IdentifyProtocolConfig,
events: SmallVec::new(),
next_id: Delay::new(Instant::now() + DELAY_TO_FIRST_ID),
next_id: Delay::new(DELAY_TO_FIRST_ID),
keep_alive: KeepAlive::Yes,
marker: PhantomData,
}
@ -92,11 +92,11 @@ impl<TSubstream> IdentifyHandler<TSubstream> {
impl<TSubstream> ProtocolsHandler for IdentifyHandler<TSubstream>
where
TSubstream: AsyncRead + AsyncWrite,
TSubstream: AsyncRead + AsyncWrite + Unpin + Send + 'static,
{
type InEvent = ();
type OutEvent = IdentifyHandlerEvent<TSubstream>;
type Error = wasm_timer::Error;
type Error = ReadOneError;
type Substream = TSubstream;
type InboundProtocol = IdentifyProtocolConfig;
type OutboundProtocol = IdentifyProtocolConfig;
@ -133,38 +133,39 @@ where
) {
self.events.push(IdentifyHandlerEvent::IdentificationError(err));
self.keep_alive = KeepAlive::No;
self.next_id.reset(Instant::now() + TRY_AGAIN_ON_ERR);
self.next_id.reset(TRY_AGAIN_ON_ERR);
}
fn connection_keep_alive(&self) -> KeepAlive {
self.keep_alive
}
fn poll(&mut self) -> Poll<
fn poll(&mut self, cx: &mut Context) -> Poll<
ProtocolsHandlerEvent<
Self::OutboundProtocol,
Self::OutboundOpenInfo,
IdentifyHandlerEvent<TSubstream>,
Self::Error,
>,
Self::Error,
> {
if !self.events.is_empty() {
return Ok(Async::Ready(ProtocolsHandlerEvent::Custom(
return Poll::Ready(ProtocolsHandlerEvent::Custom(
self.events.remove(0),
)));
));
}
// Poll the future that fires when we need to identify the node again.
match self.next_id.poll()? {
Async::NotReady => Ok(Async::NotReady),
Async::Ready(()) => {
self.next_id.reset(Instant::now() + DELAY_TO_NEXT_ID);
match Future::poll(Pin::new(&mut self.next_id), cx) {
Poll::Pending => Poll::Pending,
Poll::Ready(Ok(())) => {
self.next_id.reset(DELAY_TO_NEXT_ID);
let ev = ProtocolsHandlerEvent::OutboundSubstreamRequest {
protocol: SubstreamProtocol::new(self.config.clone()),
info: (),
};
Ok(Async::Ready(ev))
Poll::Ready(ev)
}
Poll::Ready(Err(err)) => Poll::Ready(ProtocolsHandlerEvent::Close(err.into()))
}
}
}

91
protocols/identify/src/identify.rs
View File

@ -19,14 +19,14 @@
// DEALINGS IN THE SOFTWARE.
use crate::handler::{IdentifyHandler, IdentifyHandlerEvent};
use crate::protocol::{IdentifyInfo, ReplySubstream, ReplyFuture};
use crate::protocol::{IdentifyInfo, ReplySubstream};
use futures::prelude::*;
use libp2p_core::{
ConnectedPoint,
Multiaddr,
PeerId,
PublicKey,
upgrade::{Negotiated, UpgradeError}
upgrade::{Negotiated, ReadOneError, UpgradeError}
};
use libp2p_swarm::{
NetworkBehaviour,
@ -35,8 +35,7 @@ use libp2p_swarm::{
ProtocolsHandler,
ProtocolsHandlerUpgrErr
};
use std::{collections::HashMap, collections::VecDeque, io};
use tokio_io::{AsyncRead, AsyncWrite};
use std::{collections::HashMap, collections::VecDeque, io, pin::Pin, task::Context, task::Poll};
/// Network behaviour that automatically identifies nodes periodically, returns information
/// about them, and answers identify queries from other nodes.
@ -66,7 +65,7 @@ enum Reply<TSubstream> {
/// The reply is being sent.
Sending {
peer: PeerId,
io: ReplyFuture<Negotiated<TSubstream>>
io: Pin<Box<dyn Future<Output = Result<(), io::Error>> + Send>>,
}
}
@ -86,7 +85,7 @@ impl<TSubstream> Identify<TSubstream> {
impl<TSubstream> NetworkBehaviour for Identify<TSubstream>
where
TSubstream: AsyncRead + AsyncWrite,
TSubstream: AsyncRead + AsyncWrite + Unpin + Send + 'static,
{
type ProtocolsHandler = IdentifyHandler<TSubstream>;
type OutEvent = IdentifyEvent;
@ -153,15 +152,16 @@ where
fn poll(
&mut self,
cx: &mut Context,
params: &mut impl PollParameters,
) -> Async<
) -> Poll<
NetworkBehaviourAction<
<Self::ProtocolsHandler as ProtocolsHandler>::InEvent,
Self::OutEvent,
>,
> {
if let Some(event) = self.events.pop_front() {
return Async::Ready(event);
return Poll::Ready(event);
}
if let Some(r) = self.pending_replies.pop_front() {
@ -188,17 +188,17 @@ where
listen_addrs: listen_addrs.clone(),
protocols: protocols.clone(),
};
let io = io.send(info, &observed);
let io = Box::pin(io.send(info, &observed));
reply = Some(Reply::Sending { peer, io });
}
Some(Reply::Sending { peer, mut io }) => {
sending += 1;
match io.poll() {
Ok(Async::Ready(())) => {
match Future::poll(Pin::new(&mut io), cx) {
Poll::Ready(Ok(())) => {
let event = IdentifyEvent::Sent { peer_id: peer };
return Async::Ready(NetworkBehaviourAction::GenerateEvent(event));
return Poll::Ready(NetworkBehaviourAction::GenerateEvent(event));
},
Ok(Async::NotReady) => {
Poll::Pending => {
self.pending_replies.push_back(Reply::Sending { peer, io });
if sending == to_send {
// All remaining futures are NotReady
@ -207,12 +207,12 @@ where
reply = self.pending_replies.pop_front();
}
}
Err(err) => {
Poll::Ready(Err(err)) => {
let event = IdentifyEvent::Error {
peer_id: peer,
error: ProtocolsHandlerUpgrErr::Upgrade(UpgradeError::Apply(err))
error: ProtocolsHandlerUpgrErr::Upgrade(UpgradeError::Apply(err.into()))
};
return Async::Ready(NetworkBehaviourAction::GenerateEvent(event));
return Poll::Ready(NetworkBehaviourAction::GenerateEvent(event));
},
}
}
@ -221,7 +221,7 @@ where
}
}
Async::NotReady
Poll::Pending
}
}
@ -247,14 +247,14 @@ pub enum IdentifyEvent {
/// The peer with whom the error originated.
peer_id: PeerId,
/// The error that occurred.
error: ProtocolsHandlerUpgrErr<io::Error>,
error: ProtocolsHandlerUpgrErr<ReadOneError>,
},
}
#[cfg(test)]
mod tests {
use crate::{Identify, IdentifyEvent};
use futures::{future, prelude::*};
use futures::prelude::*;
use libp2p_core::{
identity,
PeerId,
@ -269,7 +269,6 @@ mod tests {
use libp2p_mplex::MplexConfig;
use rand::{Rng, thread_rng};
use std::{fmt, io};
use tokio::runtime::current_thread;
fn transport() -> (identity::PublicKey, impl Transport<
Output = (PeerId, impl StreamMuxer<Substream = impl Send, OutboundSubstream = impl Send, Error = impl Into<io::Error>>),
@ -316,40 +315,28 @@ mod tests {
// it will permit the connection to be closed, as defined by
// `IdentifyHandler::connection_keep_alive`. Hence the test succeeds if
// either `Identified` event arrives correctly.
current_thread::Runtime::new().unwrap().block_on(
future::poll_fn(move || -> Result<_, io::Error> {
loop {
match swarm1.poll().unwrap() {
Async::Ready(Some(IdentifyEvent::Received { info, .. })) => {
assert_eq!(info.public_key, pubkey2);
assert_eq!(info.protocol_version, "c");
assert_eq!(info.agent_version, "d");
assert!(!info.protocols.is_empty());
assert!(info.listen_addrs.is_empty());
return Ok(Async::Ready(()))
},
Async::Ready(Some(IdentifyEvent::Sent { .. })) => (),
Async::Ready(e) => panic!("{:?}", e),
Async::NotReady => {}
async_std::task::block_on(async move {
loop {
match future::select(swarm1.next(), swarm2.next()).await.factor_second().0 {
future::Either::Left(Some(Ok(IdentifyEvent::Received { info, .. }))) => {
assert_eq!(info.public_key, pubkey2);
assert_eq!(info.protocol_version, "c");
assert_eq!(info.agent_version, "d");
assert!(!info.protocols.is_empty());
assert!(info.listen_addrs.is_empty());
return;
}
match swarm2.poll().unwrap() {
Async::Ready(Some(IdentifyEvent::Received { info, .. })) => {
assert_eq!(info.public_key, pubkey1);
assert_eq!(info.protocol_version, "a");
assert_eq!(info.agent_version, "b");
assert!(!info.protocols.is_empty());
assert_eq!(info.listen_addrs.len(), 1);
return Ok(Async::Ready(()))
},
Async::Ready(Some(IdentifyEvent::Sent { .. })) => (),
Async::Ready(e) => panic!("{:?}", e),
Async::NotReady => break
future::Either::Right(Some(Ok(IdentifyEvent::Received { info, .. }))) => {
assert_eq!(info.public_key, pubkey1);
assert_eq!(info.protocol_version, "a");
assert_eq!(info.agent_version, "b");
assert!(!info.protocols.is_empty());
assert_eq!(info.listen_addrs.len(), 1);
return;
}
_ => {}
}
Ok(Async::NotReady)
}))
.unwrap();
}
})
}
}

257
protocols/identify/src/protocol.rs
View File

@ -18,25 +18,19 @@
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
use bytes::BytesMut;
use crate::structs_proto;
use futures::{future::{self, FutureResult}, Async, AsyncSink, Future, Poll, Sink, Stream};
use futures::try_ready;
use futures::prelude::*;
use libp2p_core::{
Multiaddr,
PublicKey,
upgrade::{InboundUpgrade, OutboundUpgrade, UpgradeInfo, Negotiated}
upgrade::{self, InboundUpgrade, OutboundUpgrade, UpgradeInfo, Negotiated}
};
use log::{debug, trace};
use protobuf::Message as ProtobufMessage;
use protobuf::parse_from_bytes as protobuf_parse_from_bytes;
use protobuf::RepeatedField;
use std::convert::TryFrom;
use std::io::{Error as IoError, ErrorKind as IoErrorKind};
use std::{fmt, iter};
use tokio_codec::Framed;
use tokio_io::{AsyncRead, AsyncWrite};
use unsigned_varint::codec;
use std::{fmt, io, iter, pin::Pin};
/// Configuration for an upgrade to the `Identify` protocol.
#[derive(Debug, Clone)]
@ -54,7 +48,7 @@ pub struct RemoteInfo {
/// The substream on which a reply is expected to be sent.
pub struct ReplySubstream<T> {
inner: Framed<T, codec::UviBytes<Vec<u8>>>,
inner: T,
}
impl<T> fmt::Debug for ReplySubstream<T> {
@ -65,13 +59,15 @@ impl<T> fmt::Debug for ReplySubstream<T> {
impl<T> ReplySubstream<T>
where
T: AsyncWrite
T: AsyncWrite + Unpin
{
/// Sends back the requested information on the substream.
///
/// Consumes the substream, returning a `ReplyFuture` that resolves
/// when the reply has been sent on the underlying connection.
pub fn send(self, info: IdentifyInfo, observed_addr: &Multiaddr) -> ReplyFuture<T> {
pub fn send(mut self, info: IdentifyInfo, observed_addr: &Multiaddr)
-> impl Future<Output = Result<(), io::Error>>
{
debug!("Sending identify info to client");
trace!("Sending: {:?}", info);
@ -90,50 +86,15 @@ where
message.set_observedAddr(observed_addr.to_vec());
message.set_protocols(RepeatedField::from_vec(info.protocols));
let bytes = message
.write_to_bytes()
.expect("writing protobuf failed; should never happen");
ReplyFuture {
inner: self.inner,
item: Some(bytes),
async move {
let bytes = message
.write_to_bytes()
.expect("writing protobuf failed; should never happen");
upgrade::write_one(&mut self.inner, &bytes).await
}
}
}
/// Future returned by `IdentifySender::send()`. Must be processed to the end in order to send
/// the information to the remote.
// Note: we don't use a `futures::sink::Sink` because it requires `T` to implement `Sink`, which
// means that we would require `T: AsyncWrite` in this struct definition. This requirement
// would then propagate everywhere.
#[must_use = "futures do nothing unless polled"]
pub struct ReplyFuture<T> {
/// The Sink where to send the data.
inner: Framed<T, codec::UviBytes<Vec<u8>>>,
/// Bytes to send, or `None` if we've already sent them.
item: Option<Vec<u8>>,
}
impl<T> Future for ReplyFuture<T>
where T: AsyncWrite
{
type Item = ();
type Error = IoError;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
if let Some(item) = self.item.take() {
if let AsyncSink::NotReady(item) = self.inner.start_send(item)? {
self.item = Some(item);
return Ok(Async::NotReady);
}
}
// A call to `close()` implies flushing.
try_ready!(self.inner.close());
Ok(Async::Ready(()))
}
}
/// Information of a peer sent in `Identify` protocol responses.
#[derive(Debug, Clone)]
pub struct IdentifyInfo {
@ -162,93 +123,60 @@ impl UpgradeInfo for IdentifyProtocolConfig {
impl<C> InboundUpgrade<C> for IdentifyProtocolConfig
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
{
type Output = ReplySubstream<Negotiated<C>>;
type Error = IoError;
type Future = FutureResult<Self::Output, IoError>;
type Error = io::Error;
type Future = future::Ready<Result<Self::Output, io::Error>>;
fn upgrade_inbound(self, socket: Negotiated<C>, _: Self::Info) -> Self::Future {
trace!("Upgrading inbound connection");
let inner = Framed::new(socket, codec::UviBytes::default());
future::ok(ReplySubstream { inner })
future::ok(ReplySubstream { inner: socket })
}
}
impl<C> OutboundUpgrade<C> for IdentifyProtocolConfig
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin + Send + 'static,
{
type Output = RemoteInfo;
type Error = IoError;
type Future = IdentifyOutboundFuture<Negotiated<C>>;
type Error = upgrade::ReadOneError;
type Future = Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send>>;
fn upgrade_outbound(self, socket: Negotiated<C>, _: Self::Info) -> Self::Future {
IdentifyOutboundFuture {
inner: Framed::new(socket, codec::UviBytes::<BytesMut>::default()),
shutdown: false,
}
}
}
fn upgrade_outbound(self, mut socket: Negotiated<C>, _: Self::Info) -> Self::Future {
Box::pin(async move {
socket.close().await?;
let msg = upgrade::read_one(&mut socket, 4096).await?;
let (info, observed_addr) = match parse_proto_msg(msg) {
Ok(v) => v,
Err(err) => {
debug!("Failed to parse protobuf message; error = {:?}", err);
return Err(err.into())
}
};
/// Future returned by `OutboundUpgrade::upgrade_outbound`.
pub struct IdentifyOutboundFuture<T> {
inner: Framed<T, codec::UviBytes<BytesMut>>,
/// If true, we have finished shutting down the writing part of `inner`.
shutdown: bool,
}
trace!("Remote observes us as {:?}", observed_addr);
trace!("Information received: {:?}", info);
impl<T> Future for IdentifyOutboundFuture<T>
where T: AsyncRead + AsyncWrite,
{
type Item = RemoteInfo;
type Error = IoError;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
if !self.shutdown {
try_ready!(self.inner.close());
self.shutdown = true;
}
let msg = match try_ready!(self.inner.poll()) {
Some(i) => i,
None => {
debug!("Identify protocol stream closed before receiving info");
return Err(IoErrorKind::InvalidData.into());
}
};
debug!("Received identify message");
let (info, observed_addr) = match parse_proto_msg(msg) {
Ok(v) => v,
Err(err) => {
debug!("Failed to parse protobuf message; error = {:?}", err);
return Err(err)
}
};
trace!("Remote observes us as {:?}", observed_addr);
trace!("Information received: {:?}", info);
Ok(Async::Ready(RemoteInfo {
info,
observed_addr: observed_addr.clone(),
_priv: ()
}))
Ok(RemoteInfo {
info,
observed_addr: observed_addr.clone(),
_priv: ()
})
})
}
}
// Turns a protobuf message into an `IdentifyInfo` and an observed address. If something bad
// happens, turn it into an `IoError`.
fn parse_proto_msg(msg: BytesMut) -> Result<(IdentifyInfo, Multiaddr), IoError> {
match protobuf_parse_from_bytes::<structs_proto::Identify>(&msg) {
// happens, turn it into an `io::Error`.
fn parse_proto_msg(msg: impl AsRef<[u8]>) -> Result<(IdentifyInfo, Multiaddr), io::Error> {
match protobuf_parse_from_bytes::<structs_proto::Identify>(msg.as_ref()) {
Ok(mut msg) => {
// Turn a `Vec<u8>` into a `Multiaddr`. If something bad happens, turn it into
// an `IoError`.
fn bytes_to_multiaddr(bytes: Vec<u8>) -> Result<Multiaddr, IoError> {
// an `io::Error`.
fn bytes_to_multiaddr(bytes: Vec<u8>) -> Result<Multiaddr, io::Error> {
Multiaddr::try_from(bytes)
.map_err(|err| IoError::new(IoErrorKind::InvalidData, err))
.map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))
}
let listen_addrs = {
@ -260,7 +188,7 @@ fn parse_proto_msg(msg: BytesMut) -> Result<(IdentifyInfo, Multiaddr), IoError>
};
let public_key = PublicKey::from_protobuf_encoding(msg.get_publicKey())
.map_err(|e| IoError::new(IoErrorKind::InvalidData, e))?;
.map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
let observed_addr = bytes_to_multiaddr(msg.take_observedAddr())?;
let info = IdentifyInfo {
@ -274,23 +202,20 @@ fn parse_proto_msg(msg: BytesMut) -> Result<(IdentifyInfo, Multiaddr), IoError>
Ok((info, observed_addr))
}
Err(err) => Err(IoError::new(IoErrorKind::InvalidData, err)),
Err(err) => Err(io::Error::new(io::ErrorKind::InvalidData, err)),
}
}
#[cfg(test)]
mod tests {
use crate::protocol::{IdentifyInfo, RemoteInfo, IdentifyProtocolConfig};
use tokio::runtime::current_thread::Runtime;
use libp2p_tcp::TcpConfig;
use futures::{Future, Stream};
use futures::{prelude::*, channel::oneshot};
use libp2p_core::{
identity,
Transport,
transport::ListenerEvent,
upgrade::{self, apply_outbound, apply_inbound}
};
use std::{io, sync::mpsc, thread};
#[test]
fn correct_transfer() {
@ -299,75 +224,55 @@ mod tests {
let send_pubkey = identity::Keypair::generate_ed25519().public();
let recv_pubkey = send_pubkey.clone();
let (tx, rx) = mpsc::channel();
let (tx, rx) = oneshot::channel();
let bg_thread = thread::spawn(move || {
let bg_task = async_std::task::spawn(async move {
let transport = TcpConfig::new();
let mut listener = transport
.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap())
.unwrap();
let addr = listener.by_ref().wait()
.next()
let addr = listener.next().await
.expect("some event")
.expect("no error")
.into_new_address()
.expect("listen address");
tx.send(addr).unwrap();
let future = listener
.filter_map(ListenerEvent::into_upgrade)
.into_future()
.map_err(|(err, _)| err)
.and_then(|(client, _)| client.unwrap().0)
.and_then(|socket| {
apply_inbound(socket, IdentifyProtocolConfig)
.map_err(|e| io::Error::new(io::ErrorKind::Other, e))
})
.and_then(|sender| {
sender.send(
IdentifyInfo {
public_key: send_pubkey,
protocol_version: "proto_version".to_owned(),
agent_version: "agent_version".to_owned(),
listen_addrs: vec![
"/ip4/80.81.82.83/tcp/500".parse().unwrap(),
"/ip6/::1/udp/1000".parse().unwrap(),
],
protocols: vec!["proto1".to_string(), "proto2".to_string()],
},
&"/ip4/100.101.102.103/tcp/5000".parse().unwrap(),
)
});
let mut rt = Runtime::new().unwrap();
let _ = rt.block_on(future).unwrap();
let socket = listener.next().await.unwrap().unwrap().into_upgrade().unwrap().0.await.unwrap();
let sender = apply_inbound(socket, IdentifyProtocolConfig).await.unwrap();
sender.send(
IdentifyInfo {
public_key: send_pubkey,
protocol_version: "proto_version".to_owned(),
agent_version: "agent_version".to_owned(),
listen_addrs: vec![
"/ip4/80.81.82.83/tcp/500".parse().unwrap(),
"/ip6/::1/udp/1000".parse().unwrap(),
],
protocols: vec!["proto1".to_string(), "proto2".to_string()],
},
&"/ip4/100.101.102.103/tcp/5000".parse().unwrap(),
).await.unwrap();
});
let transport = TcpConfig::new();
async_std::task::block_on(async move {
let transport = TcpConfig::new();
let future = transport.dial(rx.recv().unwrap())
.unwrap()
.and_then(|socket| {
apply_outbound(socket, IdentifyProtocolConfig, upgrade::Version::V1)
.map_err(|e| io::Error::new(io::ErrorKind::Other, e))
})
.and_then(|RemoteInfo { info, observed_addr, .. }| {
assert_eq!(observed_addr, "/ip4/100.101.102.103/tcp/5000".parse().unwrap());
assert_eq!(info.public_key, recv_pubkey);
assert_eq!(info.protocol_version, "proto_version");
assert_eq!(info.agent_version, "agent_version");
assert_eq!(info.listen_addrs,
&["/ip4/80.81.82.83/tcp/500".parse().unwrap(),
"/ip6/::1/udp/1000".parse().unwrap()]);
assert_eq!(info.protocols, &["proto1".to_string(), "proto2".to_string()]);
Ok(())
});
let socket = transport.dial(rx.await.unwrap()).unwrap().await.unwrap();
let RemoteInfo { info, observed_addr, .. } =
apply_outbound(socket, IdentifyProtocolConfig, upgrade::Version::V1).await.unwrap();
assert_eq!(observed_addr, "/ip4/100.101.102.103/tcp/5000".parse().unwrap());
assert_eq!(info.public_key, recv_pubkey);
assert_eq!(info.protocol_version, "proto_version");
assert_eq!(info.agent_version, "agent_version");
assert_eq!(info.listen_addrs,
&["/ip4/80.81.82.83/tcp/500".parse().unwrap(),
"/ip6/::1/udp/1000".parse().unwrap()]);
assert_eq!(info.protocols, &["proto1".to_string(), "proto2".to_string()]);
let mut rt = Runtime::new().unwrap();
let _ = rt.block_on(future).unwrap();
bg_thread.join().unwrap();
bg_task.await;
});
}
}

14
protocols/kad/Cargo.toml
View File

@ -11,10 +11,11 @@ categories = ["network-programming", "asynchronous"]
[dependencies]
arrayvec = "0.5.1"
bytes = "0.4"
bytes = "0.5"
either = "1.5"
fnv = "1.0"
futures = "0.1"
futures_codec = "0.3.4"
futures = "0.3.1"
log = "0.4"
libp2p-core = { version = "0.13.0", path = "../../core" }
libp2p-swarm = { version = "0.3.0", path = "../../swarm" }
@ -23,12 +24,10 @@ multihash = { package = "parity-multihash", version = "0.2.0", path = "../../mis
protobuf = "=2.8.1" # note: see https://github.com/libp2p/rust-libp2p/issues/1363
rand = "0.7.2"
sha2 = "0.8.0"
smallvec = "0.6"
tokio-codec = "0.1"
tokio-io = "0.1"
wasm-timer = "0.1"
smallvec = "1.0"
wasm-timer = "0.2"
uint = "0.8"
unsigned-varint = { version = "0.2.1", features = ["codec"] }
unsigned-varint = { version = "0.3", features = ["futures-codec"] }
void = "1.0"
[dev-dependencies]
@ -37,4 +36,3 @@ libp2p-tcp = { version = "0.13.0", path = "../../transports/tcp" }
libp2p-yamux = { version = "0.13.0", path = "../../muxers/yamux" }
quickcheck = "0.9.0"
rand = "0.7.2"
tokio = "0.1"

20
protocols/kad/src/behaviour.rs
View File

@ -39,7 +39,7 @@ use smallvec::SmallVec;
use std::{borrow::Cow, error, iter, marker::PhantomData, time::Duration};
use std::collections::VecDeque;
use std::num::NonZeroUsize;
use tokio_io::{AsyncRead, AsyncWrite};
use std::task::{Context, Poll};
use wasm_timer::Instant;
/// Network behaviour that handles Kademlia.
@ -1010,7 +1010,7 @@ where
impl<TSubstream, TStore> NetworkBehaviour for Kademlia<TSubstream, TStore>
where
TSubstream: AsyncRead + AsyncWrite,
TSubstream: AsyncRead + AsyncWrite + Unpin,
for<'a> TStore: RecordStore<'a>,
{
type ProtocolsHandler = KademliaHandler<TSubstream, QueryId>;
@ -1304,7 +1304,7 @@ where
};
}
fn poll(&mut self, parameters: &mut impl PollParameters) -> Async<
fn poll(&mut self, cx: &mut Context, parameters: &mut impl PollParameters) -> Poll<
NetworkBehaviourAction<
<Self::ProtocolsHandler as ProtocolsHandler>::InEvent,
Self::OutEvent,
@ -1319,7 +1319,7 @@ where
if let Some(mut job) = self.add_provider_job.take() {
let num = usize::min(JOBS_MAX_NEW_QUERIES, jobs_query_capacity);
for _ in 0 .. num {
if let Async::Ready(r) = job.poll(&mut self.store, now) {
if let Poll::Ready(r) = job.poll(cx, &mut self.store, now) {
self.start_add_provider(r.key, AddProviderContext::Republish)
} else {
break
@ -1333,7 +1333,7 @@ where
if let Some(mut job) = self.put_record_job.take() {
let num = usize::min(JOBS_MAX_NEW_QUERIES, jobs_query_capacity);
for _ in 0 .. num {
if let Async::Ready(r) = job.poll(&mut self.store, now) {
if let Poll::Ready(r) = job.poll(cx, &mut self.store, now) {
let context = if r.publisher.as_ref() == Some(self.kbuckets.local_key().preimage()) {
PutRecordContext::Republish
} else {
@ -1350,7 +1350,7 @@ where
loop {
// Drain queued events first.
if let Some(event) = self.queued_events.pop_front() {
return Async::Ready(event);
return Poll::Ready(event);
}
// Drain applied pending entries from the routing table.
@ -1361,7 +1361,7 @@ where
addresses: value,
old_peer: entry.evicted.map(|n| n.key.into_preimage())
};
return Async::Ready(NetworkBehaviourAction::GenerateEvent(event))
return Poll::Ready(NetworkBehaviourAction::GenerateEvent(event))
}
// Look for a finished query.
@ -1369,12 +1369,12 @@ where
match self.queries.poll(now) {
QueryPoolState::Finished(q) => {
if let Some(event) = self.query_finished(q, parameters) {
return Async::Ready(NetworkBehaviourAction::GenerateEvent(event))
return Poll::Ready(NetworkBehaviourAction::GenerateEvent(event))
}
}
QueryPoolState::Timeout(q) => {
if let Some(event) = self.query_timeout(q) {
return Async::Ready(NetworkBehaviourAction::GenerateEvent(event))
return Poll::Ready(NetworkBehaviourAction::GenerateEvent(event))
}
}
QueryPoolState::Waiting(Some((query, peer_id))) => {
@ -1406,7 +1406,7 @@ where
// If no new events have been queued either, signal `NotReady` to
// be polled again later.
if self.queued_events.is_empty() {
return Async::NotReady
return Poll::Pending
}
}
}

216
protocols/kad/src/behaviour/test.rs
View File

@ -25,7 +25,11 @@ use super::*;
use crate::K_VALUE;
use crate::kbucket::Distance;
use crate::record::store::MemoryStore;
use futures::future;
use futures::{
prelude::*,
executor::block_on,
future::poll_fn,
};
use libp2p_core::{
PeerId,
Transport,
@ -42,7 +46,6 @@ use libp2p_yamux as yamux;
use quickcheck::*;
use rand::{Rng, random, thread_rng};
use std::{collections::{HashSet, HashMap}, io, num::NonZeroUsize, u64};
use tokio::runtime::current_thread;
use multihash::{Multihash, Hash::SHA2256};
type TestSwarm = Swarm<
@ -120,27 +123,30 @@ fn bootstrap() {
let expected_known = swarm_ids.iter().skip(1).cloned().collect::<HashSet<_>>();
// Run test
current_thread::run(
future::poll_fn(move || {
block_on(
poll_fn(move |ctx| {
for (i, swarm) in swarms.iter_mut().enumerate() {
loop {
match swarm.poll().unwrap() {
Async::Ready(Some(KademliaEvent::BootstrapResult(Ok(ok)))) => {
match swarm.poll_next_unpin(ctx) {
Poll::Ready(Some(Ok(KademliaEvent::BootstrapResult(Ok(ok))))) => {
assert_eq!(i, 0);
assert_eq!(ok.peer, swarm_ids[0]);
let known = swarm.kbuckets.iter()
.map(|e| e.node.key.preimage().clone())
.collect::<HashSet<_>>();
assert_eq!(expected_known, known);
return Ok(Async::Ready(()));
return Poll::Ready(())
}
Async::Ready(_) => (),
Async::NotReady => break,
// Ignore any other event.
Poll::Ready(Some(Ok(_))) => (),
e @ Poll::Ready(_) => panic!("Unexpected return value: {:?}", e),
Poll::Pending => break,
}
}
}
Ok(Async::NotReady)
}))
Poll::Pending
})
)
}
let mut rng = thread_rng();
@ -175,27 +181,30 @@ fn query_iter() {
expected_distances.sort();
// Run test
current_thread::run(
future::poll_fn(move || {
block_on(
poll_fn(move |ctx| {
for (i, swarm) in swarms.iter_mut().enumerate() {
loop {
match swarm.poll().unwrap() {
Async::Ready(Some(KademliaEvent::GetClosestPeersResult(Ok(ok)))) => {
match swarm.poll_next_unpin(ctx) {
Poll::Ready(Some(Ok(KademliaEvent::GetClosestPeersResult(Ok(ok))))) => {
assert_eq!(&ok.key[..], search_target.as_bytes());
assert_eq!(swarm_ids[i], expected_swarm_id);
assert_eq!(swarm.queries.size(), 0);
assert!(expected_peer_ids.iter().all(|p| ok.peers.contains(p)));
let key = kbucket::Key::new(ok.key);
assert_eq!(expected_distances, distances(&key, ok.peers));
return Ok(Async::Ready(()));
return Poll::Ready(());
}
Async::Ready(_) => (),
Async::NotReady => break,
// Ignore any other event.
Poll::Ready(Some(Ok(_))) => (),
e @ Poll::Ready(_) => panic!("Unexpected return value: {:?}", e),
Poll::Pending => break,
}
}
}
Ok(Async::NotReady)
}))
Poll::Pending
})
)
}
let mut rng = thread_rng();
@ -220,24 +229,27 @@ fn unresponsive_not_returned_direct() {
let search_target = PeerId::random();
swarms[0].get_closest_peers(search_target.clone());
current_thread::run(
future::poll_fn(move || {
block_on(
poll_fn(move |ctx| {
for swarm in &mut swarms {
loop {
match swarm.poll().unwrap() {
Async::Ready(Some(KademliaEvent::GetClosestPeersResult(Ok(ok)))) => {
match swarm.poll_next_unpin(ctx) {
Poll::Ready(Some(Ok(KademliaEvent::GetClosestPeersResult(Ok(ok))))) => {
assert_eq!(&ok.key[..], search_target.as_bytes());
assert_eq!(ok.peers.len(), 0);
return Ok(Async::Ready(()));
return Poll::Ready(());
}
Async::Ready(_) => (),
Async::NotReady => break,
// Ignore any other event.
Poll::Ready(Some(Ok(_))) => (),
e @ Poll::Ready(_) => panic!("Unexpected return value: {:?}", e),
Poll::Pending => break,
}
}
}
Ok(Async::NotReady)
}))
Poll::Pending
})
)
}
#[test]
@ -261,25 +273,28 @@ fn unresponsive_not_returned_indirect() {
let search_target = PeerId::random();
swarms[1].get_closest_peers(search_target.clone());
current_thread::run(
future::poll_fn(move || {
block_on(
poll_fn(move |ctx| {
for swarm in &mut swarms {
loop {
match swarm.poll().unwrap() {
Async::Ready(Some(KademliaEvent::GetClosestPeersResult(Ok(ok)))) => {
match swarm.poll_next_unpin(ctx) {
Poll::Ready(Some(Ok(KademliaEvent::GetClosestPeersResult(Ok(ok))))) => {
assert_eq!(&ok.key[..], search_target.as_bytes());
assert_eq!(ok.peers.len(), 1);
assert_eq!(ok.peers[0], first_peer_id);
return Ok(Async::Ready(()));
return Poll::Ready(());
}
Async::Ready(_) => (),
Async::NotReady => break,
// Ignore any other event.
Poll::Ready(Some(Ok(_))) => (),
e @ Poll::Ready(_) => panic!("Unexpected return value: {:?}", e),
Poll::Pending => break,
}
}
}
Ok(Async::NotReady)
}))
Poll::Pending
})
)
}
#[test]
@ -294,30 +309,33 @@ fn get_record_not_found() {
let target_key = record::Key::from(Multihash::random(SHA2256));
swarms[0].get_record(&target_key, Quorum::One);
current_thread::run(
future::poll_fn(move || {
block_on(
poll_fn(move |ctx| {
for swarm in &mut swarms {
loop {
match swarm.poll().unwrap() {
Async::Ready(Some(KademliaEvent::GetRecordResult(Err(e)))) => {
match swarm.poll_next_unpin(ctx) {
Poll::Ready(Some(Ok(KademliaEvent::GetRecordResult(Err(e))))) => {
if let GetRecordError::NotFound { key, closest_peers, } = e {
assert_eq!(key, target_key);
assert_eq!(closest_peers.len(), 2);
assert!(closest_peers.contains(&swarm_ids[1]));
assert!(closest_peers.contains(&swarm_ids[2]));
return Ok(Async::Ready(()));
return Poll::Ready(());
} else {
panic!("Unexpected error result: {:?}", e);
}
}
Async::Ready(_) => (),
Async::NotReady => break,
// Ignore any other event.
Poll::Ready(Some(Ok(_))) => (),
e @ Poll::Ready(_) => panic!("Unexpected return value: {:?}", e),
Poll::Pending => break,
}
}
}
Ok(Async::NotReady)
}))
Poll::Pending
})
)
}
#[test]
@ -351,14 +369,14 @@ fn put_record() {
// The accumulated results for one round of publishing.
let mut results = Vec::new();
current_thread::run(
future::poll_fn(move || loop {
// Poll all swarms until they are "NotReady".
block_on(
poll_fn(move |ctx| loop {
// Poll all swarms until they are "Pending".
for swarm in &mut swarms {
loop {
match swarm.poll().unwrap() {
Async::Ready(Some(KademliaEvent::PutRecordResult(res))) |
Async::Ready(Some(KademliaEvent::RepublishRecordResult(res))) => {
match swarm.poll_next_unpin(ctx) {
Poll::Ready(Some(Ok(KademliaEvent::PutRecordResult(res)))) |
Poll::Ready(Some(Ok(KademliaEvent::RepublishRecordResult(res)))) => {
match res {
Err(e) => panic!(e),
Ok(ok) => {
@ -368,16 +386,18 @@ fn put_record() {
}
}
}
Async::Ready(_) => (),
Async::NotReady => break,
// Ignore any other event.
Poll::Ready(Some(Ok(_))) => (),
e @ Poll::Ready(_) => panic!("Unexpected return value: {:?}", e),
Poll::Pending => break,
}
}
}
// All swarms are NotReady and not enough results have been collected
// All swarms are Pending and not enough results have been collected
// so far, thus wait to be polled again for further progress.
if results.len() != records.len() {
return Ok(Async::NotReady)
return Poll::Pending
}
// Consume the results, checking that each record was replicated
@ -422,7 +442,7 @@ fn put_record() {
}
assert_eq!(swarms[0].store.records().count(), 0);
// All records have been republished, thus the test is complete.
return Ok(Async::Ready(()));
return Poll::Ready(());
}
// Tell the replication job to republish asap.
@ -449,24 +469,27 @@ fn get_value() {
swarms[1].store.put(record.clone()).unwrap();
swarms[0].get_record(&record.key, Quorum::One);
current_thread::run(
future::poll_fn(move || {
block_on(
poll_fn(move |ctx| {
for swarm in &mut swarms {
loop {
match swarm.poll().unwrap() {
Async::Ready(Some(KademliaEvent::GetRecordResult(Ok(ok)))) => {
match swarm.poll_next_unpin(ctx) {
Poll::Ready(Some(Ok(KademliaEvent::GetRecordResult(Ok(ok))))) => {
assert_eq!(ok.records.len(), 1);
assert_eq!(ok.records.first(), Some(&record));
return Ok(Async::Ready(()));
return Poll::Ready(());
}
Async::Ready(_) => (),
Async::NotReady => break,
// Ignore any other event.
Poll::Ready(Some(Ok(_))) => (),
e @ Poll::Ready(_) => panic!("Unexpected return value: {:?}", e),
Poll::Pending => break,
}
}
}
Ok(Async::NotReady)
}))
Poll::Pending
})
)
}
#[test]
@ -485,23 +508,26 @@ fn get_value_many() {
let quorum = Quorum::N(NonZeroUsize::new(num_results).unwrap());
swarms[0].get_record(&record.key, quorum);
current_thread::run(
future::poll_fn(move || {
block_on(
poll_fn(move |ctx| {
for swarm in &mut swarms {
loop {
match swarm.poll().unwrap() {
Async::Ready(Some(KademliaEvent::GetRecordResult(Ok(ok)))) => {
match swarm.poll_next_unpin(ctx) {
Poll::Ready(Some(Ok(KademliaEvent::GetRecordResult(Ok(ok))))) => {
assert_eq!(ok.records.len(), num_results);
assert_eq!(ok.records.first(), Some(&record));
return Ok(Async::Ready(()));
return Poll::Ready(());
}
Async::Ready(_) => (),
Async::NotReady => break,
// Ignore any other event.
Poll::Ready(Some(Ok(_))) => (),
e @ Poll::Ready(_) => panic!("Unexpected return value: {:?}", e),
Poll::Pending => break,
}
}
}
Ok(Async::NotReady)
}))
Poll::Pending
})
)
}
#[test]
@ -529,14 +555,14 @@ fn add_provider() {
swarms[0].start_providing(k.clone());
}
current_thread::run(
future::poll_fn(move || loop {
// Poll all swarms until they are "NotReady".
block_on(
poll_fn(move |ctx| loop {
// Poll all swarms until they are "Pending".
for swarm in &mut swarms {
loop {
match swarm.poll().unwrap() {
Async::Ready(Some(KademliaEvent::StartProvidingResult(res))) |
Async::Ready(Some(KademliaEvent::RepublishProviderResult(res))) => {
match swarm.poll_next_unpin(ctx) {
Poll::Ready(Some(Ok(KademliaEvent::StartProvidingResult(res)))) |
Poll::Ready(Some(Ok(KademliaEvent::RepublishProviderResult(res)))) => {
match res {
Err(e) => panic!(e),
Ok(ok) => {
@ -545,8 +571,10 @@ fn add_provider() {
}
}
}
Async::Ready(_) => (),
Async::NotReady => break,
// Ignore any other event.
Poll::Ready(Some(Ok(_))) => (),
e @ Poll::Ready(_) => panic!("Unexpected return value: {:?}", e),
Poll::Pending => break,
}
}
}
@ -559,7 +587,7 @@ fn add_provider() {
if !published {
// Still waiting for all requests to be sent for one round
// of publishing.
return Ok(Async::NotReady)
return Poll::Pending
}
// A round of publishing is complete. Consume the results, checking that
@ -578,7 +606,7 @@ fn add_provider() {
if actual.len() != replication_factor.get() {
// Still waiting for some nodes to process the request.
results.push(key);
return Ok(Async::NotReady)
return Poll::Pending
}
let mut expected = swarm_ids.clone().split_off(1);
@ -608,7 +636,7 @@ fn add_provider() {
}
assert_eq!(swarms[0].store.provided().count(), 0);
// All records have been republished, thus the test is complete.
return Ok(Async::Ready(()));
return Poll::Ready(());
}
// Initiate the second round of publishing by telling the
@ -636,12 +664,12 @@ fn exceed_jobs_max_queries() {
assert_eq!(swarms[0].queries.size(), num);
current_thread::run(
future::poll_fn(move || {
block_on(
poll_fn(move |ctx| {
for _ in 0 .. num {
// There are no other nodes, so the queries finish instantly.
if let Ok(Async::Ready(Some(e))) = swarms[0].poll() {
if let KademliaEvent::BootstrapResult(r) = e {
if let Poll::Ready(Some(e)) = swarms[0].poll_next_unpin(ctx) {
if let Ok(KademliaEvent::BootstrapResult(r)) = e {
assert!(r.is_ok(), "Unexpected error")
} else {
panic!("Unexpected event: {:?}", e)
@ -650,7 +678,7 @@ fn exceed_jobs_max_queries() {
panic!("Expected event")
}
}
Ok(Async::Ready(()))
}))
Poll::Ready(())
})
)
}

173
protocols/kad/src/handler.rs
View File

@ -36,8 +36,7 @@ use libp2p_core::{
upgrade::{self, InboundUpgrade, OutboundUpgrade, Negotiated}
};
use log::trace;
use std::{borrow::Cow, error, fmt, io, time::Duration};
use tokio_io::{AsyncRead, AsyncWrite};
use std::{borrow::Cow, error, fmt, io, pin::Pin, task::Context, task::Poll, time::Duration};
use wasm_timer::Instant;
/// Protocol handler that handles Kademlia communications with the remote.
@ -48,7 +47,7 @@ use wasm_timer::Instant;
/// It also handles requests made by the remote.
pub struct KademliaHandler<TSubstream, TUserData>
where
TSubstream: AsyncRead + AsyncWrite,
TSubstream: AsyncRead + AsyncWrite + Unpin,
{
/// Configuration for the Kademlia protocol.
config: KademliaProtocolConfig,
@ -69,7 +68,7 @@ where
/// State of an active substream, opened either by us or by the remote.
enum SubstreamState<TSubstream, TUserData>
where
TSubstream: AsyncRead + AsyncWrite,
TSubstream: AsyncRead + AsyncWrite + Unpin,
{
/// We haven't started opening the outgoing substream yet.
/// Contains the request we want to send, and the user data if we expect an answer.
@ -103,29 +102,29 @@ where
impl<TSubstream, TUserData> SubstreamState<TSubstream, TUserData>
where
TSubstream: AsyncRead + AsyncWrite,
TSubstream: AsyncRead + AsyncWrite + Unpin,
{
/// Consumes this state and tries to close the substream.
/// Tries to close the substream.
///
/// If the substream is not ready to be closed, returns it back.
fn try_close(self) -> AsyncSink<Self> {
fn try_close(&mut self, cx: &mut Context) -> Poll<()> {
match self {
SubstreamState::OutPendingOpen(_, _)
| SubstreamState::OutReportError(_, _) => AsyncSink::Ready,
SubstreamState::OutPendingSend(mut stream, _, _)
| SubstreamState::OutPendingFlush(mut stream, _)
| SubstreamState::OutWaitingAnswer(mut stream, _)
| SubstreamState::OutClosing(mut stream) => match stream.close() {
Ok(Async::Ready(())) | Err(_) => AsyncSink::Ready,
Ok(Async::NotReady) => AsyncSink::NotReady(SubstreamState::OutClosing(stream)),
| SubstreamState::OutReportError(_, _) => Poll::Ready(()),
SubstreamState::OutPendingSend(ref mut stream, _, _)
| SubstreamState::OutPendingFlush(ref mut stream, _)
| SubstreamState::OutWaitingAnswer(ref mut stream, _)
| SubstreamState::OutClosing(ref mut stream) => match Sink::poll_close(Pin::new(stream), cx) {
Poll::Ready(_) => Poll::Ready(()),
Poll::Pending => Poll::Pending,
},
SubstreamState::InWaitingMessage(_, mut stream)
| SubstreamState::InWaitingUser(_, mut stream)
| SubstreamState::InPendingSend(_, mut stream, _)
| SubstreamState::InPendingFlush(_, mut stream)
| SubstreamState::InClosing(mut stream) => match stream.close() {
Ok(Async::Ready(())) | Err(_) => AsyncSink::Ready,
Ok(Async::NotReady) => AsyncSink::NotReady(SubstreamState::InClosing(stream)),
SubstreamState::InWaitingMessage(_, ref mut stream)
| SubstreamState::InWaitingUser(_, ref mut stream)
| SubstreamState::InPendingSend(_, ref mut stream, _)
| SubstreamState::InPendingFlush(_, ref mut stream)
| SubstreamState::InClosing(ref mut stream) => match Sink::poll_close(Pin::new(stream), cx) {
Poll::Ready(_) => Poll::Ready(()),
Poll::Pending => Poll::Pending,
},
}
}
@ -382,7 +381,7 @@ struct UniqueConnecId(u64);
impl<TSubstream, TUserData> KademliaHandler<TSubstream, TUserData>
where
TSubstream: AsyncRead + AsyncWrite,
TSubstream: AsyncRead + AsyncWrite + Unpin,
{
/// Create a `KademliaHandler` that only allows sending messages to the remote but denying
/// incoming connections.
@ -418,7 +417,7 @@ where
impl<TSubstream, TUserData> Default for KademliaHandler<TSubstream, TUserData>
where
TSubstream: AsyncRead + AsyncWrite,
TSubstream: AsyncRead + AsyncWrite + Unpin,
{
#[inline]
fn default() -> Self {
@ -428,7 +427,7 @@ where
impl<TSubstream, TUserData> ProtocolsHandler for KademliaHandler<TSubstream, TUserData>
where
TSubstream: AsyncRead + AsyncWrite,
TSubstream: AsyncRead + AsyncWrite + Unpin,
TUserData: Clone,
{
type InEvent = KademliaHandlerIn<TUserData>;
@ -485,7 +484,10 @@ where
_ => false,
});
if let Some(pos) = pos {
let _ = self.substreams.remove(pos).try_close();
// TODO: we don't properly close down the substream
let waker = futures::task::noop_waker();
let mut cx = Context::from_waker(&waker);
let _ = self.substreams.remove(pos).try_close(&mut cx);
}
}
KademliaHandlerIn::FindNodeReq { key, user_data } => {
@ -639,22 +641,22 @@ where
fn poll(
&mut self,
cx: &mut Context,
) -> Poll<
ProtocolsHandlerEvent<Self::OutboundProtocol, Self::OutboundOpenInfo, Self::OutEvent>,
io::Error,
ProtocolsHandlerEvent<Self::OutboundProtocol, Self::OutboundOpenInfo, Self::OutEvent, Self::Error>,
> {
// We remove each element from `substreams` one by one and add them back.
for n in (0..self.substreams.len()).rev() {
let mut substream = self.substreams.swap_remove(n);
loop {
match advance_substream(substream, self.config.clone()) {
match advance_substream(substream, self.config.clone(), cx) {
(Some(new_state), Some(event), _) => {
self.substreams.push(new_state);
return Ok(Async::Ready(event));
return Poll::Ready(event);
}
(None, Some(event), _) => {
return Ok(Async::Ready(event));
return Poll::Ready(event);
}
(Some(new_state), None, false) => {
self.substreams.push(new_state);
@ -677,7 +679,7 @@ where
self.keep_alive = KeepAlive::Yes;
}
Ok(Async::NotReady)
Poll::Pending
}
}
@ -688,6 +690,7 @@ where
fn advance_substream<TSubstream, TUserData>(
state: SubstreamState<TSubstream, TUserData>,
upgrade: KademliaProtocolConfig,
cx: &mut Context,
) -> (
Option<SubstreamState<TSubstream, TUserData>>,
Option<
@ -695,12 +698,13 @@ fn advance_substream<TSubstream, TUserData>(
KademliaProtocolConfig,
(KadRequestMsg, Option<TUserData>),
KademliaHandlerEvent<TUserData>,
io::Error,
>,
>,
bool,
)
where
TSubstream: AsyncRead + AsyncWrite,
TSubstream: AsyncRead + AsyncWrite + Unpin,
{
match state {
SubstreamState::OutPendingOpen(msg, user_data) => {
@ -711,18 +715,34 @@ where
(None, Some(ev), false)
}
SubstreamState::OutPendingSend(mut substream, msg, user_data) => {
match substream.start_send(msg) {
Ok(AsyncSink::Ready) => (
Some(SubstreamState::OutPendingFlush(substream, user_data)),
None,
true,
),
Ok(AsyncSink::NotReady(msg)) => (
match Sink::poll_ready(Pin::new(&mut substream), cx) {
Poll::Ready(Ok(())) => {
match Sink::start_send(Pin::new(&mut substream), msg) {
Ok(()) => (
Some(SubstreamState::OutPendingFlush(substream, user_data)),
None,
true,
),
Err(error) => {
let event = if let Some(user_data) = user_data {
Some(ProtocolsHandlerEvent::Custom(KademliaHandlerEvent::QueryError {
error: KademliaHandlerQueryErr::Io(error),
user_data
}))
} else {
None
};
(None, event, false)
}
}
},
Poll::Pending => (
Some(SubstreamState::OutPendingSend(substream, msg, user_data)),
None,
false,
),
Err(error) => {
Poll::Ready(Err(error)) => {
let event = if let Some(user_data) = user_data {
Some(ProtocolsHandlerEvent::Custom(KademliaHandlerEvent::QueryError {
error: KademliaHandlerQueryErr::Io(error),
@ -737,8 +757,8 @@ where
}
}
SubstreamState::OutPendingFlush(mut substream, user_data) => {
match substream.poll_complete() {
Ok(Async::Ready(())) => {
match Sink::poll_flush(Pin::new(&mut substream), cx) {
Poll::Ready(Ok(())) => {
if let Some(user_data) = user_data {
(
Some(SubstreamState::OutWaitingAnswer(substream, user_data)),
@ -749,12 +769,12 @@ where
(Some(SubstreamState::OutClosing(substream)), None, true)
}
}
Ok(Async::NotReady) => (
Poll::Pending => (
Some(SubstreamState::OutPendingFlush(substream, user_data)),
None,
false,
),
Err(error) => {
Poll::Ready(Err(error)) => {
let event = if let Some(user_data) = user_data {
Some(ProtocolsHandlerEvent::Custom(KademliaHandlerEvent::QueryError {
error: KademliaHandlerQueryErr::Io(error),
@ -768,8 +788,8 @@ where
}
}
}
SubstreamState::OutWaitingAnswer(mut substream, user_data) => match substream.poll() {
Ok(Async::Ready(Some(msg))) => {
SubstreamState::OutWaitingAnswer(mut substream, user_data) => match Stream::poll_next(Pin::new(&mut substream), cx) {
Poll::Ready(Some(Ok(msg))) => {
let new_state = SubstreamState::OutClosing(substream);
let event = process_kad_response(msg, user_data);
(
@ -778,19 +798,19 @@ where
true,
)
}
Ok(Async::NotReady) => (
Poll::Pending => (
Some(SubstreamState::OutWaitingAnswer(substream, user_data)),
None,
false,
),
Err(error) => {
Poll::Ready(Some(Err(error))) => {
let event = KademliaHandlerEvent::QueryError {
error: KademliaHandlerQueryErr::Io(error),
user_data,
};
(None, Some(ProtocolsHandlerEvent::Custom(event)), false)
}
Ok(Async::Ready(None)) => {
Poll::Ready(None) => {
let event = KademliaHandlerEvent::QueryError {
error: KademliaHandlerQueryErr::Io(io::ErrorKind::UnexpectedEof.into()),
user_data,
@ -802,13 +822,13 @@ where
let event = KademliaHandlerEvent::QueryError { error, user_data };
(None, Some(ProtocolsHandlerEvent::Custom(event)), false)
}
SubstreamState::OutClosing(mut stream) => match stream.close() {
Ok(Async::Ready(())) => (None, None, false),
Ok(Async::NotReady) => (Some(SubstreamState::OutClosing(stream)), None, false),
Err(_) => (None, None, false),
SubstreamState::OutClosing(mut stream) => match Sink::poll_close(Pin::new(&mut stream), cx) {
Poll::Ready(Ok(())) => (None, None, false),
Poll::Pending => (Some(SubstreamState::OutClosing(stream)), None, false),
Poll::Ready(Err(_)) => (None, None, false),
},
SubstreamState::InWaitingMessage(id, mut substream) => match substream.poll() {
Ok(Async::Ready(Some(msg))) => {
SubstreamState::InWaitingMessage(id, mut substream) => match Stream::poll_next(Pin::new(&mut substream), cx) {
Poll::Ready(Some(Ok(msg))) => {
if let Ok(ev) = process_kad_request(msg, id) {
(
Some(SubstreamState::InWaitingUser(id, substream)),
@ -819,16 +839,16 @@ where
(Some(SubstreamState::InClosing(substream)), None, true)
}
}
Ok(Async::NotReady) => (
Poll::Pending => (
Some(SubstreamState::InWaitingMessage(id, substream)),
None,
false,
),
Ok(Async::Ready(None)) => {
Poll::Ready(None) => {
trace!("Inbound substream: EOF");
(None, None, false)
}
Err(e) => {
Poll::Ready(Some(Err(e))) => {
trace!("Inbound substream error: {:?}", e);
(None, None, false)
},
@ -838,36 +858,39 @@ where
None,
false,
),
SubstreamState::InPendingSend(id, mut substream, msg) => match substream.start_send(msg) {
Ok(AsyncSink::Ready) => (
Some(SubstreamState::InPendingFlush(id, substream)),
None,
true,
),
Ok(AsyncSink::NotReady(msg)) => (
SubstreamState::InPendingSend(id, mut substream, msg) => match Sink::poll_ready(Pin::new(&mut substream), cx) {
Poll::Ready(Ok(())) => match Sink::start_send(Pin::new(&mut substream), msg) {
Ok(()) => (
Some(SubstreamState::InPendingFlush(id, substream)),
None,
true,
),
Err(_) => (None, None, false),
},
Poll::Pending => (
Some(SubstreamState::InPendingSend(id, substream, msg)),
None,
false,
),
Err(_) => (None, None, false),
},
SubstreamState::InPendingFlush(id, mut substream) => match substream.poll_complete() {
Ok(Async::Ready(())) => (
Poll::Ready(Err(_)) => (None, None, false),
}
SubstreamState::InPendingFlush(id, mut substream) => match Sink::poll_flush(Pin::new(&mut substream), cx) {
Poll::Ready(Ok(())) => (
Some(SubstreamState::InWaitingMessage(id, substream)),
None,
true,
),
Ok(Async::NotReady) => (
Poll::Pending => (
Some(SubstreamState::InPendingFlush(id, substream)),
None,
false,
),
Err(_) => (None, None, false),
Poll::Ready(Err(_)) => (None, None, false),
},
SubstreamState::InClosing(mut stream) => match stream.close() {
Ok(Async::Ready(())) => (None, None, false),
Ok(Async::NotReady) => (Some(SubstreamState::InClosing(stream)), None, false),
Err(_) => (None, None, false),
SubstreamState::InClosing(mut stream) => match Sink::poll_close(Pin::new(&mut stream), cx) {
Poll::Ready(Ok(())) => (None, None, false),
Poll::Pending => (Some(SubstreamState::InClosing(stream)), None, false),
Poll::Ready(Err(_)) => (None, None, false),
},
}
}

110
protocols/kad/src/jobs.rs
View File

@ -65,6 +65,8 @@ use crate::record::{self, Record, ProviderRecord, store::RecordStore};
use libp2p_core::PeerId;
use futures::prelude::*;
use std::collections::HashSet;
use std::pin::Pin;
use std::task::{Context, Poll};
use std::time::Duration;
use std::vec;
use wasm_timer::{Instant, Delay};
@ -96,16 +98,18 @@ impl<T> PeriodicJob<T> {
/// Cuts short the remaining delay, if the job is currently waiting
/// for the delay to expire.
fn asap(&mut self) {
if let PeriodicJobState::Waiting(delay) = &mut self.state {
delay.reset(Instant::now() - Duration::from_secs(1))
if let PeriodicJobState::Waiting(delay, deadline) = &mut self.state {
let new_deadline = Instant::now() - Duration::from_secs(1);
*deadline = new_deadline;
delay.reset_at(new_deadline);
}
}
/// Returns `true` if the job is currently not running but ready
/// to be run, `false` otherwise.
fn is_ready(&mut self, now: Instant) -> bool {
if let PeriodicJobState::Waiting(delay) = &mut self.state {
if now >= delay.deadline() || delay.poll().map(|a| a.is_ready()).unwrap_or(false) {
fn is_ready(&mut self, cx: &mut Context, now: Instant) -> bool {
if let PeriodicJobState::Waiting(delay, deadline) = &mut self.state {
if now >= *deadline || !Future::poll(Pin::new(delay), cx).is_pending() {
return true
}
}
@ -117,7 +121,7 @@ impl<T> PeriodicJob<T> {
#[derive(Debug)]
enum PeriodicJobState<T> {
Running(T),
Waiting(Delay)
Waiting(Delay, Instant)
}
//////////////////////////////////////////////////////////////////////////////
@ -143,7 +147,8 @@ impl PutRecordJob {
record_ttl: Option<Duration>,
) -> Self {
let now = Instant::now();
let delay = Delay::new(now + replicate_interval);
let deadline = now + replicate_interval;
let delay = Delay::new_at(deadline);
let next_publish = publish_interval.map(|i| now + i);
Self {
local_id,
@ -153,7 +158,7 @@ impl PutRecordJob {
skipped: HashSet::new(),
inner: PeriodicJob {
interval: replicate_interval,
state: PeriodicJobState::Waiting(delay)
state: PeriodicJobState::Waiting(delay, deadline)
}
}
}
@ -185,11 +190,11 @@ impl PutRecordJob {
/// Must be called in the context of a task. When `NotReady` is returned,
/// the current task is registered to be notified when the job is ready
/// to be run.
pub fn poll<T>(&mut self, store: &mut T, now: Instant) -> Async<Record>
pub fn poll<T>(&mut self, cx: &mut Context, store: &mut T, now: Instant) -> Poll<Record>
where
for<'a> T: RecordStore<'a>
{
if self.inner.is_ready(now) {
if self.inner.is_ready(cx, now) {
let publish = self.next_publish.map_or(false, |t_pub| now >= t_pub);
let records = store.records()
.filter_map(|r| {
@ -224,7 +229,7 @@ impl PutRecordJob {
if r.is_expired(now) {
store.remove(&r.key)
} else {
return Async::Ready(r)
return Poll::Ready(r)
}
} else {
break
@ -232,12 +237,13 @@ impl PutRecordJob {
}
// Wait for the next run.
let delay = Delay::new(now + self.inner.interval);
self.inner.state = PeriodicJobState::Waiting(delay);
assert!(!self.inner.is_ready(now));
let deadline = now + self.inner.interval;
let delay = Delay::new_at(deadline);
self.inner.state = PeriodicJobState::Waiting(delay, deadline);
assert!(!self.inner.is_ready(cx, now));
}
Async::NotReady
Poll::Pending
}
}
@ -256,7 +262,10 @@ impl AddProviderJob {
Self {
inner: PeriodicJob {
interval,
state: PeriodicJobState::Waiting(Delay::new(now + interval))
state: {
let deadline = now + interval;
PeriodicJobState::Waiting(Delay::new_at(deadline), deadline)
}
}
}
}
@ -279,11 +288,11 @@ impl AddProviderJob {
/// Must be called in the context of a task. When `NotReady` is returned,
/// the current task is registered to be notified when the job is ready
/// to be run.
pub fn poll<T>(&mut self, store: &mut T, now: Instant) -> Async<ProviderRecord>
pub fn poll<T>(&mut self, cx: &mut Context, store: &mut T, now: Instant) -> Poll<ProviderRecord>
where
for<'a> T: RecordStore<'a>
{
if self.inner.is_ready(now) {
if self.inner.is_ready(cx, now) {
let records = store.provided()
.map(|r| r.into_owned())
.collect::<Vec<_>>()
@ -297,25 +306,27 @@ impl AddProviderJob {
if r.is_expired(now) {
store.remove_provider(&r.key, &r.provider)
} else {
return Async::Ready(r)
return Poll::Ready(r)
}
} else {
break
}
}
let delay = Delay::new(now + self.inner.interval);
self.inner.state = PeriodicJobState::Waiting(delay);
assert!(!self.inner.is_ready(now));
let deadline = now + self.inner.interval;
let delay = Delay::new_at(deadline);
self.inner.state = PeriodicJobState::Waiting(delay, deadline);
assert!(!self.inner.is_ready(cx, now));
}
Async::NotReady
Poll::Pending
}
}
#[cfg(test)]
mod tests {
use crate::record::store::MemoryStore;
use futures::{executor::block_on, future::poll_fn};
use quickcheck::*;
use rand::Rng;
use super::*;
@ -352,20 +363,20 @@ mod tests {
for r in records {
let _ = store.put(r);
}
// Polling with an instant beyond the deadline for the next run
// is guaranteed to run the job, without the job needing to poll the `Delay`
// and thus without needing to run `poll` in the context of a task
// for testing purposes.
let now = Instant::now() + job.inner.interval;
// All (non-expired) records in the store must be yielded by the job.
for r in store.records().map(|r| r.into_owned()).collect::<Vec<_>>() {
if !r.is_expired(now) {
assert_eq!(job.poll(&mut store, now), Async::Ready(r));
assert!(job.is_running());
block_on(poll_fn(|ctx| {
let now = Instant::now() + job.inner.interval;
// All (non-expired) records in the store must be yielded by the job.
for r in store.records().map(|r| r.into_owned()).collect::<Vec<_>>() {
if !r.is_expired(now) {
assert_eq!(job.poll(ctx, &mut store, now), Poll::Ready(r));
assert!(job.is_running());
}
}
}
assert_eq!(job.poll(&mut store, now), Async::NotReady);
assert!(!job.is_running());
assert_eq!(job.poll(ctx, &mut store, now), Poll::Pending);
assert!(!job.is_running());
Poll::Ready(())
}));
}
quickcheck(prop as fn(_))
@ -382,23 +393,22 @@ mod tests {
r.provider = id.clone();
let _ = store.add_provider(r);
}
// Polling with an instant beyond the deadline for the next run
// is guaranteed to run the job, without the job needing to poll the `Delay`
// and thus without needing to run `poll` in the context of a task
// for testing purposes.
let now = Instant::now() + job.inner.interval;
// All (non-expired) records in the store must be yielded by the job.
for r in store.provided().map(|r| r.into_owned()).collect::<Vec<_>>() {
if !r.is_expired(now) {
assert_eq!(job.poll(&mut store, now), Async::Ready(r));
assert!(job.is_running());
block_on(poll_fn(|ctx| {
let now = Instant::now() + job.inner.interval;
// All (non-expired) records in the store must be yielded by the job.
for r in store.provided().map(|r| r.into_owned()).collect::<Vec<_>>() {
if !r.is_expired(now) {
assert_eq!(job.poll(ctx, &mut store, now), Poll::Ready(r));
assert!(job.is_running());
}
}
}
assert_eq!(job.poll(&mut store, now), Async::NotReady);
assert!(!job.is_running());
assert_eq!(job.poll(ctx, &mut store, now), Poll::Pending);
assert!(!job.is_running());
Poll::Ready(())
}));
}
quickcheck(prop as fn(_))
}
}

62
protocols/kad/src/protocol.rs
View File

@ -34,14 +34,13 @@ use bytes::BytesMut;
use codec::UviBytes;
use crate::dht_proto as proto;
use crate::record::{self, Record};
use futures::{future::{self, FutureResult}, sink, stream, Sink, Stream};
use futures::prelude::*;
use futures_codec::Framed;
use libp2p_core::{Multiaddr, PeerId};
use libp2p_core::upgrade::{InboundUpgrade, OutboundUpgrade, UpgradeInfo, Negotiated};
use protobuf::{self, Message};
use std::{borrow::Cow, convert::TryFrom, time::Duration};
use std::{io, iter};
use tokio_codec::Framed;
use tokio_io::{AsyncRead, AsyncWrite};
use unsigned_varint::codec;
use wasm_timer::Instant;
@ -59,7 +58,6 @@ pub enum KadConnectionType {
}
impl From<proto::Message_ConnectionType> for KadConnectionType {
#[inline]
fn from(raw: proto::Message_ConnectionType) -> KadConnectionType {
use proto::Message_ConnectionType::{
CAN_CONNECT, CANNOT_CONNECT, CONNECTED, NOT_CONNECTED
@ -74,7 +72,6 @@ impl From<proto::Message_ConnectionType> for KadConnectionType {
}
impl Into<proto::Message_ConnectionType> for KadConnectionType {
#[inline]
fn into(self) -> proto::Message_ConnectionType {
use proto::Message_ConnectionType::{
CAN_CONNECT, CANNOT_CONNECT, CONNECTED, NOT_CONNECTED
@ -176,27 +173,31 @@ impl UpgradeInfo for KademliaProtocolConfig {
impl<C> InboundUpgrade<C> for KademliaProtocolConfig
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
{
type Output = KadInStreamSink<Negotiated<C>>;
type Future = FutureResult<Self::Output, io::Error>;
type Future = future::Ready<Result<Self::Output, io::Error>>;
type Error = io::Error;
#[inline]
fn upgrade_inbound(self, incoming: Negotiated<C>, _: Self::Info) -> Self::Future {
let mut codec = UviBytes::default();
codec.set_max_len(4096);
future::ok(
Framed::new(incoming, codec)
.from_err()
.with::<_, fn(_) -> _, _>(|response| {
.err_into()
.with::<_, _, fn(_) -> _, _>(|response| {
let proto_struct = resp_msg_to_proto(response);
proto_struct.write_to_bytes().map_err(invalid_data)
future::ready(proto_struct.write_to_bytes()
.map(io::Cursor::new)
.map_err(invalid_data))
})
.and_then::<fn(_) -> _, _>(|bytes| {
let request = protobuf::parse_from_bytes(&bytes)?;
proto_to_req_msg(request)
.and_then::<_, fn(_) -> _>(|bytes| {
let request = match protobuf::parse_from_bytes(&bytes) {
Ok(r) => r,
Err(err) => return future::ready(Err(err.into()))
};
future::ready(proto_to_req_msg(request))
}),
)
}
@ -204,27 +205,31 @@ where
impl<C> OutboundUpgrade<C> for KademliaProtocolConfig
where
C: AsyncRead + AsyncWrite,
C: AsyncRead + AsyncWrite + Unpin,
{
type Output = KadOutStreamSink<Negotiated<C>>;
type Future = FutureResult<Self::Output, io::Error>;
type Future = future::Ready<Result<Self::Output, io::Error>>;
type Error = io::Error;
#[inline]
fn upgrade_outbound(self, incoming: Negotiated<C>, _: Self::Info) -> Self::Future {
let mut codec = UviBytes::default();
codec.set_max_len(4096);
future::ok(
Framed::new(incoming, codec)
.from_err()
.with::<_, fn(_) -> _, _>(|request| {
.err_into()
.with::<_, _, fn(_) -> _, _>(|request| {
let proto_struct = req_msg_to_proto(request);
proto_struct.write_to_bytes().map_err(invalid_data)
future::ready(proto_struct.write_to_bytes()
.map(io::Cursor::new)
.map_err(invalid_data))
})
.and_then::<fn(_) -> _, _>(|bytes| {
let response = protobuf::parse_from_bytes(&bytes)?;
proto_to_resp_msg(response)
.and_then::<_, fn(_) -> _>(|bytes| {
let response = match protobuf::parse_from_bytes(&bytes) {
Ok(r) => r,
Err(err) => return future::ready(Err(err.into()))
};
future::ready(proto_to_resp_msg(response))
}),
)
}
@ -238,13 +243,14 @@ pub type KadOutStreamSink<S> = KadStreamSink<S, KadRequestMsg, KadResponseMsg>;
pub type KadStreamSink<S, A, B> = stream::AndThen<
sink::With<
stream::FromErr<Framed<S, UviBytes<Vec<u8>>>, io::Error>,
stream::ErrInto<Framed<S, UviBytes<io::Cursor<Vec<u8>>>>, io::Error>,
io::Cursor<Vec<u8>>,
A,
fn(A) -> Result<Vec<u8>, io::Error>,
Result<Vec<u8>, io::Error>,
future::Ready<Result<io::Cursor<Vec<u8>>, io::Error>>,
fn(A) -> future::Ready<Result<io::Cursor<Vec<u8>>, io::Error>>,
>,
fn(BytesMut) -> Result<B, io::Error>,
Result<B, io::Error>,
future::Ready<Result<B, io::Error>>,
fn(BytesMut) -> future::Ready<Result<B, io::Error>>,
>;
/// Request that we can send to a peer or that we received from a peer.

2
protocols/kad/src/record.rs
View File

@ -35,7 +35,7 @@ pub struct Key(Bytes);
impl Key {
/// Creates a new key from the bytes of the input.
pub fn new<K: AsRef<[u8]>>(key: &K) -> Self {
Key(Bytes::from(key.as_ref()))
Key(Bytes::copy_from_slice(key.as_ref()))
}
/// Copies the bytes of the key into a new vector.

7
protocols/noise/Cargo.toml
View File

@ -8,17 +8,16 @@ repository = "https://github.com/libp2p/rust-libp2p"
edition = "2018"
[dependencies]
bytes = "0.4"
bytes = "0.5"
curve25519-dalek = "1"
futures = "0.1"
futures = "0.3.1"
lazy_static = "1.2"
libp2p-core = { version = "0.13.0", path = "../../core" }
log = "0.4"
protobuf = "=2.8.1" # note: see https://github.com/libp2p/rust-libp2p/issues/1363
rand = "^0.7.2"
rand = "0.7.2"
ring = { version = "0.16.9", features = ["alloc"], default-features = false }
snow = { version = "0.6.1", features = ["ring-resolver"], default-features = false }
tokio-io = "0.1"
x25519-dalek = "0.5"
zeroize = "1"

342
protocols/noise/src/io.rs
View File

@ -22,12 +22,11 @@
pub mod handshake;
use futures::{Async, Poll};
use futures::ready;
use futures::prelude::*;
use log::{debug, trace};
use snow;
use snow::error::{StateProblem, Error as SnowError};
use std::{fmt, io};
use tokio_io::{AsyncRead, AsyncWrite};
use std::{fmt, io, pin::Pin, ops::DerefMut, task::{Context, Poll}};
const MAX_NOISE_PKG_LEN: usize = 65535;
const MAX_WRITE_BUF_LEN: usize = 16384;
@ -63,14 +62,14 @@ pub(crate) enum SnowState {
}
impl SnowState {
pub fn read_message(&mut self, message: &[u8], payload: &mut [u8]) -> Result<usize, SnowError> {
pub fn read_message(&mut self, message: &[u8], payload: &mut [u8]) -> Result<usize, snow::Error> {
match self {
SnowState::Handshake(session) => session.read_message(message, payload),
SnowState::Transport(session) => session.read_message(message, payload),
}
}
pub fn write_message(&mut self, message: &[u8], payload: &mut [u8]) -> Result<usize, SnowError> {
pub fn write_message(&mut self, message: &[u8], payload: &mut [u8]) -> Result<usize, snow::Error> {
match self {
SnowState::Handshake(session) => session.write_message(message, payload),
SnowState::Transport(session) => session.write_message(message, payload),
@ -84,10 +83,10 @@ impl SnowState {
}
}
pub fn into_transport_mode(self) -> Result<snow::TransportState, SnowError> {
pub fn into_transport_mode(self) -> Result<snow::TransportState, snow::Error> {
match self {
SnowState::Handshake(session) => session.into_transport_mode(),
SnowState::Transport(_) => Err(SnowError::State(StateProblem::HandshakeAlreadyFinished)),
SnowState::Transport(_) => Err(snow::Error::State(snow::error::StateProblem::HandshakeAlreadyFinished)),
}
}
}
@ -115,7 +114,7 @@ impl<T> fmt::Debug for NoiseOutput<T> {
impl<T> NoiseOutput<T> {
fn new(io: T, session: SnowState) -> Self {
NoiseOutput {
io,
io,
session,
buffer: Buffer { inner: Box::new([0; TOTAL_BUFFER_LEN]) },
read_state: ReadState::Init,
@ -159,57 +158,75 @@ enum WriteState {
EncErr
}
impl<T: io::Read> io::Read for NoiseOutput<T> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
let buffer = self.buffer.borrow_mut();
impl<T: AsyncRead + Unpin> AsyncRead for NoiseOutput<T> {
fn poll_read(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut [u8],
) -> Poll<Result<usize, std::io::Error>> {
let mut this = self.deref_mut();
let buffer = this.buffer.borrow_mut();
loop {
trace!("read state: {:?}", self.read_state);
match self.read_state {
trace!("read state: {:?}", this.read_state);
match this.read_state {
ReadState::Init => {
self.read_state = ReadState::ReadLen { buf: [0, 0], off: 0 };
this.read_state = ReadState::ReadLen { buf: [0, 0], off: 0 };
}
ReadState::ReadLen { mut buf, mut off } => {
let n = match read_frame_len(&mut self.io, &mut buf, &mut off) {
Ok(Some(n)) => n,
Ok(None) => {
let n = match read_frame_len(&mut this.io, cx, &mut buf, &mut off) {
Poll::Ready(Ok(Some(n))) => n,
Poll::Ready(Ok(None)) => {
trace!("read: eof");
self.read_state = ReadState::Eof(Ok(()));
return Ok(0)
this.read_state = ReadState::Eof(Ok(()));
return Poll::Ready(Ok(0))
}
Err(e) => {
if e.kind() == io::ErrorKind::WouldBlock {
// Preserve read state
self.read_state = ReadState::ReadLen { buf, off };
}
return Err(e)
Poll::Ready(Err(e)) => {
return Poll::Ready(Err(e))
}
Poll::Pending => {
this.read_state = ReadState::ReadLen { buf, off };
return Poll::Pending;
}
};
trace!("read: next frame len = {}", n);
if n == 0 {
trace!("read: empty frame");
self.read_state = ReadState::Init;
this.read_state = ReadState::Init;
continue
}
self.read_state = ReadState::ReadData { len: usize::from(n), off: 0 }
this.read_state = ReadState::ReadData { len: usize::from(n), off: 0 }
}
ReadState::ReadData { len, ref mut off } => {
let n = self.io.read(&mut buffer.read[*off .. len])?;
let n = match ready!(
Pin::new(&mut this.io).poll_read(cx, &mut buffer.read[*off ..len])
) {
Ok(n) => n,
Err(e) => return Poll::Ready(Err(e)),
};
trace!("read: read {}/{} bytes", *off + n, len);
if n == 0 {
trace!("read: eof");
self.read_state = ReadState::Eof(Err(()));
return Err(io::ErrorKind::UnexpectedEof.into())
this.read_state = ReadState::Eof(Err(()));
return Poll::Ready(Err(io::ErrorKind::UnexpectedEof.into()))
}
*off += n;
if len == *off {
trace!("read: decrypting {} bytes", len);
if let Ok(n) = self.session.read_message(&buffer.read[.. len], buffer.read_crypto) {
if let Ok(n) = this.session.read_message(
&buffer.read[.. len],
buffer.read_crypto
){
trace!("read: payload len = {} bytes", n);
self.read_state = ReadState::CopyData { len: n, off: 0 }
this.read_state = ReadState::CopyData { len: n, off: 0 }
} else {
debug!("decryption error");
self.read_state = ReadState::DecErr;
return Err(io::ErrorKind::InvalidData.into())
this.read_state = ReadState::DecErr;
return Poll::Ready(Err(io::ErrorKind::InvalidData.into()))
}
}
}
@ -219,32 +236,39 @@ impl<T: io::Read> io::Read for NoiseOutput<T> {
trace!("read: copied {}/{} bytes", *off + n, len);
*off += n;
if len == *off {
self.read_state = ReadState::ReadLen { buf: [0, 0], off: 0 };
this.read_state = ReadState::ReadLen { buf: [0, 0], off: 0 };
}
return Ok(n)
return Poll::Ready(Ok(n))
}
ReadState::Eof(Ok(())) => {
trace!("read: eof");
return Ok(0)
return Poll::Ready(Ok(0))
}
ReadState::Eof(Err(())) => {
trace!("read: eof (unexpected)");
return Err(io::ErrorKind::UnexpectedEof.into())
return Poll::Ready(Err(io::ErrorKind::UnexpectedEof.into()))
}
ReadState::DecErr => return Err(io::ErrorKind::InvalidData.into())
ReadState::DecErr => return Poll::Ready(Err(io::ErrorKind::InvalidData.into()))
}
}
}
}
impl<T: io::Write> io::Write for NoiseOutput<T> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
let buffer = self.buffer.borrow_mut();
impl<T: AsyncWrite + Unpin> AsyncWrite for NoiseOutput<T> {
fn poll_write(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8],
) -> Poll<Result<usize, std::io::Error>>{
let mut this = self.deref_mut();
let buffer = this.buffer.borrow_mut();
loop {
trace!("write state: {:?}", self.write_state);
match self.write_state {
trace!("write state: {:?}", this.write_state);
match this.write_state {
WriteState::Init => {
self.write_state = WriteState::BufferData { off: 0 }
this.write_state = WriteState::BufferData { off: 0 }
}
WriteState::BufferData { ref mut off } => {
let n = std::cmp::min(MAX_WRITE_BUF_LEN - *off, buf.len());
@ -253,138 +277,155 @@ impl<T: io::Write> io::Write for NoiseOutput<T> {
*off += n;
if *off == MAX_WRITE_BUF_LEN {
trace!("write: encrypting {} bytes", *off);
if let Ok(n) = self.session.write_message(buffer.write, buffer.write_crypto) {
trace!("write: cipher text len = {} bytes", n);
self.write_state = WriteState::WriteLen {
len: n,
buf: u16::to_be_bytes(n as u16),
off: 0
match this.session.write_message(buffer.write, buffer.write_crypto) {
Ok(n) => {
trace!("write: cipher text len = {} bytes", n);
this.write_state = WriteState::WriteLen {
len: n,
buf: u16::to_be_bytes(n as u16),
off: 0
}
}
Err(e) => {
debug!("encryption error: {:?}", e);
this.write_state = WriteState::EncErr;
return Poll::Ready(Err(io::ErrorKind::InvalidData.into()))
}
} else {
debug!("encryption error");
self.write_state = WriteState::EncErr;
return Err(io::ErrorKind::InvalidData.into())
}
}
return Ok(n)
return Poll::Ready(Ok(n))
}
WriteState::WriteLen { len, mut buf, mut off } => {
trace!("write: writing len ({}, {:?}, {}/2)", len, buf, off);
match write_frame_len(&mut self.io, &mut buf, &mut off) {
Err(e) => {
if e.kind() == io::ErrorKind::WouldBlock {
self.write_state = WriteState::WriteLen{ len, buf, off };
}
return Err(e)
}
Ok(false) => {
match write_frame_len(&mut this.io, cx, &mut buf, &mut off) {
Poll::Ready(Ok(true)) => (),
Poll::Ready(Ok(false)) => {
trace!("write: eof");
self.write_state = WriteState::Eof;
return Err(io::ErrorKind::WriteZero.into())
this.write_state = WriteState::Eof;
return Poll::Ready(Err(io::ErrorKind::WriteZero.into()))
}
Poll::Ready(Err(e)) => {
return Poll::Ready(Err(e))
}
Poll::Pending => {
this.write_state = WriteState::WriteLen{ len, buf, off };
return Poll::Pending
}
Ok(true) => ()
}
self.write_state = WriteState::WriteData { len, off: 0 }
this.write_state = WriteState::WriteData { len, off: 0 }
}
WriteState::WriteData { len, ref mut off } => {
let n = self.io.write(&buffer.write_crypto[*off .. len])?;
let n = match ready!(
Pin::new(&mut this.io).poll_write(cx, &buffer.write_crypto[*off .. len])
) {
Ok(n) => n,
Err(e) => return Poll::Ready(Err(e)),
};
trace!("write: wrote {}/{} bytes", *off + n, len);
if n == 0 {
trace!("write: eof");
self.write_state = WriteState::Eof;
return Err(io::ErrorKind::WriteZero.into())
this.write_state = WriteState::Eof;
return Poll::Ready(Err(io::ErrorKind::WriteZero.into()))
}
*off += n;
if len == *off {
trace!("write: finished writing {} bytes", len);
self.write_state = WriteState::Init
this.write_state = WriteState::Init
}
}
WriteState::Eof => {
trace!("write: eof");
return Err(io::ErrorKind::WriteZero.into())
return Poll::Ready(Err(io::ErrorKind::WriteZero.into()))
}
WriteState::EncErr => return Err(io::ErrorKind::InvalidData.into())
WriteState::EncErr => return Poll::Ready(Err(io::ErrorKind::InvalidData.into()))
}
}
}
fn flush(&mut self) -> io::Result<()> {
let buffer = self.buffer.borrow_mut();
fn poll_flush(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<(), std::io::Error>> {
let mut this = self.deref_mut();
let buffer = this.buffer.borrow_mut();
loop {
match self.write_state {
WriteState::Init => return self.io.flush(),
match this.write_state {
WriteState::Init => return Pin::new(&mut this.io).poll_flush(cx),
WriteState::BufferData { off } => {
trace!("flush: encrypting {} bytes", off);
if let Ok(n) = self.session.write_message(&buffer.write[.. off], buffer.write_crypto) {
trace!("flush: cipher text len = {} bytes", n);
self.write_state = WriteState::WriteLen {
len: n,
buf: u16::to_be_bytes(n as u16),
off: 0
match this.session.write_message(&buffer.write[.. off], buffer.write_crypto) {
Ok(n) => {
trace!("flush: cipher text len = {} bytes", n);
this.write_state = WriteState::WriteLen {
len: n,
buf: u16::to_be_bytes(n as u16),
off: 0
}
}
Err(e) => {
debug!("encryption error: {:?}", e);
this.write_state = WriteState::EncErr;
return Poll::Ready(Err(io::ErrorKind::InvalidData.into()))
}
} else {
debug!("encryption error");
self.write_state = WriteState::EncErr;
return Err(io::ErrorKind::InvalidData.into())
}
}
WriteState::WriteLen { len, mut buf, mut off } => {
trace!("flush: writing len ({}, {:?}, {}/2)", len, buf, off);
match write_frame_len(&mut self.io, &mut buf, &mut off) {
Ok(true) => (),
Ok(false) => {
match write_frame_len(&mut this.io, cx, &mut buf, &mut off) {
Poll::Ready(Ok(true)) => (),
Poll::Ready(Ok(false)) => {
trace!("write: eof");
self.write_state = WriteState::Eof;
return Err(io::ErrorKind::WriteZero.into())
this.write_state = WriteState::Eof;
return Poll::Ready(Err(io::ErrorKind::WriteZero.into()))
}
Err(e) => {
if e.kind() == io::ErrorKind::WouldBlock {
// Preserve write state
self.write_state = WriteState::WriteLen { len, buf, off };
}
return Err(e)
Poll::Ready(Err(e)) => {
return Poll::Ready(Err(e))
}
Poll::Pending => {
this.write_state = WriteState::WriteLen { len, buf, off };
return Poll::Pending
}
}
self.write_state = WriteState::WriteData { len, off: 0 }
this.write_state = WriteState::WriteData { len, off: 0 }
}
WriteState::WriteData { len, ref mut off } => {
let n = self.io.write(&buffer.write_crypto[*off .. len])?;
let n = match ready!(
Pin::new(&mut this.io).poll_write(cx, &buffer.write_crypto[*off .. len])
) {
Ok(n) => n,
Err(e) => return Poll::Ready(Err(e)),
};
trace!("flush: wrote {}/{} bytes", *off + n, len);
if n == 0 {
trace!("flush: eof");
self.write_state = WriteState::Eof;
return Err(io::ErrorKind::WriteZero.into())
this.write_state = WriteState::Eof;
return Poll::Ready(Err(io::ErrorKind::WriteZero.into()))
}
*off += n;
if len == *off {
trace!("flush: finished writing {} bytes", len);
self.write_state = WriteState::Init;
this.write_state = WriteState::Init;
}
}
WriteState::Eof => {
trace!("flush: eof");
return Err(io::ErrorKind::WriteZero.into())
return Poll::Ready(Err(io::ErrorKind::WriteZero.into()))
}
WriteState::EncErr => return Err(io::ErrorKind::InvalidData.into())
WriteState::EncErr => return Poll::Ready(Err(io::ErrorKind::InvalidData.into()))
}
}
}
}
impl<T: AsyncRead> AsyncRead for NoiseOutput<T> {
unsafe fn prepare_uninitialized_buffer(&self, _: &mut [u8]) -> bool {
false
}
}
impl<T: AsyncWrite> AsyncWrite for NoiseOutput<T> {
fn shutdown(&mut self) -> Poll<(), io::Error> {
match io::Write::flush(self) {
Ok(_) => self.io.shutdown(),
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => Ok(Async::NotReady),
Err(e) => Err(e),
}
fn poll_close(
mut self: Pin<&mut Self>,
cx: &mut Context<'_>,
) -> Poll<Result<(), std::io::Error>>{
ready!(self.as_mut().poll_flush(cx))?;
Pin::new(&mut self.io).poll_close(cx)
}
}
@ -397,17 +438,26 @@ impl<T: AsyncWrite> AsyncWrite for NoiseOutput<T> {
/// for the next invocation.
///
/// Returns `None` if EOF has been encountered.
fn read_frame_len<R: io::Read>(io: &mut R, buf: &mut [u8; 2], off: &mut usize)
-> io::Result<Option<u16>>
{
fn read_frame_len<R: AsyncRead + Unpin>(
mut io: &mut R,
cx: &mut Context<'_>,
buf: &mut [u8; 2],
off: &mut usize,
) -> Poll<Result<Option<u16>, std::io::Error>> {
loop {
let n = io.read(&mut buf[*off ..])?;
if n == 0 {
return Ok(None)
}
*off += n;
if *off == 2 {
return Ok(Some(u16::from_be_bytes(*buf)))
match ready!(Pin::new(&mut io).poll_read(cx, &mut buf[*off ..])) {
Ok(n) => {
if n == 0 {
return Poll::Ready(Ok(None));
}
*off += n;
if *off == 2 {
return Poll::Ready(Ok(Some(u16::from_be_bytes(*buf))));
}
},
Err(e) => {
return Poll::Ready(Err(e));
},
}
}
}
@ -421,18 +471,26 @@ fn read_frame_len<R: io::Read>(io: &mut R, buf: &mut [u8; 2], off: &mut usize)
/// be preserved for the next invocation.
///
/// Returns `false` if EOF has been encountered.
fn write_frame_len<W: io::Write>(io: &mut W, buf: &[u8; 2], off: &mut usize)
-> io::Result<bool>
{
fn write_frame_len<W: AsyncWrite + Unpin>(
mut io: &mut W,
cx: &mut Context<'_>,
buf: &[u8; 2],
off: &mut usize,
) -> Poll<Result<bool, std::io::Error>> {
loop {
let n = io.write(&buf[*off ..])?;
if n == 0 {
return Ok(false)
}
*off += n;
if *off == 2 {
return Ok(true)
match ready!(Pin::new(&mut io).poll_write(cx, &buf[*off ..])) {
Ok(n) => {
if n == 0 {
return Poll::Ready(Ok(false))
}
*off += n;
if *off == 2 {
return Poll::Ready(Ok(true))
}
}
Err(e) => {
return Poll::Ready(Err(e));
}
}
}
}

607
protocols/noise/src/io/handshake.rs
View File

@ -26,30 +26,13 @@ use crate::error::NoiseError;
use crate::protocol::{Protocol, PublicKey, KeypairIdentity};
use crate::io::SnowState;
use libp2p_core::identity;
use futures::{future, Async, Future, future::FutureResult, Poll};
use std::{mem, io};
use tokio_io::{io as nio, AsyncWrite, AsyncRead};
use futures::prelude::*;
use futures::task;
use futures::io::AsyncReadExt;
use protobuf::Message;
use std::{pin::Pin, task::Context};
use super::NoiseOutput;
/// A future performing a Noise handshake pattern.
pub struct Handshake<T, C>(
Box<dyn Future<
Item = <Handshake<T, C> as Future>::Item,
Error = <Handshake<T, C> as Future>::Error
> + Send>
);
impl<T, C> Future for Handshake<T, C> {
type Error = NoiseError;
type Item = (RemoteIdentity<C>, NoiseOutput<T>);
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
self.0.poll()
}
}
/// The identity of the remote established during a handshake.
pub enum RemoteIdentity<C> {
/// The remote provided no identifying information.
@ -105,133 +88,162 @@ pub enum IdentityExchange {
None { remote: identity::PublicKey }
}
impl<T, C> Handshake<T, C>
/// A future performing a Noise handshake pattern.
pub struct Handshake<T, C>(
Pin<Box<dyn Future<
Output = Result<(RemoteIdentity<C>, NoiseOutput<T>), NoiseError>,
> + Send>>
);
impl<T, C> Future for Handshake<T, C> {
type Output = Result<(RemoteIdentity<C>, NoiseOutput<T>), NoiseError>;
fn poll(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> task::Poll<Self::Output> {
Pin::new(&mut self.0).poll(ctx)
}
}
/// Creates an authenticated Noise handshake for the initiator of a
/// single roundtrip (2 message) handshake pattern.
///
/// Subject to the chosen [`IdentityExchange`], this message sequence
/// identifies the local node to the remote with the first message payload
/// (i.e. unencrypted) and expects the remote to identify itself in the
/// second message payload.
///
/// This message sequence is suitable for authenticated 2-message Noise handshake
/// patterns where the static keys of the initiator and responder are either
/// known (i.e. appear in the pre-message pattern) or are sent with
/// the first and second message, respectively (e.g. `IK` or `IX`).
///
/// ```raw
/// initiator -{id}-> responder
/// initiator <-{id}- responder
/// ```
pub fn rt1_initiator<T, C>(
io: T,
session: Result<snow::HandshakeState, NoiseError>,
identity: KeypairIdentity,
identity_x: IdentityExchange
) -> Handshake<T, C>
where
T: AsyncRead + AsyncWrite + Send + 'static,
C: Protocol<C> + AsRef<[u8]> + Send + 'static,
T: AsyncWrite + AsyncRead + Send + Unpin + 'static,
C: Protocol<C> + AsRef<[u8]>
{
/// Creates an authenticated Noise handshake for the initiator of a
/// single roundtrip (2 message) handshake pattern.
///
/// Subject to the chosen [`IdentityExchange`], this message sequence
/// identifies the local node to the remote with the first message payload
/// (i.e. unencrypted) and expects the remote to identify itself in the
/// second message payload.
///
/// This message sequence is suitable for authenticated 2-message Noise handshake
/// patterns where the static keys of the initiator and responder are either
/// known (i.e. appear in the pre-message pattern) or are sent with
/// the first and second message, respectively (e.g. `IK` or `IX`).
///
/// ```raw
/// initiator -{id}-> responder
/// initiator <-{id}- responder
/// ```
pub fn rt1_initiator(
io: T,
session: Result<snow::HandshakeState, NoiseError>,
identity: KeypairIdentity,
identity_x: IdentityExchange
) -> Handshake<T, C> {
Handshake(Box::new(
State::new(io, session, identity, identity_x)
.and_then(State::send_identity)
.and_then(State::recv_identity)
.and_then(State::finish)))
}
Handshake(Box::pin(async move {
let mut state = State::new(io, session, identity, identity_x)?;
send_identity(&mut state).await?;
recv_identity(&mut state).await?;
state.finish()
}))
}
/// Creates an authenticated Noise handshake for the responder of a
/// single roundtrip (2 message) handshake pattern.
///
/// Subject to the chosen [`IdentityExchange`], this message sequence expects the
/// remote to identify itself in the first message payload (i.e. unencrypted)
/// and identifies the local node to the remote in the second message payload.
///
/// This message sequence is suitable for authenticated 2-message Noise handshake
/// patterns where the static keys of the initiator and responder are either
/// known (i.e. appear in the pre-message pattern) or are sent with the first
/// and second message, respectively (e.g. `IK` or `IX`).
///
/// ```raw
/// initiator -{id}-> responder
/// initiator <-{id}- responder
/// ```
pub fn rt1_responder(
io: T,
session: Result<snow::HandshakeState, NoiseError>,
identity: KeypairIdentity,
identity_x: IdentityExchange,
) -> Handshake<T, C> {
Handshake(Box::new(
State::new(io, session, identity, identity_x)
.and_then(State::recv_identity)
.and_then(State::send_identity)
.and_then(State::finish)))
}
/// Creates an authenticated Noise handshake for the responder of a
/// single roundtrip (2 message) handshake pattern.
///
/// Subject to the chosen [`IdentityExchange`], this message sequence expects the
/// remote to identify itself in the first message payload (i.e. unencrypted)
/// and identifies the local node to the remote in the second message payload.
///
/// This message sequence is suitable for authenticated 2-message Noise handshake
/// patterns where the static keys of the initiator and responder are either
/// known (i.e. appear in the pre-message pattern) or are sent with the first
/// and second message, respectively (e.g. `IK` or `IX`).
///
/// ```raw
/// initiator -{id}-> responder
/// initiator <-{id}- responder
/// ```
pub fn rt1_responder<T, C>(
io: T,
session: Result<snow::HandshakeState, NoiseError>,
identity: KeypairIdentity,
identity_x: IdentityExchange,
) -> Handshake<T, C>
where
T: AsyncWrite + AsyncRead + Send + Unpin + 'static,
C: Protocol<C> + AsRef<[u8]>
{
Handshake(Box::pin(async move {
let mut state = State::new(io, session, identity, identity_x)?;
recv_identity(&mut state).await?;
send_identity(&mut state).await?;
state.finish()
}))
}
/// Creates an authenticated Noise handshake for the initiator of a
/// 1.5-roundtrip (3 message) handshake pattern.
///
/// Subject to the chosen [`IdentityExchange`], this message sequence expects
/// the remote to identify itself in the second message payload and
/// identifies the local node to the remote in the third message payload.
/// The first (unencrypted) message payload is always empty.
///
/// This message sequence is suitable for authenticated 3-message Noise handshake
/// patterns where the static keys of the responder and initiator are either known
/// (i.e. appear in the pre-message pattern) or are sent with the second and third
/// message, respectively (e.g. `XX`).
///
/// ```raw
/// initiator --{}--> responder
/// initiator <-{id}- responder
/// initiator -{id}-> responder
/// ```
pub fn rt15_initiator(
io: T,
session: Result<snow::HandshakeState, NoiseError>,
identity: KeypairIdentity,
identity_x: IdentityExchange
) -> Handshake<T, C> {
Handshake(Box::new(
State::new(io, session, identity, identity_x)
.and_then(State::send_empty)
.and_then(State::recv_identity)
.and_then(State::send_identity)
.and_then(State::finish)))
}
/// Creates an authenticated Noise handshake for the initiator of a
/// 1.5-roundtrip (3 message) handshake pattern.
///
/// Subject to the chosen [`IdentityExchange`], this message sequence expects
/// the remote to identify itself in the second message payload and
/// identifies the local node to the remote in the third message payload.
/// The first (unencrypted) message payload is always empty.
///
/// This message sequence is suitable for authenticated 3-message Noise handshake
/// patterns where the static keys of the responder and initiator are either known
/// (i.e. appear in the pre-message pattern) or are sent with the second and third
/// message, respectively (e.g. `XX`).
///
/// ```raw
/// initiator --{}--> responder
/// initiator <-{id}- responder
/// initiator -{id}-> responder
/// ```
pub fn rt15_initiator<T, C>(
io: T,
session: Result<snow::HandshakeState, NoiseError>,
identity: KeypairIdentity,
identity_x: IdentityExchange
) -> Handshake<T, C>
where
T: AsyncWrite + AsyncRead + Unpin + Send + 'static,
C: Protocol<C> + AsRef<[u8]>
{
Handshake(Box::pin(async move {
let mut state = State::new(io, session, identity, identity_x)?;
send_empty(&mut state).await?;
recv_identity(&mut state).await?;
send_identity(&mut state).await?;
state.finish()
}))
}
/// Creates an authenticated Noise handshake for the responder of a
/// 1.5-roundtrip (3 message) handshake pattern.
///
/// Subject to the chosen [`IdentityExchange`], this message sequence
/// identifies the local node in the second message payload and expects
/// the remote to identify itself in the third message payload. The first
/// (unencrypted) message payload is always empty.
///
/// This message sequence is suitable for authenticated 3-message Noise handshake
/// patterns where the static keys of the responder and initiator are either known
/// (i.e. appear in the pre-message pattern) or are sent with the second and third
/// message, respectively (e.g. `XX`).
///
/// ```raw
/// initiator --{}--> responder
/// initiator <-{id}- responder
/// initiator -{id}-> responder
/// ```
pub fn rt15_responder(
io: T,
session: Result<snow::HandshakeState, NoiseError>,
identity: KeypairIdentity,
identity_x: IdentityExchange
) -> Handshake<T, C> {
Handshake(Box::new(
State::new(io, session, identity, identity_x)
.and_then(State::recv_empty)
.and_then(State::send_identity)
.and_then(State::recv_identity)
.and_then(State::finish)))
}
/// Creates an authenticated Noise handshake for the responder of a
/// 1.5-roundtrip (3 message) handshake pattern.
///
/// Subject to the chosen [`IdentityExchange`], this message sequence
/// identifies the local node in the second message payload and expects
/// the remote to identify itself in the third message payload. The first
/// (unencrypted) message payload is always empty.
///
/// This message sequence is suitable for authenticated 3-message Noise handshake
/// patterns where the static keys of the responder and initiator are either known
/// (i.e. appear in the pre-message pattern) or are sent with the second and third
/// message, respectively (e.g. `XX`).
///
/// ```raw
/// initiator --{}--> responder
/// initiator <-{id}- responder
/// initiator -{id}-> responder
/// ```
pub fn rt15_responder<T, C>(
io: T,
session: Result<snow::HandshakeState, NoiseError>,
identity: KeypairIdentity,
identity_x: IdentityExchange
) -> Handshake<T, C>
where
T: AsyncWrite + AsyncRead + Unpin + Send + 'static,
C: Protocol<C> + AsRef<[u8]>
{
Handshake(Box::pin(async move {
let mut state = State::new(io, session, identity, identity_x)?;
recv_empty(&mut state).await?;
send_identity(&mut state).await?;
recv_identity(&mut state).await?;
state.finish()
}))
}
//////////////////////////////////////////////////////////////////////////////
@ -252,36 +264,6 @@ struct State<T> {
send_identity: bool,
}
impl<T: io::Read> io::Read for State<T> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
self.io.read(buf)
}
}
impl<T: io::Write> io::Write for State<T> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.io.write(buf)
}
fn flush(&mut self) -> io::Result<()> {
self.io.flush()
}
}
impl<T: AsyncRead> AsyncRead for State<T> {
unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool {
self.io.prepare_uninitialized_buffer(buf)
}
fn read_buf<B: bytes::BufMut>(&mut self, buf: &mut B) -> Poll<usize, io::Error> {
self.io.read_buf(buf)
}
}
impl<T: AsyncWrite> AsyncWrite for State<T> {
fn shutdown(&mut self) -> Poll<(), io::Error> {
self.io.shutdown()
}
}
impl<T> State<T> {
/// Initializes the state for a new Noise handshake, using the given local
/// identity keypair and local DH static public key. The handshake messages
@ -293,14 +275,14 @@ impl<T> State<T> {
session: Result<snow::HandshakeState, NoiseError>,
identity: KeypairIdentity,
identity_x: IdentityExchange
) -> FutureResult<Self, NoiseError> {
) -> Result<Self, NoiseError> {
let (id_remote_pubkey, send_identity) = match identity_x {
IdentityExchange::Mutual => (None, true),
IdentityExchange::Send { remote } => (Some(remote), true),
IdentityExchange::Receive => (None, false),
IdentityExchange::None { remote } => (Some(remote), false)
};
future::result(session.map(|s|
session.map(|s|
State {
identity,
io: NoiseOutput::new(io, SnowState::Handshake(s)),
@ -308,7 +290,7 @@ impl<T> State<T> {
id_remote_pubkey,
send_identity
}
))
)
}
}
@ -316,19 +298,19 @@ impl<T> State<T>
{
/// Finish a handshake, yielding the established remote identity and the
/// [`NoiseOutput`] for communicating on the encrypted channel.
fn finish<C>(self) -> FutureResult<(RemoteIdentity<C>, NoiseOutput<T>), NoiseError>
fn finish<C>(self) -> Result<(RemoteIdentity<C>, NoiseOutput<T>), NoiseError>
where
C: Protocol<C> + AsRef<[u8]>
{
let dh_remote_pubkey = match self.io.session.get_remote_static() {
None => None,
Some(k) => match C::public_from_bytes(k) {
Err(e) => return future::err(e),
Err(e) => return Err(e),
Ok(dh_pk) => Some(dh_pk)
}
};
match self.io.session.into_transport_mode() {
Err(e) => future::err(e.into()),
Err(e) => Err(e.into()),
Ok(s) => {
let remote = match (self.id_remote_pubkey, dh_remote_pubkey) {
(_, None) => RemoteIdentity::Unknown,
@ -337,258 +319,85 @@ impl<T> State<T>
if C::verify(&id_pk, &dh_pk, &self.dh_remote_pubkey_sig) {
RemoteIdentity::IdentityKey(id_pk)
} else {
return future::err(NoiseError::InvalidKey)
return Err(NoiseError::InvalidKey)
}
}
};
future::ok((remote, NoiseOutput { session: SnowState::Transport(s), .. self.io }))
Ok((remote, NoiseOutput { session: SnowState::Transport(s), .. self.io }))
}
}
}
}
impl<T> State<T> {
/// Creates a future that sends a Noise handshake message with an empty payload.
fn send_empty(self) -> SendEmpty<T> {
SendEmpty { state: SendState::Write(self) }
}
/// Creates a future that expects to receive a Noise handshake message with an empty payload.
fn recv_empty(self) -> RecvEmpty<T> {
RecvEmpty { state: RecvState::Read(self) }
}
/// Creates a future that sends a Noise handshake message with a payload identifying
/// the local node to the remote.
fn send_identity(self) -> SendIdentity<T> {
SendIdentity { state: SendIdentityState::Init(self) }
}
/// Creates a future that expects to receive a Noise handshake message with a
/// payload identifying the remote.
fn recv_identity(self) -> RecvIdentity<T> {
RecvIdentity { state: RecvIdentityState::Init(self) }
}
}
//////////////////////////////////////////////////////////////////////////////
// Handshake Message Futures
// RecvEmpty -----------------------------------------------------------------
/// A future for receiving a Noise handshake message with an empty payload.
///
/// Obtained from [`Handshake::recv_empty`].
struct RecvEmpty<T> {
state: RecvState<T>
}
enum RecvState<T> {
Read(State<T>),
Done
}
impl<T> Future for RecvEmpty<T>
async fn recv_empty<T>(state: &mut State<T>) -> Result<(), NoiseError>
where
T: AsyncRead
T: AsyncRead + Unpin
{
type Error = NoiseError;
type Item = State<T>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
match mem::replace(&mut self.state, RecvState::Done) {
RecvState::Read(mut st) => {
if !st.io.poll_read(&mut [])?.is_ready() {
self.state = RecvState::Read(st);
return Ok(Async::NotReady)
}
Ok(Async::Ready(st))
},
RecvState::Done => panic!("RecvEmpty polled after completion")
}
}
state.io.read(&mut []).await?;
Ok(())
}
// SendEmpty -----------------------------------------------------------------
/// A future for sending a Noise handshake message with an empty payload.
///
/// Obtained from [`Handshake::send_empty`].
struct SendEmpty<T> {
state: SendState<T>
}
enum SendState<T> {
Write(State<T>),
Flush(State<T>),
Done
}
impl<T> Future for SendEmpty<T>
async fn send_empty<T>(state: &mut State<T>) -> Result<(), NoiseError>
where
T: AsyncWrite
T: AsyncWrite + Unpin
{
type Error = NoiseError;
type Item = State<T>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
loop {
match mem::replace(&mut self.state, SendState::Done) {
SendState::Write(mut st) => {
if !st.io.poll_write(&mut [])?.is_ready() {
self.state = SendState::Write(st);
return Ok(Async::NotReady)
}
self.state = SendState::Flush(st);
},
SendState::Flush(mut st) => {
if !st.io.poll_flush()?.is_ready() {
self.state = SendState::Flush(st);
return Ok(Async::NotReady)
}
return Ok(Async::Ready(st))
}
SendState::Done => panic!("SendEmpty polled after completion")
}
}
}
state.io.write(&[]).await?;
state.io.flush().await?;
Ok(())
}
// RecvIdentity --------------------------------------------------------------
/// A future for receiving a Noise handshake message with a payload
/// identifying the remote.
///
/// Obtained from [`Handshake::recv_identity`].
struct RecvIdentity<T> {
state: RecvIdentityState<T>
}
enum RecvIdentityState<T> {
Init(State<T>),
ReadPayloadLen(nio::ReadExact<State<T>, [u8; 2]>),
ReadPayload(nio::ReadExact<State<T>, Vec<u8>>),
Done
}
impl<T> Future for RecvIdentity<T>
async fn recv_identity<T>(state: &mut State<T>) -> Result<(), NoiseError>
where
T: AsyncRead,
T: AsyncRead + Unpin,
{
type Error = NoiseError;
type Item = State<T>;
let mut len_buf = [0,0];
state.io.read_exact(&mut len_buf).await?;
let len = u16::from_be_bytes(len_buf) as usize;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
loop {
match mem::replace(&mut self.state, RecvIdentityState::Done) {
RecvIdentityState::Init(st) => {
self.state = RecvIdentityState::ReadPayloadLen(nio::read_exact(st, [0, 0]));
},
RecvIdentityState::ReadPayloadLen(mut read_len) => {
if let Async::Ready((st, bytes)) = read_len.poll()? {
let len = u16::from_be_bytes(bytes) as usize;
let buf = vec![0; len];
self.state = RecvIdentityState::ReadPayload(nio::read_exact(st, buf));
} else {
self.state = RecvIdentityState::ReadPayloadLen(read_len);
return Ok(Async::NotReady);
}
},
RecvIdentityState::ReadPayload(mut read_payload) => {
if let Async::Ready((mut st, bytes)) = read_payload.poll()? {
let pb: payload_proto::Identity = protobuf::parse_from_bytes(&bytes)?;
if !pb.pubkey.is_empty() {
let pk = identity::PublicKey::from_protobuf_encoding(pb.get_pubkey())
.map_err(|_| NoiseError::InvalidKey)?;
if let Some(ref k) = st.id_remote_pubkey {
if k != &pk {
return Err(NoiseError::InvalidKey)
}
}
st.id_remote_pubkey = Some(pk);
}
if !pb.signature.is_empty() {
st.dh_remote_pubkey_sig = Some(pb.signature)
}
return Ok(Async::Ready(st))
} else {
self.state = RecvIdentityState::ReadPayload(read_payload);
return Ok(Async::NotReady)
}
},
RecvIdentityState::Done => panic!("RecvIdentity polled after completion")
let mut payload_buf = vec![0; len];
state.io.read_exact(&mut payload_buf).await?;
let pb: payload_proto::Identity = protobuf::parse_from_bytes(&payload_buf)?;
if !pb.pubkey.is_empty() {
let pk = identity::PublicKey::from_protobuf_encoding(pb.get_pubkey())
.map_err(|_| NoiseError::InvalidKey)?;
if let Some(ref k) = state.id_remote_pubkey {
if k != &pk {
return Err(NoiseError::InvalidKey)
}
}
state.id_remote_pubkey = Some(pk);
}
if !pb.signature.is_empty() {
state.dh_remote_pubkey_sig = Some(pb.signature);
}
Ok(())
}
// SendIdentity --------------------------------------------------------------
/// A future for sending a Noise handshake message with a payload
/// identifying the local node to the remote.
///
/// Obtained from [`Handshake::send_identity`].
struct SendIdentity<T> {
state: SendIdentityState<T>
}
enum SendIdentityState<T> {
Init(State<T>),
WritePayloadLen(nio::WriteAll<State<T>, [u8; 2]>, Vec<u8>),
WritePayload(nio::WriteAll<State<T>, Vec<u8>>),
Flush(State<T>),
Done
}
impl<T> Future for SendIdentity<T>
/// Send a Noise handshake message with a payload identifying the local node to the remote.
async fn send_identity<T>(state: &mut State<T>) -> Result<(), NoiseError>
where
T: AsyncWrite,
T: AsyncWrite + Unpin,
{
type Error = NoiseError;
type Item = State<T>;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
loop {
match mem::replace(&mut self.state, SendIdentityState::Done) {
SendIdentityState::Init(st) => {
let mut pb = payload_proto::Identity::new();
if st.send_identity {
pb.set_pubkey(st.identity.public.clone().into_protobuf_encoding());
}
if let Some(ref sig) = st.identity.signature {
pb.set_signature(sig.clone());
}
let pb_bytes = pb.write_to_bytes()?;
let len = (pb_bytes.len() as u16).to_be_bytes();
let write_len = nio::write_all(st, len);
self.state = SendIdentityState::WritePayloadLen(write_len, pb_bytes);
},
SendIdentityState::WritePayloadLen(mut write_len, payload) => {
if let Async::Ready((st, _)) = write_len.poll()? {
self.state = SendIdentityState::WritePayload(nio::write_all(st, payload));
} else {
self.state = SendIdentityState::WritePayloadLen(write_len, payload);
return Ok(Async::NotReady)
}
},
SendIdentityState::WritePayload(mut write_payload) => {
if let Async::Ready((st, _)) = write_payload.poll()? {
self.state = SendIdentityState::Flush(st);
} else {
self.state = SendIdentityState::WritePayload(write_payload);
return Ok(Async::NotReady)
}
},
SendIdentityState::Flush(mut st) => {
if !st.poll_flush()?.is_ready() {
self.state = SendIdentityState::Flush(st);
return Ok(Async::NotReady)
}
return Ok(Async::Ready(st))
},
SendIdentityState::Done => panic!("SendIdentity polled after completion")
}
}
let mut pb = payload_proto::Identity::new();
if state.send_identity {
pb.set_pubkey(state.identity.public.clone().into_protobuf_encoding());
}
if let Some(ref sig) = state.identity.signature {
pb.set_signature(sig.clone());
}
let pb_bytes = pb.write_to_bytes()?;
let len = (pb_bytes.len() as u16).to_be_bytes();
state.io.write_all(&len).await?;
state.io.write_all(&pb_bytes).await?;
state.io.flush().await?;
Ok(())
}

72
protocols/noise/src/lib.rs
View File

@ -25,11 +25,11 @@
//!
//! This crate provides `libp2p_core::InboundUpgrade` and `libp2p_core::OutboundUpgrade`
//! implementations for various noise handshake patterns (currently `IK`, `IX`, and `XX`)
//! over a particular choice of DH key agreement (currently only X25519).
//! over a particular choice of Diffie–Hellman key agreement (currently only X25519).
//!
//! All upgrades produce as output a pair, consisting of the remote's static public key
//! and a `NoiseOutput` which represents the established cryptographic session with the
//! remote, implementing `tokio_io::AsyncRead` and `tokio_io::AsyncWrite`.
//! remote, implementing `futures::io::AsyncRead` and `futures::io::AsyncWrite`.
//!
//! # Usage
//!
@ -57,13 +57,14 @@ mod protocol;
pub use error::NoiseError;
pub use io::NoiseOutput;
pub use io::handshake;
pub use io::handshake::{Handshake, RemoteIdentity, IdentityExchange};
pub use protocol::{Keypair, AuthenticKeypair, KeypairIdentity, PublicKey, SecretKey};
pub use protocol::{Protocol, ProtocolParams, x25519::X25519, IX, IK, XX};
use futures::{future::{self, FutureResult}, Future};
use futures::prelude::*;
use libp2p_core::{identity, PeerId, UpgradeInfo, InboundUpgrade, OutboundUpgrade, Negotiated};
use tokio_io::{AsyncRead, AsyncWrite};
use std::pin::Pin;
use zeroize::Zeroize;
/// The protocol upgrade configuration.
@ -158,7 +159,7 @@ where
impl<T, C> InboundUpgrade<T> for NoiseConfig<IX, C>
where
NoiseConfig<IX, C>: UpgradeInfo,
T: AsyncRead + AsyncWrite + Send + 'static,
T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
C: Protocol<C> + AsRef<[u8]> + Zeroize + Send + 'static,
{
type Output = (RemoteIdentity<C>, NoiseOutput<Negotiated<T>>);
@ -170,7 +171,7 @@ where
.local_private_key(self.dh_keys.secret().as_ref())
.build_responder()
.map_err(NoiseError::from);
Handshake::rt1_responder(socket, session,
handshake::rt1_responder(socket, session,
self.dh_keys.into_identity(),
IdentityExchange::Mutual)
}
@ -179,7 +180,7 @@ where
impl<T, C> OutboundUpgrade<T> for NoiseConfig<IX, C>
where
NoiseConfig<IX, C>: UpgradeInfo,
T: AsyncRead + AsyncWrite + Send + 'static,
T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
C: Protocol<C> + AsRef<[u8]> + Zeroize + Send + 'static,
{
type Output = (RemoteIdentity<C>, NoiseOutput<Negotiated<T>>);
@ -191,9 +192,9 @@ where
.local_private_key(self.dh_keys.secret().as_ref())
.build_initiator()
.map_err(NoiseError::from);
Handshake::rt1_initiator(socket, session,
self.dh_keys.into_identity(),
IdentityExchange::Mutual)
handshake::rt1_initiator(socket, session,
self.dh_keys.into_identity(),
IdentityExchange::Mutual)
}
}
@ -202,7 +203,7 @@ where
impl<T, C> InboundUpgrade<T> for NoiseConfig<XX, C>
where
NoiseConfig<XX, C>: UpgradeInfo,
T: AsyncRead + AsyncWrite + Send + 'static,
T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
C: Protocol<C> + AsRef<[u8]> + Zeroize + Send + 'static,
{
type Output = (RemoteIdentity<C>, NoiseOutput<Negotiated<T>>);
@ -214,7 +215,7 @@ where
.local_private_key(self.dh_keys.secret().as_ref())
.build_responder()
.map_err(NoiseError::from);
Handshake::rt15_responder(socket, session,
handshake::rt15_responder(socket, session,
self.dh_keys.into_identity(),
IdentityExchange::Mutual)
}
@ -223,7 +224,7 @@ where
impl<T, C> OutboundUpgrade<T> for NoiseConfig<XX, C>
where
NoiseConfig<XX, C>: UpgradeInfo,
T: AsyncRead + AsyncWrite + Send + 'static,
T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
C: Protocol<C> + AsRef<[u8]> + Zeroize + Send + 'static,
{
type Output = (RemoteIdentity<C>, NoiseOutput<Negotiated<T>>);
@ -235,7 +236,7 @@ where
.local_private_key(self.dh_keys.secret().as_ref())
.build_initiator()
.map_err(NoiseError::from);
Handshake::rt15_initiator(socket, session,
handshake::rt15_initiator(socket, session,
self.dh_keys.into_identity(),
IdentityExchange::Mutual)
}
@ -246,7 +247,7 @@ where
impl<T, C> InboundUpgrade<T> for NoiseConfig<IK, C>
where
NoiseConfig<IK, C>: UpgradeInfo,
T: AsyncRead + AsyncWrite + Send + 'static,
T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
C: Protocol<C> + AsRef<[u8]> + Zeroize + Send + 'static,
{
type Output = (RemoteIdentity<C>, NoiseOutput<Negotiated<T>>);
@ -258,7 +259,7 @@ where
.local_private_key(self.dh_keys.secret().as_ref())
.build_responder()
.map_err(NoiseError::from);
Handshake::rt1_responder(socket, session,
handshake::rt1_responder(socket, session,
self.dh_keys.into_identity(),
IdentityExchange::Receive)
}
@ -267,7 +268,7 @@ where
impl<T, C> OutboundUpgrade<T> for NoiseConfig<IK, C, (PublicKey<C>, identity::PublicKey)>
where
NoiseConfig<IK, C, (PublicKey<C>, identity::PublicKey)>: UpgradeInfo,
T: AsyncRead + AsyncWrite + Send + 'static,
T: AsyncRead + AsyncWrite + Unpin + Send + 'static,
C: Protocol<C> + AsRef<[u8]> + Zeroize + Send + 'static,
{
type Output = (RemoteIdentity<C>, NoiseOutput<Negotiated<T>>);
@ -280,7 +281,7 @@ where
.remote_public_key(self.remote.0.as_ref())
.build_initiator()
.map_err(NoiseError::from);
Handshake::rt1_initiator(socket, session,
handshake::rt1_initiator(socket, session,
self.dh_keys.into_identity(),
IdentityExchange::Send { remote: self.remote.1 })
}
@ -320,23 +321,20 @@ where
NoiseConfig<P, C, R>: UpgradeInfo + InboundUpgrade<T,
Output = (RemoteIdentity<C>, NoiseOutput<Negotiated<T>>),
Error = NoiseError
>,
> + 'static,
<NoiseConfig<P, C, R> as InboundUpgrade<T>>::Future: Send,
T: AsyncRead + AsyncWrite + Send + 'static,
C: Protocol<C> + AsRef<[u8]> + Zeroize + Send + 'static,
{
type Output = (PeerId, NoiseOutput<Negotiated<T>>);
type Error = NoiseError;
type Future = future::AndThen<
<NoiseConfig<P, C, R> as InboundUpgrade<T>>::Future,
FutureResult<Self::Output, Self::Error>,
fn((RemoteIdentity<C>, NoiseOutput<Negotiated<T>>)) -> FutureResult<Self::Output, Self::Error>
>;
type Future = Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send>>;
fn upgrade_inbound(self, socket: Negotiated<T>, info: Self::Info) -> Self::Future {
self.config.upgrade_inbound(socket, info)
.and_then(|(remote, io)| future::result(match remote {
RemoteIdentity::IdentityKey(pk) => Ok((pk.into_peer_id(), io)),
_ => Err(NoiseError::AuthenticationFailed)
Box::pin(self.config.upgrade_inbound(socket, info)
.and_then(|(remote, io)| match remote {
RemoteIdentity::IdentityKey(pk) => future::ok((pk.into_peer_id(), io)),
_ => future::err(NoiseError::AuthenticationFailed)
}))
}
}
@ -346,24 +344,20 @@ where
NoiseConfig<P, C, R>: UpgradeInfo + OutboundUpgrade<T,
Output = (RemoteIdentity<C>, NoiseOutput<Negotiated<T>>),
Error = NoiseError
>,
> + 'static,
<NoiseConfig<P, C, R> as OutboundUpgrade<T>>::Future: Send,
T: AsyncRead + AsyncWrite + Send + 'static,
C: Protocol<C> + AsRef<[u8]> + Zeroize + Send + 'static,
{
type Output = (PeerId, NoiseOutput<Negotiated<T>>);
type Error = NoiseError;
type Future = future::AndThen<
<NoiseConfig<P, C, R> as OutboundUpgrade<T>>::Future,
FutureResult<Self::Output, Self::Error>,
fn((RemoteIdentity<C>, NoiseOutput<Negotiated<T>>)) -> FutureResult<Self::Output, Self::Error>
>;
type Future = Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send>>;
fn upgrade_outbound(self, socket: Negotiated<T>, info: Self::Info) -> Self::Future {
self.config.upgrade_outbound(socket, info)
.and_then(|(remote, io)| future::result(match remote {
RemoteIdentity::IdentityKey(pk) => Ok((pk.into_peer_id(), io)),
_ => Err(NoiseError::AuthenticationFailed)
Box::pin(self.config.upgrade_outbound(socket, info)
.and_then(|(remote, io)| match remote {
RemoteIdentity::IdentityKey(pk) => future::ok((pk.into_peer_id(), io)),
_ => future::err(NoiseError::AuthenticationFailed)
}))
}
}

85
protocols/noise/tests/smoke.rs
View File

@ -26,7 +26,6 @@ use libp2p_noise::{Keypair, X25519, NoiseConfig, RemoteIdentity, NoiseError, Noi
use libp2p_tcp::{TcpConfig, TcpTransStream};
use log::info;
use quickcheck::QuickCheck;
use tokio::{self, io};
#[allow(dead_code)]
fn core_upgrade_compat() {
@ -113,9 +112,9 @@ fn ik_xx() {
let server_transport = TcpConfig::new()
.and_then(move |output, endpoint| {
if endpoint.is_listener() {
Either::A(apply_inbound(output, NoiseConfig::ik_listener(server_dh)))
Either::Left(apply_inbound(output, NoiseConfig::ik_listener(server_dh)))
} else {
Either::B(apply_outbound(output, NoiseConfig::xx(server_dh),
Either::Right(apply_outbound(output, NoiseConfig::xx(server_dh),
upgrade::Version::V1))
}
})
@ -126,11 +125,11 @@ fn ik_xx() {
let client_transport = TcpConfig::new()
.and_then(move |output, endpoint| {
if endpoint.is_dialer() {
Either::A(apply_outbound(output,
Either::Left(apply_outbound(output,
NoiseConfig::ik_dialer(client_dh, server_id_public, server_dh_public),
upgrade::Version::V1))
} else {
Either::B(apply_inbound(output, NoiseConfig::xx(client_dh)))
Either::Right(apply_inbound(output, NoiseConfig::xx(client_dh)))
}
})
.and_then(move |out, _| expect_identity(out, &server_id_public2));
@ -147,55 +146,63 @@ fn run<T, U>(server_transport: T, client_transport: U, message1: Vec<u8>)
where
T: Transport<Output = Output>,
T::Dial: Send + 'static,
T::Listener: Send + 'static,
T::Listener: Send + Unpin + futures::stream::TryStream + 'static,
T::ListenerUpgrade: Send + 'static,
U: Transport<Output = Output>,
U::Dial: Send + 'static,
U::Listener: Send + 'static,
U::ListenerUpgrade: Send + 'static,
{
let message2 = message1.clone();
futures::executor::block_on(async {
let mut message2 = message1.clone();
let mut server = server_transport
.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap())
.unwrap();
let mut server: T::Listener = server_transport
.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap())
.unwrap();
let server_address = server.by_ref().wait()
.next()
.expect("some event")
.expect("no error")
.into_new_address()
.expect("listen address");
let server_address = server.try_next()
.await
.expect("some event")
.expect("no error")
.into_new_address()
.expect("listen address");
let server = server.take(1)
.filter_map(ListenerEvent::into_upgrade)
.and_then(|client| client.0)
.map_err(|e| panic!("server error: {}", e))
.and_then(|(_, client)| {
let client_fut = async {
let mut client_session = client_transport.dial(server_address.clone())
.unwrap()
.await
.map(|(_, session)| session)
.expect("no error");
client_session.write_all(&mut message2).await.expect("no error");
client_session.flush().await.expect("no error");
};
let server_fut = async {
let mut server_session = server.try_next()
.await
.expect("some event")
.map(ListenerEvent::into_upgrade)
.expect("no error")
.map(|client| client.0)
.expect("listener upgrade")
.await
.map(|(_, session)| session)
.expect("no error");
let mut server_buffer = vec![];
info!("server: reading message");
io::read_to_end(client, Vec::new())
})
.for_each(move |msg| {
assert_eq!(msg.1, message1);
Ok(())
});
server_session.read_to_end(&mut server_buffer).await.expect("no error");
let client = client_transport.dial(server_address.clone()).unwrap()
.map_err(|e| panic!("client error: {}", e))
.and_then(move |(_, server)| {
io::write_all(server, message2).and_then(|(client, _)| io::flush(client))
})
.map(|_| ());
assert_eq!(server_buffer, message1);
};
let future = client.join(server)
.map_err(|e| panic!("{:?}", e))
.map(|_| ());
tokio::run(future)
futures::future::join(server_fut, client_fut).await;
})
}
fn expect_identity(output: Output, pk: &identity::PublicKey)
-> impl Future<Item = Output, Error = NoiseError>
-> impl Future<Output = Result<Output, NoiseError>>
{
match output.0 {
RemoteIdentity::IdentityKey(ref k) if k == pk => future::ok(output),

10
protocols/ping/Cargo.toml
View File

@ -10,21 +10,19 @@ keywords = ["peer-to-peer", "libp2p", "networking"]
categories = ["network-programming", "asynchronous"]
[dependencies]
bytes = "0.4"
bytes = "0.5"
futures = "0.3.1"
libp2p-core = { version = "0.13.0", path = "../../core" }
libp2p-swarm = { version = "0.3.0", path = "../../swarm" }
log = "0.4.1"
multiaddr = { package = "parity-multiaddr", version = "0.6.0", path = "../../misc/multiaddr" }
futures = "0.1"
rand = "0.7.2"
tokio-io = "0.1"
wasm-timer = "0.1"
void = "1.0"
wasm-timer = "0.2"
[dev-dependencies]
async-std = "1.0"
libp2p-tcp = { version = "0.13.0", path = "../../transports/tcp" }
libp2p-secio = { version = "0.13.0", path = "../../protocols/secio" }
libp2p-yamux = { version = "0.13.0", path = "../../muxers/yamux" }
quickcheck = "0.9.0"
tokio = "0.1"
tokio-tcp = "0.1"

68
protocols/ping/src/handler.rs
View File

@ -27,10 +27,9 @@ use libp2p_swarm::{
ProtocolsHandlerUpgrErr,
ProtocolsHandlerEvent
};
use std::{error::Error, io, fmt, num::NonZeroU32, time::Duration};
use std::{error::Error, io, fmt, num::NonZeroU32, pin::Pin, task::Context, task::Poll, time::Duration};
use std::collections::VecDeque;
use tokio_io::{AsyncRead, AsyncWrite};
use wasm_timer::{Delay, Instant};
use wasm_timer::Delay;
use void::Void;
/// The configuration for outbound pings.
@ -176,7 +175,7 @@ impl<TSubstream> PingHandler<TSubstream> {
pub fn new(config: PingConfig) -> Self {
PingHandler {
config,
next_ping: Delay::new(Instant::now()),
next_ping: Delay::new(Duration::new(0, 0)),
pending_results: VecDeque::with_capacity(2),
failures: 0,
_marker: std::marker::PhantomData
@ -186,7 +185,7 @@ impl<TSubstream> PingHandler<TSubstream> {
impl<TSubstream> ProtocolsHandler for PingHandler<TSubstream>
where
TSubstream: AsyncRead + AsyncWrite,
TSubstream: AsyncRead + AsyncWrite + Send + Unpin + 'static,
{
type InEvent = Void;
type OutEvent = PingResult;
@ -228,36 +227,36 @@ where
}
}
fn poll(&mut self) -> Poll<ProtocolsHandlerEvent<protocol::Ping, (), PingResult>, Self::Error> {
fn poll(&mut self, cx: &mut Context) -> Poll<ProtocolsHandlerEvent<protocol::Ping, (), PingResult, Self::Error>> {
if let Some(result) = self.pending_results.pop_back() {
if let Ok(PingSuccess::Ping { .. }) = result {
let next_ping = Instant::now() + self.config.interval;
self.failures = 0;
self.next_ping.reset(next_ping);
self.next_ping.reset(self.config.interval);
}
if let Err(e) = result {
self.failures += 1;
if self.failures >= self.config.max_failures.get() {
return Err(e)
return Poll::Ready(ProtocolsHandlerEvent::Close(e))
} else {
return Ok(Async::Ready(ProtocolsHandlerEvent::Custom(Err(e))))
return Poll::Ready(ProtocolsHandlerEvent::Custom(Err(e)))
}
}
return Ok(Async::Ready(ProtocolsHandlerEvent::Custom(result)))
return Poll::Ready(ProtocolsHandlerEvent::Custom(result))
}
match self.next_ping.poll() {
Ok(Async::Ready(())) => {
self.next_ping.reset(Instant::now() + self.config.timeout);
match Future::poll(Pin::new(&mut self.next_ping), cx) {
Poll::Ready(Ok(())) => {
self.next_ping.reset(self.config.timeout);
let protocol = SubstreamProtocol::new(protocol::Ping)
.with_timeout(self.config.timeout);
Ok(Async::Ready(ProtocolsHandlerEvent::OutboundSubstreamRequest {
Poll::Ready(ProtocolsHandlerEvent::OutboundSubstreamRequest {
protocol,
info: (),
}))
})
},
Ok(Async::NotReady) => Ok(Async::NotReady),
Err(e) => Err(PingFailure::Other { error: Box::new(e) })
Poll::Pending => Poll::Pending,
Poll::Ready(Err(e)) =>
Poll::Ready(ProtocolsHandlerEvent::Close(PingFailure::Other { error: Box::new(e) }))
}
}
}
@ -266,11 +265,10 @@ where
mod tests {
use super::*;
use async_std::net::TcpStream;
use futures::future;
use quickcheck::*;
use rand::Rng;
use tokio_tcp::TcpStream;
use tokio::runtime::current_thread::Runtime;
impl Arbitrary for PingConfig {
fn arbitrary<G: Gen>(g: &mut G) -> PingConfig {
@ -281,11 +279,10 @@ mod tests {
}
}
fn tick(h: &mut PingHandler<TcpStream>) -> Result<
ProtocolsHandlerEvent<protocol::Ping, (), PingResult>,
PingFailure
> {
Runtime::new().unwrap().block_on(future::poll_fn(|| h.poll() ))
fn tick(h: &mut PingHandler<TcpStream>)
-> ProtocolsHandlerEvent<protocol::Ping, (), PingResult, PingFailure>
{
async_std::task::block_on(future::poll_fn(|cx| h.poll(cx) ))
}
#[test]
@ -293,34 +290,25 @@ mod tests {
fn prop(cfg: PingConfig, ping_rtt: Duration) -> bool {
let mut h = PingHandler::<TcpStream>::new(cfg);
// The first ping is scheduled "immediately".
let start = h.next_ping.deadline();
assert!(start <= Instant::now());
// Send ping
match tick(&mut h) {
Ok(ProtocolsHandlerEvent::OutboundSubstreamRequest { protocol, info: _ }) => {
ProtocolsHandlerEvent::OutboundSubstreamRequest { protocol, info: _ } => {
// The handler must use the configured timeout.
assert_eq!(protocol.timeout(), &h.config.timeout);
// The next ping must be scheduled no earlier than the ping timeout.
assert!(h.next_ping.deadline() >= start + h.config.timeout);
}
e => panic!("Unexpected event: {:?}", e)
}
let now = Instant::now();
// Receive pong
h.inject_fully_negotiated_outbound(ping_rtt, ());
match tick(&mut h) {
Ok(ProtocolsHandlerEvent::Custom(Ok(PingSuccess::Ping { rtt }))) => {
ProtocolsHandlerEvent::Custom(Ok(PingSuccess::Ping { rtt })) => {
// The handler must report the given RTT.
assert_eq!(rtt, ping_rtt);
// The next ping must be scheduled no earlier than the ping interval.
assert!(now + h.config.interval <= h.next_ping.deadline());
}
e => panic!("Unexpected event: {:?}", e)
}
true
}
@ -334,20 +322,20 @@ mod tests {
for _ in 0 .. h.config.max_failures.get() - 1 {
h.inject_dial_upgrade_error((), ProtocolsHandlerUpgrErr::Timeout);
match tick(&mut h) {
Ok(ProtocolsHandlerEvent::Custom(Err(PingFailure::Timeout))) => {}
ProtocolsHandlerEvent::Custom(Err(PingFailure::Timeout)) => {}
e => panic!("Unexpected event: {:?}", e)
}
}
h.inject_dial_upgrade_error((), ProtocolsHandlerUpgrErr::Timeout);
match tick(&mut h) {
Err(PingFailure::Timeout) => {
ProtocolsHandlerEvent::Close(PingFailure::Timeout) => {
assert_eq!(h.failures, h.config.max_failures.get());
}
e => panic!("Unexpected event: {:?}", e)
}
h.inject_fully_negotiated_outbound(Duration::from_secs(1), ());
match tick(&mut h) {
Ok(ProtocolsHandlerEvent::Custom(Ok(PingSuccess::Ping { .. }))) => {
ProtocolsHandlerEvent::Custom(Ok(PingSuccess::Ping { .. })) => {
// A success resets the counter for consecutive failures.
assert_eq!(h.failures, 0);
}

13
protocols/ping/src/lib.rs
View File

@ -50,9 +50,7 @@ use handler::PingHandler;
use futures::prelude::*;
use libp2p_core::{ConnectedPoint, Multiaddr, PeerId};
use libp2p_swarm::{NetworkBehaviour, NetworkBehaviourAction, PollParameters};
use std::collections::VecDeque;
use std::marker::PhantomData;
use tokio_io::{AsyncRead, AsyncWrite};
use std::{collections::VecDeque, marker::PhantomData, task::Context, task::Poll};
use void::Void;
/// `Ping` is a [`NetworkBehaviour`] that responds to inbound pings and
@ -95,7 +93,7 @@ impl<TSubstream> Default for Ping<TSubstream> {
impl<TSubstream> NetworkBehaviour for Ping<TSubstream>
where
TSubstream: AsyncRead + AsyncWrite,
TSubstream: AsyncRead + AsyncWrite + Send + Unpin + 'static,
{
type ProtocolsHandler = PingHandler<TSubstream>;
type OutEvent = PingEvent;
@ -116,12 +114,13 @@ where
self.events.push_front(PingEvent { peer, result })
}
fn poll(&mut self, _: &mut impl PollParameters) -> Async<NetworkBehaviourAction<Void, PingEvent>>
fn poll(&mut self, _: &mut Context, _: &mut impl PollParameters)
-> Poll<NetworkBehaviourAction<Void, PingEvent>>
{
if let Some(e) = self.events.pop_back() {
Async::Ready(NetworkBehaviourAction::GenerateEvent(e))
Poll::Ready(NetworkBehaviourAction::GenerateEvent(e))
} else {
Async::NotReady
Poll::Pending
}
}
}

164
protocols/ping/src/protocol.rs
View File

@ -18,12 +18,11 @@
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
use futures::{prelude::*, future, try_ready};
use libp2p_core::{InboundUpgrade, OutboundUpgrade, UpgradeInfo, upgrade::Negotiated};
use futures::{future::BoxFuture, prelude::*};
use libp2p_core::{InboundUpgrade, OutboundUpgrade, UpgradeInfo, Negotiated};
use log::debug;
use rand::{distributions, prelude::*};
use std::{io, iter, time::Duration};
use tokio_io::{io as nio, AsyncRead, AsyncWrite};
use wasm_timer::Instant;
/// Represents a prototype for an upgrade to handle the ping protocol.
@ -54,126 +53,49 @@ impl UpgradeInfo for Ping {
}
}
type RecvPing<T> = nio::ReadExact<Negotiated<T>, [u8; 32]>;
type SendPong<T> = nio::WriteAll<Negotiated<T>, [u8; 32]>;
type Flush<T> = nio::Flush<Negotiated<T>>;
type Shutdown<T> = nio::Shutdown<Negotiated<T>>;
impl<TSocket> InboundUpgrade<TSocket> for Ping
where
TSocket: AsyncRead + AsyncWrite,
TSocket: AsyncRead + AsyncWrite + Send + Unpin + 'static,
{
type Output = ();
type Error = io::Error;
type Future = future::Map<
future::AndThen<
future::AndThen<
future::AndThen<
RecvPing<TSocket>,
SendPong<TSocket>, fn((Negotiated<TSocket>, [u8; 32])) -> SendPong<TSocket>>,
Flush<TSocket>, fn((Negotiated<TSocket>, [u8; 32])) -> Flush<TSocket>>,
Shutdown<TSocket>, fn(Negotiated<TSocket>) -> Shutdown<TSocket>>,
fn(Negotiated<TSocket>) -> ()>;
type Future = BoxFuture<'static, Result<(), io::Error>>;
#[inline]
fn upgrade_inbound(self, socket: Negotiated<TSocket>, _: Self::Info) -> Self::Future {
nio::read_exact(socket, [0; 32])
.and_then::<fn(_) -> _, _>(|(sock, buf)| nio::write_all(sock, buf))
.and_then::<fn(_) -> _, _>(|(sock, _)| nio::flush(sock))
.and_then::<fn(_) -> _, _>(|sock| nio::shutdown(sock))
.map(|_| ())
fn upgrade_inbound(self, mut socket: Negotiated<TSocket>, _: Self::Info) -> Self::Future {
async move {
let mut payload = [0u8; 32];
socket.read_exact(&mut payload).await?;
socket.write_all(&payload).await?;
socket.close().await?;
Ok(())
}.boxed()
}
}
impl<TSocket> OutboundUpgrade<TSocket> for Ping
where
TSocket: AsyncRead + AsyncWrite,
TSocket: AsyncRead + AsyncWrite + Send + Unpin + 'static,
{
type Output = Duration;
type Error = io::Error;
type Future = PingDialer<Negotiated<TSocket>>;
type Future = BoxFuture<'static, Result<Duration, io::Error>>;
#[inline]
fn upgrade_outbound(self, socket: Negotiated<TSocket>, _: Self::Info) -> Self::Future {
fn upgrade_outbound(self, mut socket: Negotiated<TSocket>, _: Self::Info) -> Self::Future {
let payload: [u8; 32] = thread_rng().sample(distributions::Standard);
debug!("Preparing ping payload {:?}", payload);
async move {
socket.write_all(&payload).await?;
socket.close().await?;
let started = Instant::now();
PingDialer {
state: PingDialerState::Write {
inner: nio::write_all(socket, payload),
},
}
}
}
/// A `PingDialer` is a future that sends a ping and expects to receive a pong.
pub struct PingDialer<TSocket> {
state: PingDialerState<TSocket>
}
enum PingDialerState<TSocket> {
Write {
inner: nio::WriteAll<TSocket, [u8; 32]>,
},
Flush {
inner: nio::Flush<TSocket>,
payload: [u8; 32],
},
Read {
inner: nio::ReadExact<TSocket, [u8; 32]>,
payload: [u8; 32],
started: Instant,
},
Shutdown {
inner: nio::Shutdown<TSocket>,
rtt: Duration,
},
}
impl<TSocket> Future for PingDialer<TSocket>
where
TSocket: AsyncRead + AsyncWrite,
{
type Item = Duration;
type Error = io::Error;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
loop {
self.state = match self.state {
PingDialerState::Write { ref mut inner } => {
let (socket, payload) = try_ready!(inner.poll());
PingDialerState::Flush {
inner: nio::flush(socket),
payload,
}
},
PingDialerState::Flush { ref mut inner, payload } => {
let socket = try_ready!(inner.poll());
let started = Instant::now();
PingDialerState::Read {
inner: nio::read_exact(socket, [0; 32]),
payload,
started,
}
},
PingDialerState::Read { ref mut inner, payload, started } => {
let (socket, payload_received) = try_ready!(inner.poll());
let rtt = started.elapsed();
if payload_received != payload {
return Err(io::Error::new(
io::ErrorKind::InvalidData, "Ping payload mismatch"));
}
PingDialerState::Shutdown {
inner: nio::shutdown(socket),
rtt,
}
},
PingDialerState::Shutdown { ref mut inner, rtt } => {
try_ready!(inner.poll());
return Ok(Async::Ready(rtt));
},
let mut recv_payload = [0u8; 32];
socket.read_exact(&mut recv_payload).await?;
if recv_payload == payload {
Ok(started.elapsed())
} else {
Err(io::Error::new(io::ErrorKind::InvalidData, "Ping payload mismatch"))
}
}
}.boxed()
}
}
@ -199,31 +121,23 @@ mod tests {
let mut listener = MemoryTransport.listen_on(mem_addr).unwrap();
let listener_addr =
if let Ok(Async::Ready(Some(ListenerEvent::NewAddress(a)))) = listener.poll() {
if let Some(Some(Ok(ListenerEvent::NewAddress(a)))) = listener.next().now_or_never() {
a
} else {
panic!("MemoryTransport not listening on an address!");
};
async_std::task::spawn(async move {
let listener_event = listener.next().await.unwrap();
let (listener_upgrade, _) = listener_event.unwrap().into_upgrade().unwrap();
let conn = listener_upgrade.await.unwrap();
upgrade::apply_inbound(conn, Ping::default()).await.unwrap();
});
let server = listener
.into_future()
.map_err(|(e, _)| e)
.and_then(|(listener_event, _)| {
let (listener_upgrade, _) = listener_event.unwrap().into_upgrade().unwrap();
let conn = listener_upgrade.wait().unwrap();
upgrade::apply_inbound(conn, Ping::default())
.map_err(|e| panic!(e))
});
let client = MemoryTransport.dial(listener_addr).unwrap()
.and_then(|c| {
upgrade::apply_outbound(c, Ping::default(), upgrade::Version::V1)
.map_err(|e| panic!(e))
});
let mut runtime = tokio::runtime::Runtime::new().unwrap();
runtime.spawn(server.map_err(|e| panic!(e)));
let rtt = runtime.block_on(client).expect("RTT");
assert!(rtt > Duration::from_secs(0));
async_std::task::block_on(async move {
let c = MemoryTransport.dial(listener_addr).unwrap().await.unwrap();
let rtt = upgrade::apply_outbound(c, Ping::default(), upgrade::Version::V1).await.unwrap();
assert!(rtt > Duration::from_secs(0));
});
}
}

77
protocols/ping/tests/ping.rs
View File

@ -23,20 +23,18 @@
use libp2p_core::{
Multiaddr,
PeerId,
Negotiated,
identity,
muxing::StreamMuxerBox,
transport::{Transport, boxed::Boxed},
either::EitherError,
upgrade::{self, UpgradeError}
};
use libp2p_ping::*;
use libp2p_yamux::{self as yamux, Yamux};
use libp2p_secio::{SecioConfig, SecioOutput, SecioError};
use libp2p_secio::{SecioConfig, SecioError};
use libp2p_swarm::Swarm;
use libp2p_tcp::{TcpConfig, TcpTransStream};
use futures::{future, prelude::*};
use std::{io, time::Duration, sync::mpsc::sync_channel};
use tokio::runtime::Runtime;
use libp2p_tcp::TcpConfig;
use futures::{prelude::*, channel::mpsc};
use std::{io, time::Duration};
#[test]
fn ping() {
@ -48,56 +46,45 @@ fn ping() {
let (peer2_id, trans) = mk_transport();
let mut swarm2 = Swarm::new(trans, Ping::new(cfg), peer2_id.clone());
let (tx, rx) = sync_channel::<Multiaddr>(1);
let (mut tx, mut rx) = mpsc::channel::<Multiaddr>(1);
let pid1 = peer1_id.clone();
let addr = "/ip4/127.0.0.1/tcp/0".parse().unwrap();
let mut listening = false;
Swarm::listen_on(&mut swarm1, addr).unwrap();
let peer1 = future::poll_fn(move || -> Result<_, ()> {
let peer1 = async move {
while let Some(_) = swarm1.next().now_or_never() {}
for l in Swarm::listeners(&swarm1) {
tx.send(l.clone()).await.unwrap();
}
loop {
match swarm1.poll().expect("Error while polling swarm") {
Async::Ready(Some(PingEvent { peer, result })) => match result {
Ok(PingSuccess::Ping { rtt }) =>
return Ok(Async::Ready((pid1.clone(), peer, rtt))),
_ => {}
match swarm1.next().await.unwrap().unwrap() {
PingEvent { peer, result: Ok(PingSuccess::Ping { rtt }) } => {
return (pid1.clone(), peer, rtt)
},
_ => {
if !listening {
for l in Swarm::listeners(&swarm1) {
tx.send(l.clone()).unwrap();
listening = true;
}
}
return Ok(Async::NotReady)
}
_ => {}
}
}
});
};
let pid2 = peer2_id.clone();
let mut dialing = false;
let peer2 = future::poll_fn(move || -> Result<_, ()> {
let peer2 = async move {
Swarm::dial_addr(&mut swarm2, rx.next().await.unwrap()).unwrap();
loop {
match swarm2.poll().expect("Error while polling swarm") {
Async::Ready(Some(PingEvent { peer, result })) => match result {
Ok(PingSuccess::Ping { rtt }) =>
return Ok(Async::Ready((pid2.clone(), peer, rtt))),
_ => {}
match swarm2.next().await.unwrap().unwrap() {
PingEvent { peer, result: Ok(PingSuccess::Ping { rtt }) } => {
return (pid2.clone(), peer, rtt)
},
_ => {
if !dialing {
Swarm::dial_addr(&mut swarm2, rx.recv().unwrap()).unwrap();
dialing = true;
}
return Ok(Async::NotReady)
}
_ => {}
}
}
});
};
let result = peer1.select(peer2).map_err(|e| panic!(e));
let ((p1, p2, rtt), _) = Runtime::new().unwrap().block_on(result).unwrap();
let result = future::select(Box::pin(peer1), Box::pin(peer2));
let ((p1, p2, rtt), _) = async_std::task::block_on(result).factor_first();
assert!(p1 == peer1_id && p2 == peer2_id || p1 == peer2_id && p2 == peer1_id);
assert!(rtt < Duration::from_millis(50));
}
@ -105,7 +92,7 @@ fn ping() {
fn mk_transport() -> (
PeerId,
Boxed<
(PeerId, Yamux<Negotiated<SecioOutput<Negotiated<TcpTransStream>>>>),
(PeerId, StreamMuxerBox),
EitherError<EitherError<io::Error, UpgradeError<SecioError>>, UpgradeError<io::Error>>
>
) {
@ -115,8 +102,8 @@ fn mk_transport() -> (
.nodelay(true)
.upgrade(upgrade::Version::V1)
.authenticate(SecioConfig::new(id_keys))
.multiplex(yamux::Config::default())
.multiplex(libp2p_yamux::Config::default())
.map(|(peer, muxer), _| (peer, StreamMuxerBox::new(muxer)))
.boxed();
(peer_id, transport)
}

15
protocols/plaintext/Cargo.toml
View File

@ -10,11 +10,18 @@ keywords = ["peer-to-peer", "libp2p", "networking"]
categories = ["network-programming", "asynchronous"]
[dependencies]
futures = "0.1.29"
bytes = "0.5"
futures = "0.3.1"
futures_codec = "0.3.4"
libp2p-core = { version = "0.13.0", path = "../../core" }
bytes = "0.4.12"
log = "0.4.8"
void = "1.0.2"
tokio-io = "0.1.12"
protobuf = "=2.8.1" # note: see https://github.com/libp2p/rust-libp2p/issues/1363
rw-stream-sink = { version = "0.1.1", path = "../../misc/rw-stream-sink" }
unsigned-varint = { version = "0.3", features = ["futures-codec"] }
void = "1.0.2"
[dev-dependencies]
env_logger = "0.7.1"
quickcheck = "0.9.0"
rand = "0.7"
futures-timer = "2.0"

Some files were not shown because too many files have changed in this diff Show More