fluencelabs/rust-libp2p
1
0
Fork 0
mirror of https://github.com/fluencelabs/rust-libp2p synced 2025-04-25 11:02:12 +00:00
Code Issues Projects Releases Wiki Activity

Rename RawSwarm* to Network*. (#1194)

Browse Source 
* Rename RawSwarm* to Network*.

To complete the cut performed in [1].

The only remaining mention of a "swarm" in libp2p-core is in some tests
which actually depend on libp2p-swarm.

[1]: https://github.com/libp2p/rust-libp2p/pull/1188

* Post-merge corrections.
This commit is contained in:
Roman Borschel 2019-07-10 10:27:21 +02:00 committed by GitHub
parent ede114a13c
commit dfbf5b65c5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 229 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -32,7 +32,7 @@ mod tests;
pub trait NodeHandler { pub trait NodeHandler {
/// Custom event that can be received from the outside. /// Custom event that can be received from the outside.
type InEvent; type InEvent;
/// Custom event that can be produced by the handler and that will be returned by the swarm. /// Custom event that can be produced by the handler and that will be returned by the `Network`.
type OutEvent; type OutEvent;
/// Error that can happen during the processing of the node. /// Error that can happen during the processing of the node.
type Error; type Error;

6
core/src/nodes/mod.rs
View File

@ -23,7 +23,7 @@
//! Contains structs that are aiming at providing very precise control over what happens over the //! Contains structs that are aiming at providing very precise control over what happens over the
//! network. //! network.
//! //!
//! The more complete and highest-level struct is the `RawSwarm`. The `RawSwarm` directly or //! The more complete and highest-level struct is the `Network`. The `Network` directly or
//! indirectly uses all the other structs of this module. //! indirectly uses all the other structs of this module.
pub mod collection; pub mod collection;
@ -31,9 +31,9 @@ pub mod handled_node;
pub mod tasks; pub mod tasks;
pub mod listeners; pub mod listeners;
pub mod node; pub mod node;
pub mod raw_swarm; pub mod network;
pub use collection::ConnectionInfo; pub use collection::ConnectionInfo;
pub use node::Substream; pub use node::Substream;
pub use handled_node::{NodeHandlerEvent, NodeHandlerEndpoint}; pub use handled_node::{NodeHandlerEvent, NodeHandlerEndpoint};
pub use raw_swarm::{Peer, RawSwarm, RawSwarmEvent}; pub use network::{Peer, Network, NetworkEvent};

102
core/src/nodes/raw_swarm.rs → core/src/nodes/network.rs
View File

@ -56,7 +56,7 @@ pub use crate::nodes::collection::StartTakeOver;
mod tests; mod tests;
/// Implementation of `Stream` that handles the nodes. /// Implementation of `Stream` that handles the nodes.
pub struct RawSwarm<TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo = PeerId, TPeerId = PeerId> pub struct Network<TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo = PeerId, TPeerId = PeerId>
where where
TTrans: Transport, TTrans: Transport,
{ {
@ -66,7 +66,7 @@ where
/// The nodes currently active. /// The nodes currently active.
active_nodes: CollectionStream<TInEvent, TOutEvent, THandler, InternalReachErr<TTrans::Error, TConnInfo>, THandlerErr, (), (TConnInfo, ConnectedPoint), TPeerId>, active_nodes: CollectionStream<TInEvent, TOutEvent, THandler, InternalReachErr<TTrans::Error, TConnInfo>, THandlerErr, (), (TConnInfo, ConnectedPoint), TPeerId>,
/// The reach attempts of the swarm. /// The reach attempts of the network.
/// This needs to be a separate struct in order to handle multiple mutable borrows issues. /// This needs to be a separate struct in order to handle multiple mutable borrows issues.
reach_attempts: ReachAttempts<TPeerId>, reach_attempts: ReachAttempts<TPeerId>,
@ -85,7 +85,7 @@ where
} }
impl<TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId> fmt::Debug for impl<TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId> fmt::Debug for
RawSwarm<TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId> Network<TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId>
where where
TTrans: fmt::Debug + Transport, TTrans: fmt::Debug + Transport,
TConnInfo: fmt::Debug, TConnInfo: fmt::Debug,
@ -155,8 +155,8 @@ struct OutReachAttempt {
next_attempts: Vec<Multiaddr>, next_attempts: Vec<Multiaddr>,
} }
/// Event that can happen on the `RawSwarm`. /// Event that can happen on the `Network`.
pub enum RawSwarmEvent<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo = PeerId, TPeerId = PeerId> pub enum NetworkEvent<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo = PeerId, TPeerId = PeerId>
where where
TTrans: Transport, TTrans: Transport,
{ {
@ -242,7 +242,7 @@ where
multiaddr: Multiaddr, multiaddr: Multiaddr,
/// The error that happened. /// The error that happened.
error: RawSwarmReachError<TTrans::Error, TConnInfo>, error: NetworkReachError<TTrans::Error, TConnInfo>,
}, },
/// Failed to reach a peer that we were trying to dial. /// Failed to reach a peer that we were trying to dial.
@ -267,7 +267,7 @@ where
} }
impl<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId> fmt::Debug for impl<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId> fmt::Debug for
RawSwarmEvent<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId> NetworkEvent<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId>
where where
TOutEvent: fmt::Debug, TOutEvent: fmt::Debug,
TTrans: Transport, TTrans: Transport,
@ -278,28 +278,28 @@ where
{ {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
match *self { match *self {
RawSwarmEvent::NewListenerAddress { ref listen_addr } => { NetworkEvent::NewListenerAddress { ref listen_addr } => {
f.debug_struct("NewListenerAddress") f.debug_struct("NewListenerAddress")
.field("listen_addr", listen_addr) .field("listen_addr", listen_addr)
.finish() .finish()
} }
RawSwarmEvent::ExpiredListenerAddress { ref listen_addr } => { NetworkEvent::ExpiredListenerAddress { ref listen_addr } => {
f.debug_struct("ExpiredListenerAddress") f.debug_struct("ExpiredListenerAddress")
.field("listen_addr", listen_addr) .field("listen_addr", listen_addr)
.finish() .finish()
} }
RawSwarmEvent::ListenerClosed { ref result, .. } => { NetworkEvent::ListenerClosed { ref result, .. } => {
f.debug_struct("ListenerClosed") f.debug_struct("ListenerClosed")
.field("result", result) .field("result", result)
.finish() .finish()
} }
RawSwarmEvent::IncomingConnection(ref event) => { NetworkEvent::IncomingConnection(ref event) => {
f.debug_struct("IncomingConnection") f.debug_struct("IncomingConnection")
.field("listen_addr", &event.listen_addr) .field("listen_addr", &event.listen_addr)
.field("send_back_addr", &event.send_back_addr) .field("send_back_addr", &event.send_back_addr)
.finish() .finish()
} }
RawSwarmEvent::IncomingConnectionError { NetworkEvent::IncomingConnectionError {
ref listen_addr, ref listen_addr,
ref send_back_addr, ref send_back_addr,
ref error ref error
@ -310,13 +310,13 @@ where
.field("error", error) .field("error", error)
.finish() .finish()
} }
RawSwarmEvent::Connected { ref conn_info, ref endpoint } => { NetworkEvent::Connected { ref conn_info, ref endpoint } => {
f.debug_struct("Connected") f.debug_struct("Connected")
.field("conn_info", conn_info) .field("conn_info", conn_info)
.field("endpoint", endpoint) .field("endpoint", endpoint)
.finish() .finish()
} }
RawSwarmEvent::Replaced { ref new_info, ref old_info, ref closed_endpoint, ref endpoint } => { NetworkEvent::Replaced { ref new_info, ref old_info, ref closed_endpoint, ref endpoint } => {
f.debug_struct("Replaced") f.debug_struct("Replaced")
.field("new_info", new_info) .field("new_info", new_info)
.field("old_info", old_info) .field("old_info", old_info)
@ -324,14 +324,14 @@ where
.field("endpoint", endpoint) .field("endpoint", endpoint)
.finish() .finish()
} }
RawSwarmEvent::NodeClosed { ref conn_info, ref endpoint, ref error } => { NetworkEvent::NodeClosed { ref conn_info, ref endpoint, ref error } => {
f.debug_struct("NodeClosed") f.debug_struct("NodeClosed")
.field("conn_info", conn_info) .field("conn_info", conn_info)
.field("endpoint", endpoint) .field("endpoint", endpoint)
.field("error", error) .field("error", error)
.finish() .finish()
} }
RawSwarmEvent::DialError { ref new_state, ref peer_id, ref multiaddr, ref error } => { NetworkEvent::DialError { ref new_state, ref peer_id, ref multiaddr, ref error } => {
f.debug_struct("DialError") f.debug_struct("DialError")
.field("new_state", new_state) .field("new_state", new_state)
.field("peer_id", peer_id) .field("peer_id", peer_id)
@ -339,13 +339,13 @@ where
.field("error", error) .field("error", error)
.finish() .finish()
} }
RawSwarmEvent::UnknownPeerDialError { ref multiaddr, ref error, .. } => { NetworkEvent::UnknownPeerDialError { ref multiaddr, ref error, .. } => {
f.debug_struct("UnknownPeerDialError") f.debug_struct("UnknownPeerDialError")
.field("multiaddr", multiaddr) .field("multiaddr", multiaddr)
.field("error", error) .field("error", error)
.finish() .finish()
} }
RawSwarmEvent::NodeEvent { ref conn_info, ref event } => { NetworkEvent::NodeEvent { ref conn_info, ref event } => {
f.debug_struct("NodeEvent") f.debug_struct("NodeEvent")
.field("conn_info", conn_info) .field("conn_info", conn_info)
.field("event", event) .field("event", event)
@ -418,7 +418,7 @@ pub enum PeerState {
/// Error that can happen when trying to reach a node. /// Error that can happen when trying to reach a node.
#[derive(Debug)] #[derive(Debug)]
pub enum RawSwarmReachError<TTransErr, TConnInfo> { pub enum NetworkReachError<TTransErr, TConnInfo> {
/// Error in the transport layer. /// Error in the transport layer.
Transport(TransportError<TTransErr>), Transport(TransportError<TTransErr>),
@ -430,30 +430,30 @@ pub enum RawSwarmReachError<TTransErr, TConnInfo> {
} }
} }
impl<TTransErr, TConnInfo> fmt::Display for RawSwarmReachError<TTransErr, TConnInfo> impl<TTransErr, TConnInfo> fmt::Display for NetworkReachError<TTransErr, TConnInfo>
where where
TTransErr: fmt::Display, TTransErr: fmt::Display,
TConnInfo: fmt::Debug, TConnInfo: fmt::Debug,
{ {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self { match self {
RawSwarmReachError::Transport(err) => write!(f, "{}", err), NetworkReachError::Transport(err) => write!(f, "{}", err),
RawSwarmReachError::PeerIdMismatch { obtained } => { NetworkReachError::PeerIdMismatch { obtained } => {
write!(f, "Peer ID mismatch, obtained: {:?}", obtained) write!(f, "Peer ID mismatch, obtained: {:?}", obtained)
}, },
} }
} }
} }
impl<TTransErr, TConnInfo> error::Error for RawSwarmReachError<TTransErr, TConnInfo> impl<TTransErr, TConnInfo> error::Error for NetworkReachError<TTransErr, TConnInfo>
where where
TTransErr: error::Error + 'static, TTransErr: error::Error + 'static,
TConnInfo: fmt::Debug, TConnInfo: fmt::Debug,
{ {
fn source(&self) -> Option<&(dyn error::Error + 'static)> { fn source(&self) -> Option<&(dyn error::Error + 'static)> {
match self { match self {
RawSwarmReachError::Transport(err) => Some(err), NetworkReachError::Transport(err) => Some(err),
RawSwarmReachError::PeerIdMismatch { .. } => None, NetworkReachError::PeerIdMismatch { .. } => None,
} }
} }
} }
@ -544,9 +544,9 @@ where TTrans: Transport
listen_addr: Multiaddr, listen_addr: Multiaddr,
/// Address used to send back data to the remote. /// Address used to send back data to the remote.
send_back_addr: Multiaddr, send_back_addr: Multiaddr,
/// Reference to the `active_nodes` field of the swarm. /// Reference to the `active_nodes` field of the `Network`.
active_nodes: &'a mut CollectionStream<TInEvent, TOutEvent, THandler, InternalReachErr<TTrans::Error, TConnInfo>, THandlerErr, (), (TConnInfo, ConnectedPoint), TPeerId>, active_nodes: &'a mut CollectionStream<TInEvent, TOutEvent, THandler, InternalReachErr<TTrans::Error, TConnInfo>, THandlerErr, (), (TConnInfo, ConnectedPoint), TPeerId>,
/// Reference to the `other_reach_attempts` field of the swarm. /// Reference to the `other_reach_attempts` field of the `Network`.
other_reach_attempts: &'a mut Vec<(ReachAttemptId, ConnectedPoint)>, other_reach_attempts: &'a mut Vec<(ReachAttemptId, ConnectedPoint)>,
} }
@ -648,7 +648,7 @@ impl<'a> IncomingInfo<'a> {
} }
impl<TTrans, TInEvent, TOutEvent, TMuxer, THandler, THandlerErr, TConnInfo, TPeerId> impl<TTrans, TInEvent, TOutEvent, TMuxer, THandler, THandlerErr, TConnInfo, TPeerId>
RawSwarm<TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId> Network<TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId>
where where
TTrans: Transport + Clone, TTrans: Transport + Clone,
TMuxer: StreamMuxer, TMuxer: StreamMuxer,
@ -662,7 +662,7 @@ where
/// Creates a new node events stream. /// Creates a new node events stream.
pub fn new(transport: TTrans, local_peer_id: TPeerId) -> Self { pub fn new(transport: TTrans, local_peer_id: TPeerId) -> Self {
// TODO: with_capacity? // TODO: with_capacity?
RawSwarm { Network {
listeners: ListenersStream::new(transport), listeners: ListenersStream::new(transport),
active_nodes: CollectionStream::new(), active_nodes: CollectionStream::new(),
reach_attempts: ReachAttempts { reach_attempts: ReachAttempts {
@ -680,7 +680,7 @@ where
pub fn new_with_incoming_limit(transport: TTrans, pub fn new_with_incoming_limit(transport: TTrans,
local_peer_id: TPeerId, incoming_limit: Option<u32>) -> Self local_peer_id: TPeerId, incoming_limit: Option<u32>) -> Self
{ {
RawSwarm { Network {
incoming_limit, incoming_limit,
listeners: ListenersStream::new(transport), listeners: ListenersStream::new(transport),
active_nodes: CollectionStream::new(), active_nodes: CollectionStream::new(),
@ -942,7 +942,7 @@ where
} }
/// Provides an API similar to `Stream`, except that it cannot error. /// Provides an API similar to `Stream`, except that it cannot error.
pub fn poll(&mut self) -> Async<RawSwarmEvent<'_, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId>> pub fn poll(&mut self) -> Async<NetworkEvent<'_, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId>>
where where
TTrans: Transport<Output = (TConnInfo, TMuxer)>, TTrans: Transport<Output = (TConnInfo, TMuxer)>,
TTrans::Error: Send + 'static, TTrans::Error: Send + 'static,
@ -977,16 +977,16 @@ where
active_nodes: &mut self.active_nodes, active_nodes: &mut self.active_nodes,
other_reach_attempts: &mut self.reach_attempts.other_reach_attempts, other_reach_attempts: &mut self.reach_attempts.other_reach_attempts,
}; };
return Async::Ready(RawSwarmEvent::IncomingConnection(event)); return Async::Ready(NetworkEvent::IncomingConnection(event));
} }
Async::Ready(ListenersEvent::NewAddress { listen_addr }) => { Async::Ready(ListenersEvent::NewAddress { listen_addr }) => {
return Async::Ready(RawSwarmEvent::NewListenerAddress { listen_addr }) return Async::Ready(NetworkEvent::NewListenerAddress { listen_addr })
} }
Async::Ready(ListenersEvent::AddressExpired { listen_addr }) => { Async::Ready(ListenersEvent::AddressExpired { listen_addr }) => {
return Async::Ready(RawSwarmEvent::ExpiredListenerAddress { listen_addr }) return Async::Ready(NetworkEvent::ExpiredListenerAddress { listen_addr })
} }
Async::Ready(ListenersEvent::Closed { listener, result }) => { Async::Ready(ListenersEvent::Closed { listener, result }) => {
return Async::Ready(RawSwarmEvent::ListenerClosed { listener, result }) return Async::Ready(NetworkEvent::ListenerClosed { listener, result })
} }
} }
} }
@ -1036,7 +1036,7 @@ where
closed message after it has been opened, and no two closed \ closed message after it has been opened, and no two closed \
messages; QED"); messages; QED");
action = Default::default(); action = Default::default();
out_event = RawSwarmEvent::NodeClosed { out_event = NetworkEvent::NodeClosed {
conn_info: conn_info.0, conn_info: conn_info.0,
endpoint, endpoint,
error, error,
@ -1044,7 +1044,7 @@ where
} }
Async::Ready(CollectionEvent::NodeEvent { peer, event }) => { Async::Ready(CollectionEvent::NodeEvent { peer, event }) => {
action = Default::default(); action = Default::default();
out_event = RawSwarmEvent::NodeEvent { conn_info: peer.info().0.clone(), event }; out_event = NetworkEvent::NodeEvent { conn_info: peer.info().0.clone(), event };
} }
} }
@ -1077,7 +1077,7 @@ where
} }
} }
/// Internal struct indicating an action to perform of the swarm. /// Internal struct indicating an action to perform on the network.
#[derive(Debug)] #[derive(Debug)]
#[must_use] #[must_use]
struct ActionItem<THandler, TPeerId> { struct ActionItem<THandler, TPeerId> {
@ -1105,7 +1105,7 @@ impl<THandler, TPeerId> Default for ActionItem<THandler, TPeerId> {
fn handle_node_reached<'a, TTrans, TMuxer, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId>( fn handle_node_reached<'a, TTrans, TMuxer, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId>(
reach_attempts: &mut ReachAttempts<TPeerId>, reach_attempts: &mut ReachAttempts<TPeerId>,
event: CollectionReachEvent<'_, TInEvent, TOutEvent, THandler, InternalReachErr<TTrans::Error, TConnInfo>, THandlerErr, (), (TConnInfo, ConnectedPoint), TPeerId>, event: CollectionReachEvent<'_, TInEvent, TOutEvent, THandler, InternalReachErr<TTrans::Error, TConnInfo>, THandlerErr, (), (TConnInfo, ConnectedPoint), TPeerId>,
) -> (ActionItem<THandler, TPeerId>, RawSwarmEvent<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId>) ) -> (ActionItem<THandler, TPeerId>, NetworkEvent<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId>)
where where
TTrans: Transport<Output = (TConnInfo, TMuxer)> + Clone, TTrans: Transport<Output = (TConnInfo, TMuxer)> + Clone,
TMuxer: StreamMuxer + Send + Sync + 'static, TMuxer: StreamMuxer + Send + Sync + 'static,
@ -1131,7 +1131,7 @@ where
if event.would_replace() && has_dial_prio { if event.would_replace() && has_dial_prio {
if let Some(ConnectedPoint::Dialer { .. }) = reach_attempts.connected_points.get(event.peer_id()) { if let Some(ConnectedPoint::Dialer { .. }) = reach_attempts.connected_points.get(event.peer_id()) {
if let ConnectedPoint::Listener { listen_addr, send_back_addr } = opened_endpoint { if let ConnectedPoint::Listener { listen_addr, send_back_addr } = opened_endpoint {
return (Default::default(), RawSwarmEvent::IncomingConnectionError { return (Default::default(), NetworkEvent::IncomingConnectionError {
listen_addr, listen_addr,
send_back_addr, send_back_addr,
error: IncomingError::DeniedLowerPriority, error: IncomingError::DeniedLowerPriority,
@ -1172,14 +1172,14 @@ where
remove only when a connection is closed; the underlying API is \ remove only when a connection is closed; the underlying API is \
guaranteed to always deliver a connection closed message after it has \ guaranteed to always deliver a connection closed message after it has \
been opened, and no two closed messages; QED"); been opened, and no two closed messages; QED");
return (action, RawSwarmEvent::Replaced { return (action, NetworkEvent::Replaced {
new_info: conn_info.0, new_info: conn_info.0,
old_info: old_info.0, old_info: old_info.0,
endpoint: opened_endpoint, endpoint: opened_endpoint,
closed_endpoint, closed_endpoint,
}); });
} else { } else {
return (action, RawSwarmEvent::Connected { return (action, NetworkEvent::Connected {
conn_info: conn_info.0, conn_info: conn_info.0,
endpoint: opened_endpoint endpoint: opened_endpoint
}); });
@ -1214,7 +1214,7 @@ where
remove only when a connection is closed; the underlying API is guaranteed \ remove only when a connection is closed; the underlying API is guaranteed \
to always deliver a connection closed message after it has been opened, \ to always deliver a connection closed message after it has been opened, \
and no two closed messages; QED"); and no two closed messages; QED");
return (Default::default(), RawSwarmEvent::Replaced { return (Default::default(), NetworkEvent::Replaced {
new_info: conn_info.0, new_info: conn_info.0,
old_info: old_info.0, old_info: old_info.0,
endpoint: opened_endpoint, endpoint: opened_endpoint,
@ -1222,7 +1222,7 @@ where
}); });
} else { } else {
return (Default::default(), RawSwarmEvent::Connected { return (Default::default(), NetworkEvent::Connected {
conn_info: conn_info.0, conn_info: conn_info.0,
endpoint: opened_endpoint endpoint: opened_endpoint
}); });
@ -1260,7 +1260,7 @@ fn handle_reach_error<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TC
reach_id: ReachAttemptId, reach_id: ReachAttemptId,
error: InternalReachErr<TTrans::Error, TConnInfo>, error: InternalReachErr<TTrans::Error, TConnInfo>,
handler: THandler, handler: THandler,
) -> (ActionItem<THandler, TPeerId>, RawSwarmEvent<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId>) ) -> (ActionItem<THandler, TPeerId>, NetworkEvent<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId>)
where where
TTrans: Transport, TTrans: Transport,
TConnInfo: ConnectionInfo<PeerId = TPeerId> + Send + 'static, TConnInfo: ConnectionInfo<PeerId = TPeerId> + Send + 'static,
@ -1303,9 +1303,9 @@ where
}; };
let error = match error { let error = match error {
InternalReachErr::Transport(err) => RawSwarmReachError::Transport(err), InternalReachErr::Transport(err) => NetworkReachError::Transport(err),
InternalReachErr::PeerIdMismatch { obtained } => { InternalReachErr::PeerIdMismatch { obtained } => {
RawSwarmReachError::PeerIdMismatch { obtained } NetworkReachError::PeerIdMismatch { obtained }
}, },
InternalReachErr::FoundLocalPeerId => { InternalReachErr::FoundLocalPeerId => {
unreachable!("We only generate FoundLocalPeerId within dial() or accept(); neither \ unreachable!("We only generate FoundLocalPeerId within dial() or accept(); neither \
@ -1313,7 +1313,7 @@ where
}, },
}; };
return (action, RawSwarmEvent::DialError { return (action, NetworkEvent::DialError {
new_state, new_state,
peer_id, peer_id,
multiaddr: failed_addr, multiaddr: failed_addr,
@ -1338,7 +1338,7 @@ where
which doesn't add any entry in other_reach_attempts; QED") which doesn't add any entry in other_reach_attempts; QED")
}, },
}; };
return (Default::default(), RawSwarmEvent::UnknownPeerDialError { return (Default::default(), NetworkEvent::UnknownPeerDialError {
multiaddr: address, multiaddr: address,
error, error,
handler, handler,
@ -1353,7 +1353,7 @@ where
which doesn't add any entry in other_reach_attempts; QED") which doesn't add any entry in other_reach_attempts; QED")
}, },
}; };
return (Default::default(), RawSwarmEvent::IncomingConnectionError { return (Default::default(), NetworkEvent::IncomingConnectionError {
listen_addr, listen_addr,
send_back_addr, send_back_addr,
error error
@ -1693,7 +1693,7 @@ where
TTrans: Transport, TTrans: Transport,
{ {
peer_id: TPeerId, peer_id: TPeerId,
nodes: &'a mut RawSwarm<TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId>, nodes: &'a mut Network<TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId>,
} }
impl<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId> fmt::Debug for impl<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo, TPeerId> fmt::Debug for

206
core/src/nodes/raw_swarm/tests.rs → core/src/nodes/network/tests.rs
View File

@ -36,45 +36,45 @@ use tokio::runtime::{Builder, Runtime};
fn query_transport() { fn query_transport() {
let transport = DummyTransport::new(); let transport = DummyTransport::new();
let transport2 = transport.clone(); let transport2 = transport.clone();
let raw_swarm = RawSwarm::<_, _, _, Handler, _>::new(transport, PeerId::random()); let network = Network::<_, _, _, Handler, _>::new(transport, PeerId::random());
assert_eq!(raw_swarm.transport(), &transport2); assert_eq!(network.transport(), &transport2);
} }
#[test] #[test]
fn local_node_peer() { fn local_node_peer() {
let peer_id = PeerId::random(); let peer_id = PeerId::random();
let mut raw_swarm = RawSwarm::<_, _, _, Handler, _>::new(DummyTransport::new(), peer_id.clone()); let mut network = Network::<_, _, _, Handler, _>::new(DummyTransport::new(), peer_id.clone());
assert_matches!(raw_swarm.peer(peer_id), Peer::LocalNode); assert_matches!(network.peer(peer_id), Peer::LocalNode);
} }
#[test] #[test]
fn successful_dial_reaches_a_node() { fn successful_dial_reaches_a_node() {
let mut swarm = RawSwarm::<_, _, _, Handler, _>::new(DummyTransport::new(), PeerId::random()); 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 addr = "/ip4/127.0.0.1/tcp/1234".parse::<Multiaddr>().expect("bad multiaddr");
let dial_res = swarm.dial(addr, Handler::default()); let dial_res = network.dial(addr, Handler::default());
assert!(dial_res.is_ok()); assert!(dial_res.is_ok());
// Poll the swarm until we get a `NodeReached` then assert on the peer: // Poll the network until we get a `NodeReached` then assert on the peer:
// it's there and it's connected. // it's there and it's connected.
let swarm = Arc::new(Mutex::new(swarm)); let network = Arc::new(Mutex::new(network));
let mut rt = Runtime::new().unwrap(); let mut rt = Runtime::new().unwrap();
let mut peer_id : Option<PeerId> = None; let mut peer_id : Option<PeerId> = None;
// Drive forward until we're Connected // Drive forward until we're Connected
while peer_id.is_none() { while peer_id.is_none() {
let swarm_fut = swarm.clone(); let network_fut = network.clone();
peer_id = rt.block_on(future::poll_fn(move || -> Poll<Option<PeerId>, ()> { peer_id = rt.block_on(future::poll_fn(move || -> Poll<Option<PeerId>, ()> {
let mut swarm = swarm_fut.lock(); let mut network = network_fut.lock();
let poll_res = swarm.poll(); let poll_res = network.poll();
match poll_res { match poll_res {
Async::Ready(RawSwarmEvent::Connected { conn_info, .. }) => Ok(Async::Ready(Some(conn_info))), Async::Ready(NetworkEvent::Connected { conn_info, .. }) => Ok(Async::Ready(Some(conn_info))),
_ => Ok(Async::Ready(None)) _ => Ok(Async::Ready(None))
} }
})).expect("tokio works"); })).expect("tokio works");
} }
let mut swarm = swarm.lock(); let mut network = network.lock();
let peer = swarm.peer(peer_id.unwrap()); let peer = network.peer(peer_id.unwrap());
assert_matches!(peer, Peer::Connected(PeerConnected{..})); assert_matches!(peer, Peer::Connected(PeerConnected{..}));
} }
@ -94,46 +94,46 @@ fn num_incoming_negotiated() {
]; ];
transport.set_initial_listener_state(ListenerState::Events(events)); transport.set_initial_listener_state(ListenerState::Events(events));
let mut swarm = RawSwarm::<_, _, _, Handler, _>::new(transport, PeerId::random()); let mut network = Network::<_, _, _, Handler, _>::new(transport, PeerId::random());
swarm.listen_on("/memory/0".parse().unwrap()).unwrap(); network.listen_on("/memory/0".parse().unwrap()).unwrap();
// no incoming yet // no incoming yet
assert_eq!(swarm.incoming_negotiated().count(), 0); assert_eq!(network.incoming_negotiated().count(), 0);
let mut rt = Runtime::new().unwrap(); let mut rt = Runtime::new().unwrap();
let swarm = Arc::new(Mutex::new(swarm)); let network = Arc::new(Mutex::new(network));
let swarm_fut = swarm.clone(); let network_fut = network.clone();
let fut = future::poll_fn(move || -> Poll<_, ()> { let fut = future::poll_fn(move || -> Poll<_, ()> {
let mut swarm_fut = swarm_fut.lock(); let mut network_fut = network_fut.lock();
assert_matches!(swarm_fut.poll(), Async::Ready(RawSwarmEvent::NewListenerAddress {..})); assert_matches!(network_fut.poll(), Async::Ready(NetworkEvent::NewListenerAddress {..}));
assert_matches!(swarm_fut.poll(), Async::Ready(RawSwarmEvent::IncomingConnection(incoming)) => { assert_matches!(network_fut.poll(), Async::Ready(NetworkEvent::IncomingConnection(incoming)) => {
incoming.accept(Handler::default()); incoming.accept(Handler::default());
}); });
Ok(Async::Ready(())) Ok(Async::Ready(()))
}); });
rt.block_on(fut).expect("tokio works"); rt.block_on(fut).expect("tokio works");
let swarm = swarm.lock(); let network = network.lock();
// Now there's an incoming connection // Now there's an incoming connection
assert_eq!(swarm.incoming_negotiated().count(), 1); assert_eq!(network.incoming_negotiated().count(), 1);
} }
#[test] #[test]
fn broadcasted_events_reach_active_nodes() { fn broadcasted_events_reach_active_nodes() {
let mut swarm = RawSwarm::<_, _, _, Handler, _>::new(DummyTransport::new(), PeerId::random()); let mut network = Network::<_, _, _, Handler, _>::new(DummyTransport::new(), PeerId::random());
let mut muxer = DummyMuxer::new(); let mut muxer = DummyMuxer::new();
muxer.set_inbound_connection_state(DummyConnectionState::Pending); muxer.set_inbound_connection_state(DummyConnectionState::Pending);
muxer.set_outbound_connection_state(DummyConnectionState::Opened); muxer.set_outbound_connection_state(DummyConnectionState::Opened);
let addr = "/ip4/127.0.0.1/tcp/1234".parse::<Multiaddr>().expect("bad multiaddr"); let addr = "/ip4/127.0.0.1/tcp/1234".parse::<Multiaddr>().expect("bad multiaddr");
let mut handler = Handler::default(); let mut handler = Handler::default();
handler.next_states = vec![HandlerState::Ready(NodeHandlerEvent::Custom(OutEvent::Custom("from handler 1") )),]; handler.next_states = vec![HandlerState::Ready(NodeHandlerEvent::Custom(OutEvent::Custom("from handler 1") )),];
let dial_result = swarm.dial(addr, handler); let dial_result = network.dial(addr, handler);
assert!(dial_result.is_ok()); assert!(dial_result.is_ok());
let swarm = Arc::new(Mutex::new(swarm)); let network = Arc::new(Mutex::new(network));
let mut rt = Runtime::new().unwrap(); let mut rt = Runtime::new().unwrap();
let swarm2 = swarm.clone(); let network2 = network.clone();
rt.block_on(future::poll_fn(move || { rt.block_on(future::poll_fn(move || {
if swarm2.lock().start_broadcast(&InEvent::NextState).is_not_ready() { if network2.lock().start_broadcast(&InEvent::NextState).is_not_ready() {
Ok::<_, ()>(Async::NotReady) Ok::<_, ()>(Async::NotReady)
} else { } else {
Ok(Async::Ready(())) Ok(Async::Ready(()))
@ -141,15 +141,15 @@ fn broadcasted_events_reach_active_nodes() {
})).unwrap(); })).unwrap();
let mut peer_id : Option<PeerId> = None; let mut peer_id : Option<PeerId> = None;
while peer_id.is_none() { while peer_id.is_none() {
let swarm_fut = swarm.clone(); let network_fut = network.clone();
peer_id = rt.block_on(future::poll_fn(move || -> Poll<Option<PeerId>, ()> { peer_id = rt.block_on(future::poll_fn(move || -> Poll<Option<PeerId>, ()> {
let mut swarm = swarm_fut.lock(); let mut network = network_fut.lock();
if swarm.complete_broadcast().is_not_ready() { if network.complete_broadcast().is_not_ready() {
return Ok(Async::NotReady) return Ok(Async::NotReady)
} }
let poll_res = swarm.poll(); let poll_res = network.poll();
match poll_res { match poll_res {
Async::Ready(RawSwarmEvent::Connected { conn_info, .. }) => Ok(Async::Ready(Some(conn_info))), Async::Ready(NetworkEvent::Connected { conn_info, .. }) => Ok(Async::Ready(Some(conn_info))),
_ => Ok(Async::Ready(None)) _ => Ok(Async::Ready(None))
} }
})).expect("tokio works"); })).expect("tokio works");
@ -157,12 +157,12 @@ fn broadcasted_events_reach_active_nodes() {
let mut keep_polling = true; let mut keep_polling = true;
while keep_polling { while keep_polling {
let swarm_fut = swarm.clone(); let network_fut = network.clone();
keep_polling = rt.block_on(future::poll_fn(move || -> Poll<_, ()> { keep_polling = rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut swarm = swarm_fut.lock(); let mut network = network_fut.lock();
match swarm.poll() { match network.poll() {
Async::Ready(event) => { Async::Ready(event) => {
assert_matches!(event, RawSwarmEvent::NodeEvent { conn_info: _, event: inner_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 // 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")); assert_matches!(inner_event, OutEvent::Custom("from handler 1"));
}); });
@ -176,9 +176,9 @@ fn broadcasted_events_reach_active_nodes() {
#[test] #[test]
fn querying_for_pending_peer() { fn querying_for_pending_peer() {
let mut swarm = RawSwarm::<_, _, _, Handler, _>::new(DummyTransport::new(), PeerId::random()); let mut network = Network::<_, _, _, Handler, _>::new(DummyTransport::new(), PeerId::random());
let peer_id = PeerId::random(); let peer_id = PeerId::random();
let peer = swarm.peer(peer_id.clone()); let peer = network.peer(peer_id.clone());
assert_matches!(peer, Peer::NotConnected(PeerNotConnected{ .. })); assert_matches!(peer, Peer::NotConnected(PeerNotConnected{ .. }));
let addr = "/memory/0".parse().expect("bad multiaddr"); let addr = "/memory/0".parse().expect("bad multiaddr");
let pending_peer = peer.into_not_connected().unwrap().connect(addr, Handler::default()); let pending_peer = peer.into_not_connected().unwrap().connect(addr, Handler::default());
@ -187,9 +187,9 @@ fn querying_for_pending_peer() {
#[test] #[test]
fn querying_for_unknown_peer() { fn querying_for_unknown_peer() {
let mut swarm = RawSwarm::<_, _, _, Handler, _>::new(DummyTransport::new(), PeerId::random()); let mut network = Network::<_, _, _, Handler, _>::new(DummyTransport::new(), PeerId::random());
let peer_id = PeerId::random(); let peer_id = PeerId::random();
let peer = swarm.peer(peer_id.clone()); let peer = network.peer(peer_id.clone());
assert_matches!(peer, Peer::NotConnected( PeerNotConnected { nodes: _, peer_id: node_peer_id }) => { assert_matches!(peer, Peer::NotConnected( PeerNotConnected { nodes: _, peer_id: node_peer_id }) => {
assert_eq!(node_peer_id, peer_id); assert_eq!(node_peer_id, peer_id);
}); });
@ -197,31 +197,31 @@ fn querying_for_unknown_peer() {
#[test] #[test]
fn querying_for_connected_peer() { fn querying_for_connected_peer() {
let mut swarm = RawSwarm::<_, _, _, Handler, _>::new(DummyTransport::new(), PeerId::random()); let mut network = Network::<_, _, _, Handler, _>::new(DummyTransport::new(), PeerId::random());
// Dial a node // Dial a node
let addr = "/ip4/127.0.0.1/tcp/1234".parse().expect("bad multiaddr"); let addr = "/ip4/127.0.0.1/tcp/1234".parse().expect("bad multiaddr");
swarm.dial(addr, Handler::default()).expect("dialing works"); network.dial(addr, Handler::default()).expect("dialing works");
let swarm = Arc::new(Mutex::new(swarm)); let network = Arc::new(Mutex::new(network));
let mut rt = Runtime::new().unwrap(); let mut rt = Runtime::new().unwrap();
// Drive it forward until we connect; extract the new PeerId. // Drive it forward until we connect; extract the new PeerId.
let mut peer_id : Option<PeerId> = None; let mut peer_id : Option<PeerId> = None;
while peer_id.is_none() { while peer_id.is_none() {
let swarm_fut = swarm.clone(); let network_fut = network.clone();
peer_id = rt.block_on(future::poll_fn(move || -> Poll<Option<PeerId>, ()> { peer_id = rt.block_on(future::poll_fn(move || -> Poll<Option<PeerId>, ()> {
let mut swarm = swarm_fut.lock(); let mut network = network_fut.lock();
let poll_res = swarm.poll(); let poll_res = network.poll();
match poll_res { match poll_res {
Async::Ready(RawSwarmEvent::Connected { conn_info, .. }) => Ok(Async::Ready(Some(conn_info))), Async::Ready(NetworkEvent::Connected { conn_info, .. }) => Ok(Async::Ready(Some(conn_info))),
_ => Ok(Async::Ready(None)) _ => Ok(Async::Ready(None))
} }
})).expect("tokio works"); })).expect("tokio works");
} }
// We're connected. // We're connected.
let mut swarm = swarm.lock(); let mut network = network.lock();
let peer = swarm.peer(peer_id.unwrap()); let peer = network.peer(peer_id.unwrap());
assert_matches!(peer, Peer::Connected( PeerConnected { .. } )); assert_matches!(peer, Peer::Connected( PeerConnected { .. } ));
} }
@ -231,16 +231,16 @@ fn poll_with_closed_listener() {
// Set up listener to be closed // Set up listener to be closed
transport.set_initial_listener_state(ListenerState::Ok(Async::Ready(None))); transport.set_initial_listener_state(ListenerState::Ok(Async::Ready(None)));
let mut swarm = RawSwarm::<_, _, _, Handler, _>::new(transport, PeerId::random()); let mut network = Network::<_, _, _, Handler, _>::new(transport, PeerId::random());
swarm.listen_on("/memory/0".parse().unwrap()).unwrap(); network.listen_on("/memory/0".parse().unwrap()).unwrap();
let mut rt = Runtime::new().unwrap(); let mut rt = Runtime::new().unwrap();
let swarm = Arc::new(Mutex::new(swarm)); let network = Arc::new(Mutex::new(network));
let swarm_fut = swarm.clone(); let network_fut = network.clone();
let fut = future::poll_fn(move || -> Poll<_, ()> { let fut = future::poll_fn(move || -> Poll<_, ()> {
let mut swarm = swarm_fut.lock(); let mut network = network_fut.lock();
assert_matches!(swarm.poll(), Async::Ready(RawSwarmEvent::ListenerClosed { .. } )); assert_matches!(network.poll(), Async::Ready(NetworkEvent::ListenerClosed { .. } ));
Ok(Async::Ready(())) Ok(Async::Ready(()))
}); });
rt.block_on(fut).expect("tokio works"); rt.block_on(fut).expect("tokio works");
@ -250,24 +250,24 @@ fn poll_with_closed_listener() {
fn unknown_peer_that_is_unreachable_yields_unknown_peer_dial_error() { fn unknown_peer_that_is_unreachable_yields_unknown_peer_dial_error() {
let mut transport = DummyTransport::new(); let mut transport = DummyTransport::new();
transport.make_dial_fail(); transport.make_dial_fail();
let mut swarm = RawSwarm::<_, _, _, Handler, _>::new(transport, PeerId::random()); let mut network = Network::<_, _, _, Handler, _>::new(transport, PeerId::random());
let addr = "/memory/0".parse::<Multiaddr>().expect("bad multiaddr"); let addr = "/memory/0".parse::<Multiaddr>().expect("bad multiaddr");
let handler = Handler::default(); let handler = Handler::default();
let dial_result = swarm.dial(addr, handler); let dial_result = network.dial(addr, handler);
assert!(dial_result.is_ok()); assert!(dial_result.is_ok());
let swarm = Arc::new(Mutex::new(swarm)); let network = Arc::new(Mutex::new(network));
let mut rt = Runtime::new().unwrap(); let mut rt = Runtime::new().unwrap();
// Drive it forward until we hear back from the node. // Drive it forward until we hear back from the node.
let mut keep_polling = true; let mut keep_polling = true;
while keep_polling { while keep_polling {
let swarm_fut = swarm.clone(); let network_fut = network.clone();
keep_polling = rt.block_on(future::poll_fn(move || -> Poll<_, ()> { keep_polling = rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut swarm = swarm_fut.lock(); let mut network = network_fut.lock();
match swarm.poll() { match network.poll() {
Async::NotReady => Ok(Async::Ready(true)), Async::NotReady => Ok(Async::Ready(true)),
Async::Ready(event) => { Async::Ready(event) => {
assert_matches!(event, RawSwarmEvent::UnknownPeerDialError { .. } ); assert_matches!(event, NetworkEvent::UnknownPeerDialError { .. } );
Ok(Async::Ready(false)) Ok(Async::Ready(false))
}, },
} }
@ -281,12 +281,12 @@ fn known_peer_that_is_unreachable_yields_dial_error() {
let peer_id = PeerId::random(); let peer_id = PeerId::random();
transport.set_next_peer_id(&peer_id); transport.set_next_peer_id(&peer_id);
transport.make_dial_fail(); transport.make_dial_fail();
let swarm = Arc::new(Mutex::new(RawSwarm::<_, _, _, Handler, _>::new(transport, PeerId::random()))); let network = Arc::new(Mutex::new(Network::<_, _, _, Handler, _>::new(transport, PeerId::random())));
{ {
let swarm1 = swarm.clone(); let network1 = network.clone();
let mut swarm1 = swarm1.lock(); let mut network1 = network1.lock();
let peer = swarm1.peer(peer_id.clone()); let peer = network1.peer(peer_id.clone());
assert_matches!(peer, Peer::NotConnected(PeerNotConnected{ .. })); assert_matches!(peer, Peer::NotConnected(PeerNotConnected{ .. }));
let addr = "/memory/0".parse::<Multiaddr>().expect("bad multiaddr"); let addr = "/memory/0".parse::<Multiaddr>().expect("bad multiaddr");
let pending_peer = peer.into_not_connected().unwrap().connect(addr, Handler::default()); let pending_peer = peer.into_not_connected().unwrap().connect(addr, Handler::default());
@ -296,16 +296,16 @@ fn known_peer_that_is_unreachable_yields_dial_error() {
// Drive it forward until we hear back from the node. // Drive it forward until we hear back from the node.
let mut keep_polling = true; let mut keep_polling = true;
while keep_polling { while keep_polling {
let swarm_fut = swarm.clone(); let network_fut = network.clone();
let peer_id = peer_id.clone(); let peer_id = peer_id.clone();
keep_polling = rt.block_on(future::poll_fn(move || -> Poll<_, ()> { keep_polling = rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut swarm = swarm_fut.lock(); let mut network = network_fut.lock();
match swarm.poll() { match network.poll() {
Async::NotReady => Ok(Async::Ready(true)), Async::NotReady => Ok(Async::Ready(true)),
Async::Ready(event) => { Async::Ready(event) => {
let failed_peer_id = assert_matches!( let failed_peer_id = assert_matches!(
event, event,
RawSwarmEvent::DialError { new_state: _, peer_id: failed_peer_id, .. } => failed_peer_id NetworkEvent::DialError { new_state: _, peer_id: failed_peer_id, .. } => failed_peer_id
); );
assert_eq!(peer_id, failed_peer_id); assert_eq!(peer_id, failed_peer_id);
Ok(Async::Ready(false)) Ok(Async::Ready(false))
@ -320,13 +320,13 @@ fn yields_node_error_when_there_is_an_error_after_successful_connect() {
let mut transport = DummyTransport::new(); let mut transport = DummyTransport::new();
let peer_id = PeerId::random(); let peer_id = PeerId::random();
transport.set_next_peer_id(&peer_id); transport.set_next_peer_id(&peer_id);
let swarm = Arc::new(Mutex::new(RawSwarm::<_, _, _, Handler, _>::new(transport, PeerId::random()))); let network = Arc::new(Mutex::new(Network::<_, _, _, Handler, _>::new(transport, PeerId::random())));
{ {
// Set up an outgoing connection with a PeerId we know // Set up an outgoing connection with a PeerId we know
let swarm1 = swarm.clone(); let network1 = network.clone();
let mut swarm1 = swarm1.lock(); let mut network1 = network1.lock();
let peer = swarm1.peer(peer_id.clone()); let peer = network1.peer(peer_id.clone());
let addr = "/unix/reachable".parse().expect("bad multiaddr"); let addr = "/unix/reachable".parse().expect("bad multiaddr");
let mut handler = Handler::default(); let mut handler = Handler::default();
// Force an error // Force an error
@ -340,25 +340,25 @@ fn yields_node_error_when_there_is_an_error_after_successful_connect() {
// Drive it forward until we connect to the node. // Drive it forward until we connect to the node.
let mut keep_polling = true; let mut keep_polling = true;
while keep_polling { while keep_polling {
let swarm_fut = swarm.clone(); let network_fut = network.clone();
let swarm2 = swarm.clone(); let network2 = network.clone();
rt.block_on(future::poll_fn(move || { rt.block_on(future::poll_fn(move || {
if swarm2.lock().start_broadcast(&InEvent::NextState).is_not_ready() { if network2.lock().start_broadcast(&InEvent::NextState).is_not_ready() {
Ok::<_, ()>(Async::NotReady) Ok::<_, ()>(Async::NotReady)
} else { } else {
Ok(Async::Ready(())) Ok(Async::Ready(()))
} }
})).unwrap(); })).unwrap();
keep_polling = rt.block_on(future::poll_fn(move || -> Poll<_, ()> { keep_polling = rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut swarm = swarm_fut.lock(); let mut network = network_fut.lock();
// Push the Handler into an error state on the next poll // Push the Handler into an error state on the next poll
if swarm.complete_broadcast().is_not_ready() { if network.complete_broadcast().is_not_ready() {
return Ok(Async::NotReady) return Ok(Async::NotReady)
} }
match swarm.poll() { match network.poll() {
Async::NotReady => Ok(Async::Ready(true)), Async::NotReady => Ok(Async::Ready(true)),
Async::Ready(event) => { Async::Ready(event) => {
assert_matches!(event, RawSwarmEvent::Connected { .. }); assert_matches!(event, NetworkEvent::Connected { .. });
// We're connected, we can move on // We're connected, we can move on
Ok(Async::Ready(false)) Ok(Async::Ready(false))
}, },
@ -368,11 +368,11 @@ fn yields_node_error_when_there_is_an_error_after_successful_connect() {
// Poll again. It is going to be a NodeClosed because of how the // Poll again. It is going to be a NodeClosed because of how the
// handler's next state was set up. // handler's next state was set up.
let swarm_fut = swarm.clone(); let network_fut = network.clone();
let expected_peer_id = peer_id.clone(); let expected_peer_id = peer_id.clone();
rt.block_on(future::poll_fn(move || -> Poll<_, ()> { rt.block_on(future::poll_fn(move || -> Poll<_, ()> {
let mut swarm = swarm_fut.lock(); let mut network = network_fut.lock();
assert_matches!(swarm.poll(), Async::Ready(RawSwarmEvent::NodeClosed { conn_info, .. }) => { assert_matches!(network.poll(), Async::Ready(NetworkEvent::NodeClosed { conn_info, .. }) => {
assert_eq!(conn_info, expected_peer_id); assert_eq!(conn_info, expected_peer_id);
}); });
Ok(Async::Ready(())) Ok(Async::Ready(()))
@ -405,32 +405,32 @@ fn limit_incoming_connections() {
).take(10)); ).take(10));
transport.set_initial_listener_state(ListenerState::Events(events)); transport.set_initial_listener_state(ListenerState::Events(events));
let mut swarm = RawSwarm::<_, _, _, Handler, _>::new_with_incoming_limit(transport, PeerId::random(), Some(limit)); let mut network = Network::<_, _, _, Handler, _>::new_with_incoming_limit(transport, PeerId::random(), Some(limit));
assert_eq!(swarm.incoming_limit(), Some(limit)); assert_eq!(network.incoming_limit(), Some(limit));
swarm.listen_on("/memory/0".parse().unwrap()).unwrap(); network.listen_on("/memory/0".parse().unwrap()).unwrap();
assert_eq!(swarm.incoming_negotiated().count(), 0); assert_eq!(network.incoming_negotiated().count(), 0);
let swarm = Arc::new(Mutex::new(swarm)); let network = Arc::new(Mutex::new(network));
let mut rt = Runtime::new().unwrap(); let mut rt = Runtime::new().unwrap();
for i in 1..10 { for i in 1..10 {
let swarm_fut = swarm.clone(); let network_fut = network.clone();
let fut = future::poll_fn(move || -> Poll<_, ()> { let fut = future::poll_fn(move || -> Poll<_, ()> {
let mut swarm_fut = swarm_fut.lock(); let mut network_fut = network_fut.lock();
if i <= limit { if i <= limit {
assert_matches!(swarm_fut.poll(), Async::Ready(RawSwarmEvent::NewListenerAddress {..})); assert_matches!(network_fut.poll(), Async::Ready(NetworkEvent::NewListenerAddress {..}));
assert_matches!(swarm_fut.poll(), assert_matches!(network_fut.poll(),
Async::Ready(RawSwarmEvent::IncomingConnection(incoming)) => { Async::Ready(NetworkEvent::IncomingConnection(incoming)) => {
incoming.accept(Handler::default()); incoming.accept(Handler::default());
}); });
} else { } else {
match swarm_fut.poll() { match network_fut.poll() {
Async::NotReady => (), Async::NotReady => (),
Async::Ready(x) => { Async::Ready(x) => {
match x { match x {
RawSwarmEvent::NewListenerAddress {..} => {} NetworkEvent::NewListenerAddress {..} => {}
RawSwarmEvent::ExpiredListenerAddress {..} => {} NetworkEvent::ExpiredListenerAddress {..} => {}
RawSwarmEvent::IncomingConnection(_) => {} NetworkEvent::IncomingConnection(_) => {}
RawSwarmEvent::Connected {..} => {} NetworkEvent::Connected {..} => {}
e => panic!("Not expected event: {:?}", e) e => panic!("Not expected event: {:?}", e)
} }
}, },
@ -439,7 +439,7 @@ fn limit_incoming_connections() {
Ok(Async::Ready(())) Ok(Async::Ready(()))
}); });
rt.block_on(fut).expect("tokio works"); rt.block_on(fut).expect("tokio works");
let swarm = swarm.lock(); let network = network.lock();
assert!(swarm.incoming_negotiated().count() <= (limit as usize)); assert!(network.incoming_negotiated().count() <= (limit as usize));
} }
} }

36
core/tests/raw_swarm_dial_error.rs → core/tests/network_dial_error.rs
View File

@ -21,7 +21,7 @@
use futures::{future, prelude::*}; use futures::{future, prelude::*};
use libp2p_core::identity; use libp2p_core::identity;
use libp2p_core::multiaddr::multiaddr; use libp2p_core::multiaddr::multiaddr;
use libp2p_core::nodes::raw_swarm::{RawSwarm, RawSwarmEvent, RawSwarmReachError, PeerState, UnknownPeerDialErr, IncomingError}; use libp2p_core::nodes::network::{Network, NetworkEvent, NetworkReachError, PeerState, UnknownPeerDialErr, IncomingError};
use libp2p_core::{PeerId, Transport, upgrade, upgrade::InboundUpgradeExt, upgrade::OutboundUpgradeExt}; use libp2p_core::{PeerId, Transport, upgrade, upgrade::InboundUpgradeExt, upgrade::OutboundUpgradeExt};
use libp2p_swarm::{ use libp2p_swarm::{
ProtocolsHandler, ProtocolsHandler,
@ -91,7 +91,7 @@ fn deny_incoming_connec() {
// TODO: make creating the transport more elegant ; literaly half of the code of the test // TODO: make creating the transport more elegant ; literaly half of the code of the test
// is about creating the transport // is about creating the transport
let mut swarm1: RawSwarm<_, _, _, NodeHandlerWrapperBuilder<TestHandler<_>>, _> = { let mut swarm1: Network<_, _, _, NodeHandlerWrapperBuilder<TestHandler<_>>, _> = {
let local_key = identity::Keypair::generate_ed25519(); let local_key = identity::Keypair::generate_ed25519();
let local_public_key = local_key.public(); let local_public_key = local_key.public();
let transport = libp2p_tcp::TcpConfig::new() let transport = libp2p_tcp::TcpConfig::new()
@ -104,7 +104,7 @@ fn deny_incoming_connec() {
.map_inbound(move |muxer| (peer_id2, muxer)); .map_inbound(move |muxer| (peer_id2, muxer));
upgrade::apply(out.stream, upgrade, endpoint) upgrade::apply(out.stream, upgrade, endpoint)
}); });
RawSwarm::new(transport, local_public_key.into()) Network::new(transport, local_public_key.into())
}; };
let mut swarm2 = { let mut swarm2 = {
@ -120,13 +120,13 @@ fn deny_incoming_connec() {
.map_inbound(move |muxer| (peer_id2, muxer)); .map_inbound(move |muxer| (peer_id2, muxer));
upgrade::apply(out.stream, upgrade, endpoint) upgrade::apply(out.stream, upgrade, endpoint)
}); });
RawSwarm::new(transport, local_public_key.into()) Network::new(transport, local_public_key.into())
}; };
swarm1.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap()).unwrap(); swarm1.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap()).unwrap();
let address = let address =
if let Async::Ready(RawSwarmEvent::NewListenerAddress { listen_addr, .. }) = swarm1.poll() { if let Async::Ready(NetworkEvent::NewListenerAddress { listen_addr, .. }) = swarm1.poll() {
listen_addr listen_addr
} else { } else {
panic!("Was expecting the listen address to be reported") panic!("Was expecting the listen address to be reported")
@ -139,17 +139,17 @@ fn deny_incoming_connec() {
let future = future::poll_fn(|| -> Poll<(), io::Error> { let future = future::poll_fn(|| -> Poll<(), io::Error> {
match swarm1.poll() { match swarm1.poll() {
Async::Ready(RawSwarmEvent::IncomingConnection(inc)) => drop(inc), Async::Ready(NetworkEvent::IncomingConnection(inc)) => drop(inc),
Async::Ready(_) => unreachable!(), Async::Ready(_) => unreachable!(),
Async::NotReady => (), Async::NotReady => (),
} }
match swarm2.poll() { match swarm2.poll() {
Async::Ready(RawSwarmEvent::DialError { Async::Ready(NetworkEvent::DialError {
new_state: PeerState::NotConnected, new_state: PeerState::NotConnected,
peer_id, peer_id,
multiaddr, multiaddr,
error: RawSwarmReachError::Transport(_) error: NetworkReachError::Transport(_)
}) => { }) => {
assert_eq!(peer_id, *swarm1.local_peer_id()); assert_eq!(peer_id, *swarm1.local_peer_id());
assert_eq!(multiaddr, address); assert_eq!(multiaddr, address);
@ -192,14 +192,14 @@ fn dial_self() {
.map_inbound(move |muxer| (peer_id2, muxer)); .map_inbound(move |muxer| (peer_id2, muxer));
upgrade::apply(out.stream, upgrade, endpoint) upgrade::apply(out.stream, upgrade, endpoint)
}); });
RawSwarm::new(transport, local_public_key.into()) Network::new(transport, local_public_key.into())
}; };
swarm.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap()).unwrap(); swarm.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap()).unwrap();
let (address, mut swarm) = let (address, mut swarm) =
future::lazy(move || { future::lazy(move || {
if let Async::Ready(RawSwarmEvent::NewListenerAddress { listen_addr, .. }) = swarm.poll() { if let Async::Ready(NetworkEvent::NewListenerAddress { listen_addr, .. }) = swarm.poll() {
Ok::<_, void::Void>((listen_addr, swarm)) Ok::<_, void::Void>((listen_addr, swarm))
} else { } else {
panic!("Was expecting the listen address to be reported") panic!("Was expecting the listen address to be reported")
@ -215,7 +215,7 @@ fn dial_self() {
let future = future::poll_fn(|| -> Poll<(), io::Error> { let future = future::poll_fn(|| -> Poll<(), io::Error> {
loop { loop {
match swarm.poll() { match swarm.poll() {
Async::Ready(RawSwarmEvent::UnknownPeerDialError { Async::Ready(NetworkEvent::UnknownPeerDialError {
multiaddr, multiaddr,
error: UnknownPeerDialErr::FoundLocalPeerId, error: UnknownPeerDialErr::FoundLocalPeerId,
handler: _ handler: _
@ -227,7 +227,7 @@ fn dial_self() {
return Ok(Async::Ready(())); return Ok(Async::Ready(()));
} }
}, },
Async::Ready(RawSwarmEvent::IncomingConnectionError { Async::Ready(NetworkEvent::IncomingConnectionError {
listen_addr, listen_addr,
send_back_addr: _, send_back_addr: _,
error: IncomingError::FoundLocalPeerId error: IncomingError::FoundLocalPeerId
@ -239,7 +239,7 @@ fn dial_self() {
return Ok(Async::Ready(())); return Ok(Async::Ready(()));
} }
}, },
Async::Ready(RawSwarmEvent::IncomingConnection(inc)) => { Async::Ready(NetworkEvent::IncomingConnection(inc)) => {
assert_eq!(*inc.listen_addr(), address); assert_eq!(*inc.listen_addr(), address);
inc.accept(TestHandler::default().into_node_handler_builder()); inc.accept(TestHandler::default().into_node_handler_builder());
}, },
@ -259,7 +259,7 @@ fn dial_self_by_id() {
// TODO: make creating the transport more elegant ; literaly half of the code of the test // TODO: make creating the transport more elegant ; literaly half of the code of the test
// is about creating the transport // is about creating the transport
let mut swarm: RawSwarm<_, _, _, NodeHandlerWrapperBuilder<TestHandler<_>>, _> = { let mut swarm: Network<_, _, _, NodeHandlerWrapperBuilder<TestHandler<_>>, _> = {
let local_key = identity::Keypair::generate_ed25519(); let local_key = identity::Keypair::generate_ed25519();
let local_public_key = local_key.public(); let local_public_key = local_key.public();
let transport = libp2p_tcp::TcpConfig::new() let transport = libp2p_tcp::TcpConfig::new()
@ -272,7 +272,7 @@ fn dial_self_by_id() {
.map_inbound(move |muxer| (peer_id2, muxer)); .map_inbound(move |muxer| (peer_id2, muxer));
upgrade::apply(out.stream, upgrade, endpoint) upgrade::apply(out.stream, upgrade, endpoint)
}); });
RawSwarm::new(transport, local_public_key.into()) Network::new(transport, local_public_key.into())
}; };
let peer_id = swarm.local_peer_id().clone(); let peer_id = swarm.local_peer_id().clone();
@ -298,7 +298,7 @@ fn multiple_addresses_err() {
.map_inbound(move |muxer| (peer_id2, muxer)); .map_inbound(move |muxer| (peer_id2, muxer));
upgrade::apply(out.stream, upgrade, endpoint) upgrade::apply(out.stream, upgrade, endpoint)
}); });
RawSwarm::new(transport, local_public_key.into()) Network::new(transport, local_public_key.into())
}; };
let mut addresses = Vec::new(); let mut addresses = Vec::new();
@ -319,11 +319,11 @@ fn multiple_addresses_err() {
let future = future::poll_fn(|| -> Poll<(), io::Error> { let future = future::poll_fn(|| -> Poll<(), io::Error> {
loop { loop {
match swarm.poll() { match swarm.poll() {
Async::Ready(RawSwarmEvent::DialError { Async::Ready(NetworkEvent::DialError {
new_state, new_state,
peer_id, peer_id,
multiaddr, multiaddr,
error: RawSwarmReachError::Transport(_) error: NetworkReachError::Transport(_)
}) => { }) => {
assert_eq!(peer_id, target); assert_eq!(peer_id, target);
let expected = addresses.remove(0); let expected = addresses.remove(0);

26
core/tests/raw_swarm_simult.rs → core/tests/network_simult.rs
View File

@ -20,7 +20,7 @@
use futures::{future, prelude::*}; use futures::{future, prelude::*};
use libp2p_core::identity; use libp2p_core::identity;
use libp2p_core::nodes::raw_swarm::{RawSwarm, RawSwarmEvent, IncomingError}; use libp2p_core::nodes::network::{Network, NetworkEvent, IncomingError};
use libp2p_core::{Transport, upgrade, upgrade::OutboundUpgradeExt, upgrade::InboundUpgradeExt}; use libp2p_core::{Transport, upgrade, upgrade::OutboundUpgradeExt, upgrade::InboundUpgradeExt};
use libp2p_swarm::{ use libp2p_swarm::{
ProtocolsHandler, ProtocolsHandler,
@ -119,7 +119,7 @@ fn raw_swarm_simultaneous_connect() {
.map_inbound(move |muxer| (peer_id2, muxer)); .map_inbound(move |muxer| (peer_id2, muxer));
upgrade::apply(out.stream, upgrade, endpoint) upgrade::apply(out.stream, upgrade, endpoint)
}); });
RawSwarm::new(transport, local_public_key.into_peer_id()) Network::new(transport, local_public_key.into_peer_id())
}; };
let mut swarm2 = { let mut swarm2 = {
@ -135,7 +135,7 @@ fn raw_swarm_simultaneous_connect() {
.map_inbound(move |muxer| (peer_id2, muxer)); .map_inbound(move |muxer| (peer_id2, muxer));
upgrade::apply(out.stream, upgrade, endpoint) upgrade::apply(out.stream, upgrade, endpoint)
}); });
RawSwarm::new(transport, local_public_key.into_peer_id()) Network::new(transport, local_public_key.into_peer_id())
}; };
swarm1.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap()).unwrap(); swarm1.listen_on("/ip4/127.0.0.1/tcp/0".parse().unwrap()).unwrap();
@ -144,14 +144,14 @@ fn raw_swarm_simultaneous_connect() {
let (swarm1_listen_addr, swarm2_listen_addr, mut swarm1, mut swarm2) = let (swarm1_listen_addr, swarm2_listen_addr, mut swarm1, mut swarm2) =
future::lazy(move || { future::lazy(move || {
let swarm1_listen_addr = let swarm1_listen_addr =
if let Async::Ready(RawSwarmEvent::NewListenerAddress { listen_addr, .. }) = swarm1.poll() { if let Async::Ready(NetworkEvent::NewListenerAddress { listen_addr, .. }) = swarm1.poll() {
listen_addr listen_addr
} else { } else {
panic!("Was expecting the listen address to be reported") panic!("Was expecting the listen address to be reported")
}; };
let swarm2_listen_addr = let swarm2_listen_addr =
if let Async::Ready(RawSwarmEvent::NewListenerAddress { listen_addr, .. }) = swarm2.poll() { if let Async::Ready(NetworkEvent::NewListenerAddress { listen_addr, .. }) = swarm2.poll() {
listen_addr listen_addr
} else { } else {
panic!("Was expecting the listen address to be reported") panic!("Was expecting the listen address to be reported")
@ -207,21 +207,21 @@ fn raw_swarm_simultaneous_connect() {
if rand::random::<f32>() < 0.1 { if rand::random::<f32>() < 0.1 {
match swarm1.poll() { match swarm1.poll() {
Async::Ready(RawSwarmEvent::IncomingConnectionError { error: IncomingError::DeniedLowerPriority, .. }) => { Async::Ready(NetworkEvent::IncomingConnectionError { error: IncomingError::DeniedLowerPriority, .. }) => {
assert_eq!(swarm1_step, 2); assert_eq!(swarm1_step, 2);
swarm1_step = 3; swarm1_step = 3;
}, },
Async::Ready(RawSwarmEvent::Connected { conn_info, .. }) => { Async::Ready(NetworkEvent::Connected { conn_info, .. }) => {
assert_eq!(conn_info, *swarm2.local_peer_id()); assert_eq!(conn_info, *swarm2.local_peer_id());
assert_eq!(swarm1_step, 1); assert_eq!(swarm1_step, 1);
swarm1_step = 2; swarm1_step = 2;
}, },
Async::Ready(RawSwarmEvent::Replaced { new_info, .. }) => { Async::Ready(NetworkEvent::Replaced { new_info, .. }) => {
assert_eq!(new_info, *swarm2.local_peer_id()); assert_eq!(new_info, *swarm2.local_peer_id());
assert_eq!(swarm1_step, 2); assert_eq!(swarm1_step, 2);
swarm1_step = 3; swarm1_step = 3;
}, },
Async::Ready(RawSwarmEvent::IncomingConnection(inc)) => { Async::Ready(NetworkEvent::IncomingConnection(inc)) => {
inc.accept(TestHandler::default().into_node_handler_builder()); inc.accept(TestHandler::default().into_node_handler_builder());
}, },
Async::Ready(_) => unreachable!(), Async::Ready(_) => unreachable!(),
@ -231,21 +231,21 @@ fn raw_swarm_simultaneous_connect() {
if rand::random::<f32>() < 0.1 { if rand::random::<f32>() < 0.1 {
match swarm2.poll() { match swarm2.poll() {
Async::Ready(RawSwarmEvent::IncomingConnectionError { error: IncomingError::DeniedLowerPriority, .. }) => { Async::Ready(NetworkEvent::IncomingConnectionError { error: IncomingError::DeniedLowerPriority, .. }) => {
assert_eq!(swarm2_step, 2); assert_eq!(swarm2_step, 2);
swarm2_step = 3; swarm2_step = 3;
}, },
Async::Ready(RawSwarmEvent::Connected { conn_info, .. }) => { Async::Ready(NetworkEvent::Connected { conn_info, .. }) => {
assert_eq!(conn_info, *swarm1.local_peer_id()); assert_eq!(conn_info, *swarm1.local_peer_id());
assert_eq!(swarm2_step, 1); assert_eq!(swarm2_step, 1);
swarm2_step = 2; swarm2_step = 2;
}, },
Async::Ready(RawSwarmEvent::Replaced { new_info, .. }) => { Async::Ready(NetworkEvent::Replaced { new_info, .. }) => {
assert_eq!(new_info, *swarm1.local_peer_id()); assert_eq!(new_info, *swarm1.local_peer_id());
assert_eq!(swarm2_step, 2); assert_eq!(swarm2_step, 2);
swarm2_step = 3; swarm2_step = 3;
}, },
Async::Ready(RawSwarmEvent::IncomingConnection(inc)) => { Async::Ready(NetworkEvent::IncomingConnection(inc)) => {
inc.accept(TestHandler::default().into_node_handler_builder()); inc.accept(TestHandler::default().into_node_handler_builder());
}, },
Async::Ready(_) => unreachable!(), Async::Ready(_) => unreachable!(),

80
swarm/src/lib.rs
View File

@ -86,7 +86,7 @@ use libp2p_core::{
collection::ConnectionInfo, collection::ConnectionInfo,
handled_node::NodeHandler, handled_node::NodeHandler,
node::Substream, node::Substream,
raw_swarm::{self, RawSwarm, RawSwarmEvent} network::{self, Network, NetworkEvent}
}, },
transport::TransportError transport::TransportError
}; };
@ -111,7 +111,7 @@ pub struct ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler,
where where
TTransport: Transport, TTransport: Transport,
{ {
raw_swarm: RawSwarm< network: Network<
TTransport, TTransport,
TInEvent, TInEvent,
TOutEvent, TOutEvent,
@ -212,14 +212,14 @@ where TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
/// Returns the transport passed when building this object. /// Returns the transport passed when building this object.
pub fn transport(me: &Self) -> &TTransport { pub fn transport(me: &Self) -> &TTransport {
me.raw_swarm.transport() me.network.transport()
} }
/// Starts listening on the given address. /// Starts listening on the given address.
/// ///
/// Returns an error if the address is not supported. /// Returns an error if the address is not supported.
pub fn listen_on(me: &mut Self, addr: Multiaddr) -> Result<(), TransportError<TTransport::Error>> { pub fn listen_on(me: &mut Self, addr: Multiaddr) -> Result<(), TransportError<TTransport::Error>> {
me.raw_swarm.listen_on(addr) me.network.listen_on(addr)
} }
/// Tries to dial the given address. /// Tries to dial the given address.
@ -227,7 +227,7 @@ where TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
/// Returns an error if the address is not supported. /// Returns an error if the address is not supported.
pub fn dial_addr(me: &mut Self, addr: Multiaddr) -> Result<(), TransportError<TTransport::Error>> { pub fn dial_addr(me: &mut Self, addr: Multiaddr) -> Result<(), TransportError<TTransport::Error>> {
let handler = me.behaviour.new_handler(); let handler = me.behaviour.new_handler();
me.raw_swarm.dial(addr, handler.into_node_handler_builder()) me.network.dial(addr, handler.into_node_handler_builder())
} }
/// Tries to reach the given peer using the elements in the topology. /// Tries to reach the given peer using the elements in the topology.
@ -236,23 +236,23 @@ where TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
/// peer. /// peer.
pub fn dial(me: &mut Self, peer_id: PeerId) { pub fn dial(me: &mut Self, peer_id: PeerId) {
let addrs = me.behaviour.addresses_of_peer(&peer_id); let addrs = me.behaviour.addresses_of_peer(&peer_id);
match me.raw_swarm.peer(peer_id.clone()) { match me.network.peer(peer_id.clone()) {
raw_swarm::Peer::NotConnected(peer) => { network::Peer::NotConnected(peer) => {
let handler = me.behaviour.new_handler().into_node_handler_builder(); let handler = me.behaviour.new_handler().into_node_handler_builder();
if peer.connect_iter(addrs, handler).is_err() { if peer.connect_iter(addrs, handler).is_err() {
me.behaviour.inject_dial_failure(&peer_id); me.behaviour.inject_dial_failure(&peer_id);
} }
}, },
raw_swarm::Peer::PendingConnect(mut peer) => { network::Peer::PendingConnect(mut peer) => {
peer.append_multiaddr_attempts(addrs) peer.append_multiaddr_attempts(addrs)
}, },
raw_swarm::Peer::Connected(_) | raw_swarm::Peer::LocalNode => {} network::Peer::Connected(_) | network::Peer::LocalNode => {}
} }
} }
/// Returns an iterator that produces the list of addresses we're listening on. /// Returns an iterator that produces the list of addresses we're listening on.
pub fn listeners(me: &Self) -> impl Iterator<Item = &Multiaddr> { pub fn listeners(me: &Self) -> impl Iterator<Item = &Multiaddr> {
me.raw_swarm.listen_addrs() me.network.listen_addrs()
} }
/// Returns an iterator that produces the list of addresses that other nodes can use to reach /// Returns an iterator that produces the list of addresses that other nodes can use to reach
@ -263,7 +263,7 @@ where TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
/// Returns the peer ID of the swarm passed as parameter. /// Returns the peer ID of the swarm passed as parameter.
pub fn local_peer_id(me: &Self) -> &PeerId { pub fn local_peer_id(me: &Self) -> &PeerId {
&me.raw_swarm.local_peer_id() &me.network.local_peer_id()
} }
/// Adds an external address. /// Adds an external address.
@ -275,9 +275,9 @@ where TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
} }
/// Returns the connection info of a node, or `None` if we're not connected to it. /// Returns the connection info of a node, or `None` if we're not connected to it.
// TODO: should take &self instead of &mut self, but the API in raw_swarm requires &mut // TODO: should take &self instead of &mut self, but the API in network requires &mut
pub fn connection_info(me: &mut Self, peer_id: &PeerId) -> Option<TConnInfo> { pub fn connection_info(me: &mut Self, peer_id: &PeerId) -> Option<TConnInfo> {
if let Some(mut n) = me.raw_swarm.peer(peer_id.clone()).into_connected() { if let Some(mut n) = me.network.peer(peer_id.clone()).into_connected() {
Some(n.connection_info().clone()) Some(n.connection_info().clone())
} else { } else {
None None
@ -290,7 +290,7 @@ where TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
/// This function has no effect is the peer is already banned. /// This function has no effect is the peer is already banned.
pub fn ban_peer_id(me: &mut Self, peer_id: PeerId) { pub fn ban_peer_id(me: &mut Self, peer_id: PeerId) {
me.banned_peers.insert(peer_id.clone()); me.banned_peers.insert(peer_id.clone());
if let Some(c) = me.raw_swarm.peer(peer_id).into_connected() { if let Some(c) = me.network.peer(peer_id).into_connected() {
c.close(); c.close();
} }
} }
@ -339,59 +339,59 @@ where TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
fn poll(&mut self) -> Poll<Option<Self::Item>, io::Error> { fn poll(&mut self) -> Poll<Option<Self::Item>, io::Error> {
loop { loop {
let mut raw_swarm_not_ready = false; let mut network_not_ready = false;
match self.raw_swarm.poll() { match self.network.poll() {
Async::NotReady => raw_swarm_not_ready = true, Async::NotReady => network_not_ready = true,
Async::Ready(RawSwarmEvent::NodeEvent { conn_info, event }) => { Async::Ready(NetworkEvent::NodeEvent { conn_info, event }) => {
self.behaviour.inject_node_event(conn_info.peer_id().clone(), event); self.behaviour.inject_node_event(conn_info.peer_id().clone(), event);
}, },
Async::Ready(RawSwarmEvent::Connected { conn_info, endpoint }) => { Async::Ready(NetworkEvent::Connected { conn_info, endpoint }) => {
if self.banned_peers.contains(conn_info.peer_id()) { if self.banned_peers.contains(conn_info.peer_id()) {
self.raw_swarm.peer(conn_info.peer_id().clone()) self.network.peer(conn_info.peer_id().clone())
.into_connected() .into_connected()
.expect("the RawSwarm just notified us that we were connected; QED") .expect("the Network just notified us that we were connected; QED")
.close(); .close();
} else { } else {
self.behaviour.inject_connected(conn_info.peer_id().clone(), endpoint); self.behaviour.inject_connected(conn_info.peer_id().clone(), endpoint);
} }
}, },
Async::Ready(RawSwarmEvent::NodeClosed { conn_info, endpoint, .. }) => { Async::Ready(NetworkEvent::NodeClosed { conn_info, endpoint, .. }) => {
self.behaviour.inject_disconnected(conn_info.peer_id(), endpoint); self.behaviour.inject_disconnected(conn_info.peer_id(), endpoint);
}, },
Async::Ready(RawSwarmEvent::Replaced { new_info, closed_endpoint, endpoint, .. }) => { Async::Ready(NetworkEvent::Replaced { new_info, closed_endpoint, endpoint, .. }) => {
self.behaviour.inject_replaced(new_info.peer_id().clone(), closed_endpoint, endpoint); self.behaviour.inject_replaced(new_info.peer_id().clone(), closed_endpoint, endpoint);
}, },
Async::Ready(RawSwarmEvent::IncomingConnection(incoming)) => { Async::Ready(NetworkEvent::IncomingConnection(incoming)) => {
let handler = self.behaviour.new_handler(); let handler = self.behaviour.new_handler();
incoming.accept(handler.into_node_handler_builder()); incoming.accept(handler.into_node_handler_builder());
}, },
Async::Ready(RawSwarmEvent::NewListenerAddress { listen_addr }) => { Async::Ready(NetworkEvent::NewListenerAddress { listen_addr }) => {
if !self.listened_addrs.contains(&listen_addr) { if !self.listened_addrs.contains(&listen_addr) {
self.listened_addrs.push(listen_addr.clone()) self.listened_addrs.push(listen_addr.clone())
} }
self.behaviour.inject_new_listen_addr(&listen_addr); self.behaviour.inject_new_listen_addr(&listen_addr);
} }
Async::Ready(RawSwarmEvent::ExpiredListenerAddress { listen_addr }) => { Async::Ready(NetworkEvent::ExpiredListenerAddress { listen_addr }) => {
self.listened_addrs.retain(|a| a != &listen_addr); self.listened_addrs.retain(|a| a != &listen_addr);
self.behaviour.inject_expired_listen_addr(&listen_addr); self.behaviour.inject_expired_listen_addr(&listen_addr);
} }
Async::Ready(RawSwarmEvent::ListenerClosed { .. }) => {}, Async::Ready(NetworkEvent::ListenerClosed { .. }) => {},
Async::Ready(RawSwarmEvent::IncomingConnectionError { .. }) => {}, Async::Ready(NetworkEvent::IncomingConnectionError { .. }) => {},
Async::Ready(RawSwarmEvent::DialError { peer_id, multiaddr, error, new_state }) => { Async::Ready(NetworkEvent::DialError { peer_id, multiaddr, error, new_state }) => {
self.behaviour.inject_addr_reach_failure(Some(&peer_id), &multiaddr, &error); self.behaviour.inject_addr_reach_failure(Some(&peer_id), &multiaddr, &error);
if let raw_swarm::PeerState::NotConnected = new_state { if let network::PeerState::NotConnected = new_state {
self.behaviour.inject_dial_failure(&peer_id); self.behaviour.inject_dial_failure(&peer_id);
} }
}, },
Async::Ready(RawSwarmEvent::UnknownPeerDialError { multiaddr, error, .. }) => { Async::Ready(NetworkEvent::UnknownPeerDialError { multiaddr, error, .. }) => {
self.behaviour.inject_addr_reach_failure(None, &multiaddr, &error); self.behaviour.inject_addr_reach_failure(None, &multiaddr, &error);
}, },
} }
// Try to deliver pending event. // Try to deliver pending event.
if let Some((id, pending)) = self.send_event_to_complete.take() { if let Some((id, pending)) = self.send_event_to_complete.take() {
if let Some(mut peer) = self.raw_swarm.peer(id.clone()).into_connected() { if let Some(mut peer) = self.network.peer(id.clone()).into_connected() {
if let AsyncSink::NotReady(e) = pending { if let AsyncSink::NotReady(e) = pending {
if let Ok(a@AsyncSink::NotReady(_)) = peer.start_send_event(e) { if let Ok(a@AsyncSink::NotReady(_)) = peer.start_send_event(e) {
self.send_event_to_complete = Some((id, a)) self.send_event_to_complete = Some((id, a))
@ -409,7 +409,7 @@ where TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
let behaviour_poll = { let behaviour_poll = {
let mut parameters = SwarmPollParameters { let mut parameters = SwarmPollParameters {
local_peer_id: &mut self.raw_swarm.local_peer_id(), local_peer_id: &mut self.network.local_peer_id(),
supported_protocols: &self.supported_protocols, supported_protocols: &self.supported_protocols,
listened_addrs: &self.listened_addrs, listened_addrs: &self.listened_addrs,
external_addrs: &self.external_addrs external_addrs: &self.external_addrs
@ -418,7 +418,7 @@ where TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
}; };
match behaviour_poll { match behaviour_poll {
Async::NotReady if raw_swarm_not_ready => return Ok(Async::NotReady), Async::NotReady if network_not_ready => return Ok(Async::NotReady),
Async::NotReady => (), Async::NotReady => (),
Async::Ready(NetworkBehaviourAction::GenerateEvent(event)) => { Async::Ready(NetworkBehaviourAction::GenerateEvent(event)) => {
return Ok(Async::Ready(Some(event))) return Ok(Async::Ready(Some(event)))
@ -434,7 +434,7 @@ where TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
} }
}, },
Async::Ready(NetworkBehaviourAction::SendEvent { peer_id, event }) => { Async::Ready(NetworkBehaviourAction::SendEvent { peer_id, event }) => {
if let Some(mut peer) = self.raw_swarm.peer(peer_id.clone()).into_connected() { if let Some(mut peer) = self.network.peer(peer_id.clone()).into_connected() {
if let Ok(a@AsyncSink::NotReady(_)) = peer.start_send_event(event) { if let Ok(a@AsyncSink::NotReady(_)) = peer.start_send_event(event) {
self.send_event_to_complete = Some((peer_id, a)) self.send_event_to_complete = Some((peer_id, a))
} else if let Ok(Async::NotReady) = peer.complete_send_event() { } else if let Ok(Async::NotReady) = peer.complete_send_event() {
@ -443,7 +443,7 @@ where TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
} }
}, },
Async::Ready(NetworkBehaviourAction::ReportObservedAddr { address }) => { Async::Ready(NetworkBehaviourAction::ReportObservedAddr { address }) => {
for addr in self.raw_swarm.nat_traversal(&address) { for addr in self.network.nat_traversal(&address) {
if self.external_addrs.iter().all(|a| *a != addr) { if self.external_addrs.iter().all(|a| *a != addr) {
self.behaviour.inject_new_external_addr(&addr); self.behaviour.inject_new_external_addr(&addr);
} }
@ -547,10 +547,10 @@ where TBehaviour: NetworkBehaviour,
.map(|info| info.protocol_name().to_vec()) .map(|info| info.protocol_name().to_vec())
.collect(); .collect();
let raw_swarm = RawSwarm::new_with_incoming_limit(self.transport, self.local_peer_id, self.incoming_limit); let network = Network::new_with_incoming_limit(self.transport, self.local_peer_id, self.incoming_limit);
ExpandedSwarm { ExpandedSwarm {
raw_swarm, network,
behaviour: self.behaviour, behaviour: self.behaviour,
supported_protocols, supported_protocols,
listened_addrs: SmallVec::new(), listened_addrs: SmallVec::new(),
@ -628,7 +628,7 @@ mod tests {
let behaviour = DummyBehaviour{marker: PhantomData}; let behaviour = DummyBehaviour{marker: PhantomData};
let swarm = SwarmBuilder::new(transport, behaviour, id.into()) let swarm = SwarmBuilder::new(transport, behaviour, id.into())
.incoming_limit(Some(4)).build(); .incoming_limit(Some(4)).build();
assert_eq!(swarm.raw_swarm.incoming_limit(), Some(4)); assert_eq!(swarm.network.incoming_limit(), Some(4));
} }
#[test] #[test]
@ -637,6 +637,6 @@ mod tests {
let transport = DummyTransport::<(PeerId, Multiplex<DummyStream>)>::new(); let transport = DummyTransport::<(PeerId, Multiplex<DummyStream>)>::new();
let behaviour = DummyBehaviour{marker: PhantomData}; let behaviour = DummyBehaviour{marker: PhantomData};
let swarm = SwarmBuilder::new(transport, behaviour, id.into()).build(); let swarm = SwarmBuilder::new(transport, behaviour, id.into()).build();
assert!(swarm.raw_swarm.incoming_limit().is_none()) assert!(swarm.network.incoming_limit().is_none())
} }
} }