fluencelabs/rust-libp2p
1
0
Fork 0
mirror of https://github.com/fluencelabs/rust-libp2p synced 2025-06-27 08:41:36 +00:00
Code Issues Projects Releases Wiki Activity

*: Format with rustfmt (#2188)

Browse Source 
Co-authored-by: Thomas Eizinger <thomas@eizinger.io>
This commit is contained in:
Max Inden
2021-08-11 13:12:12 +02:00
committed by GitHub
parent 008561283e
commit f701b24ec0
171 changed files with 10051 additions and 7193 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -24,23 +24,19 @@ use crate::protocol::{
};
use crate::record::{self, Record};
use futures::prelude::*;
use libp2p_swarm::{
IntoProtocolsHandler,
KeepAlive,
NegotiatedSubstream,
SubstreamProtocol,
ProtocolsHandler,
ProtocolsHandlerEvent,
ProtocolsHandlerUpgrErr
};
use libp2p_core::{
ConnectedPoint,
PeerId,
either::EitherOutput,
upgrade::{self, InboundUpgrade, OutboundUpgrade}
upgrade::{self, InboundUpgrade, OutboundUpgrade},
ConnectedPoint, PeerId,
};
use libp2p_swarm::{
IntoProtocolsHandler, KeepAlive, NegotiatedSubstream, ProtocolsHandler, ProtocolsHandlerEvent,
ProtocolsHandlerUpgrErr, SubstreamProtocol,
};
use log::trace;
use std::{error, fmt, io, marker::PhantomData, pin::Pin, task::Context, task::Poll, time::Duration};
use std::{
error, fmt, io, marker::PhantomData, pin::Pin, task::Context, task::Poll, time::Duration,
};
use wasm_timer::Instant;
/// A prototype from which [`KademliaHandler`]s can be constructed.
@ -51,7 +47,10 @@ pub struct KademliaHandlerProto<T> {
impl<T> KademliaHandlerProto<T> {
pub fn new(config: KademliaHandlerConfig) -> Self {
KademliaHandlerProto { config, _type: PhantomData }
KademliaHandlerProto {
config,
_type: PhantomData,
}
}
}
@ -151,7 +150,11 @@ enum SubstreamState<TUserData> {
/// Waiting for the user to send a `KademliaHandlerIn` event containing the response.
InWaitingUser(UniqueConnecId, KadInStreamSink<NegotiatedSubstream>),
/// Waiting to send an answer back to the remote.
InPendingSend(UniqueConnecId, KadInStreamSink<NegotiatedSubstream>, KadResponseMsg),
InPendingSend(
UniqueConnecId,
KadInStreamSink<NegotiatedSubstream>,
KadResponseMsg,
),
/// Waiting to flush an answer back to the remote.
InPendingFlush(UniqueConnecId, KadInStreamSink<NegotiatedSubstream>),
/// The substream is being closed.
@ -164,23 +167,28 @@ impl<TUserData> SubstreamState<TUserData> {
/// If the substream is not ready to be closed, returns it back.
fn try_close(&mut self, cx: &mut Context<'_>) -> Poll<()> {
match self {
SubstreamState::OutPendingOpen(_, _)
| SubstreamState::OutReportError(_, _) => Poll::Ready(()),
SubstreamState::OutPendingOpen(_, _) | 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::OutClosing(ref mut stream) => {
match Sink::poll_close(Pin::new(stream), cx) {
Poll::Ready(_) => Poll::Ready(()),
Poll::Pending => Poll::Pending,
}
}
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,
},
| SubstreamState::InClosing(ref mut stream) => {
match Sink::poll_close(Pin::new(stream), cx) {
Poll::Ready(_) => Poll::Ready(()),
Poll::Pending => Poll::Pending,
}
}
}
}
}
@ -282,7 +290,7 @@ pub enum KademliaHandlerEvent<TUserData> {
value: Vec<u8>,
/// The user data passed to the `PutValue`.
user_data: TUserData,
}
},
}
/// Error that can happen when requesting an RPC query.
@ -301,13 +309,16 @@ impl fmt::Display for KademliaHandlerQueryErr {
match self {
KademliaHandlerQueryErr::Upgrade(err) => {
write!(f, "Error while performing Kademlia query: {}", err)
},
}
KademliaHandlerQueryErr::UnexpectedMessage => {
write!(f, "Remote answered our Kademlia RPC query with the wrong message type")
},
write!(
f,
"Remote answered our Kademlia RPC query with the wrong message type"
)
}
KademliaHandlerQueryErr::Io(err) => {
write!(f, "I/O error during a Kademlia RPC query: {}", err)
},
}
}
}
}
@ -424,7 +435,7 @@ pub enum KademliaHandlerIn<TUserData> {
value: Vec<u8>,
/// Identifier of the request that was made by the remote.
request_id: KademliaRequestId,
}
},
}
/// Unique identifier for a request. Must be passed back in order to answer a request from
@ -470,7 +481,8 @@ where
fn listen_protocol(&self) -> SubstreamProtocol<Self::InboundProtocol, Self::InboundOpenInfo> {
if self.config.allow_listening {
SubstreamProtocol::new(self.config.protocol_config.clone(), ()).map_upgrade(upgrade::EitherUpgrade::A)
SubstreamProtocol::new(self.config.protocol_config.clone(), ())
.map_upgrade(upgrade::EitherUpgrade::A)
} else {
SubstreamProtocol::new(upgrade::EitherUpgrade::B(upgrade::DeniedUpgrade), ())
}
@ -481,7 +493,8 @@ where
protocol: <Self::OutboundProtocol as OutboundUpgrade<NegotiatedSubstream>>::Output,
(msg, user_data): Self::OutboundOpenInfo,
) {
self.substreams.push(SubstreamState::OutPendingSend(protocol, msg, user_data));
self.substreams
.push(SubstreamState::OutPendingSend(protocol, msg, user_data));
if let ProtocolStatus::Unconfirmed = self.protocol_status {
// Upon the first successfully negotiated substream, we know that the
// remote is configured with the same protocol name and we want
@ -493,7 +506,7 @@ where
fn inject_fully_negotiated_inbound(
&mut self,
protocol: <Self::InboundProtocol as InboundUpgrade<NegotiatedSubstream>>::Output,
(): Self::InboundOpenInfo
(): Self::InboundOpenInfo,
) {
// If `self.allow_listening` is false, then we produced a `DeniedUpgrade` and `protocol`
// is a `Void`.
@ -505,7 +518,8 @@ where
debug_assert!(self.config.allow_listening);
let connec_unique_id = self.next_connec_unique_id;
self.next_connec_unique_id.0 += 1;
self.substreams.push(SubstreamState::InWaitingMessage(connec_unique_id, protocol));
self.substreams
.push(SubstreamState::InWaitingMessage(connec_unique_id, protocol));
if let ProtocolStatus::Unconfirmed = self.protocol_status {
// Upon the first successfully negotiated substream, we know that the
// remote is configured with the same protocol name and we want
@ -518,8 +532,9 @@ where
match message {
KademliaHandlerIn::Reset(request_id) => {
let pos = self.substreams.iter().position(|state| match state {
SubstreamState::InWaitingUser(conn_id, _) =>
conn_id == &request_id.connec_unique_id,
SubstreamState::InWaitingUser(conn_id, _) => {
conn_id == &request_id.connec_unique_id
}
_ => false,
});
if let Some(pos) = pos {
@ -531,15 +546,17 @@ where
}
KademliaHandlerIn::FindNodeReq { key, user_data } => {
let msg = KadRequestMsg::FindNode { key };
self.substreams.push(SubstreamState::OutPendingOpen(msg, Some(user_data)));
self.substreams
.push(SubstreamState::OutPendingOpen(msg, Some(user_data)));
}
KademliaHandlerIn::FindNodeRes {
closer_peers,
request_id,
} => {
let pos = self.substreams.iter().position(|state| match state {
SubstreamState::InWaitingUser(ref conn_id, _) =>
conn_id == &request_id.connec_unique_id,
SubstreamState::InWaitingUser(ref conn_id, _) => {
conn_id == &request_id.connec_unique_id
}
_ => false,
});
@ -549,9 +566,7 @@ where
_ => unreachable!(),
};
let msg = KadResponseMsg::FindNode {
closer_peers,
};
let msg = KadResponseMsg::FindNode { closer_peers };
self.substreams
.push(SubstreamState::InPendingSend(conn_id, substream, msg));
}
@ -591,12 +606,13 @@ where
}
KademliaHandlerIn::AddProvider { key, provider } => {
let msg = KadRequestMsg::AddProvider { key, provider };
self.substreams.push(SubstreamState::OutPendingOpen(msg, None));
self.substreams
.push(SubstreamState::OutPendingOpen(msg, None));
}
KademliaHandlerIn::GetRecord { key, user_data } => {
let msg = KadRequestMsg::GetValue { key };
self.substreams.push(SubstreamState::OutPendingOpen(msg, Some(user_data)));
self.substreams
.push(SubstreamState::OutPendingOpen(msg, Some(user_data)));
}
KademliaHandlerIn::PutRecord { record, user_data } => {
let msg = KadRequestMsg::PutValue { record };
@ -609,8 +625,9 @@ where
request_id,
} => {
let pos = self.substreams.iter().position(|state| match state {
SubstreamState::InWaitingUser(ref conn_id, _)
=> conn_id == &request_id.connec_unique_id,
SubstreamState::InWaitingUser(ref conn_id, _) => {
conn_id == &request_id.connec_unique_id
}
_ => false,
});
@ -636,9 +653,9 @@ where
let pos = self.substreams.iter().position(|state| match state {
SubstreamState::InWaitingUser(ref conn_id, _)
if conn_id == &request_id.connec_unique_id =>
{
true
}
{
true
}
_ => false,
});
@ -648,10 +665,7 @@ where
_ => unreachable!(),
};
let msg = KadResponseMsg::PutValue {
key,
value,
};
let msg = KadResponseMsg::PutValue { key, value };
self.substreams
.push(SubstreamState::InPendingSend(conn_id, substream, msg));
}
@ -680,7 +694,12 @@ where
&mut self,
cx: &mut Context<'_>,
) -> Poll<
ProtocolsHandlerEvent<Self::OutboundProtocol, Self::OutboundOpenInfo, Self::OutEvent, Self::Error>,
ProtocolsHandlerEvent<
Self::OutboundProtocol,
Self::OutboundOpenInfo,
Self::OutEvent,
Self::Error,
>,
> {
if self.substreams.is_empty() {
return Poll::Pending;
@ -690,8 +709,9 @@ where
self.protocol_status = ProtocolStatus::Reported;
return Poll::Ready(ProtocolsHandlerEvent::Custom(
KademliaHandlerEvent::ProtocolConfirmed {
endpoint: self.endpoint.clone()
}))
endpoint: self.endpoint.clone(),
},
));
}
// We remove each element from `substreams` one by one and add them back.
@ -706,7 +726,8 @@ where
}
(None, Some(event), _) => {
if self.substreams.is_empty() {
self.keep_alive = KeepAlive::Until(Instant::now() + self.config.idle_timeout);
self.keep_alive =
KeepAlive::Until(Instant::now() + self.config.idle_timeout);
}
return Poll::Ready(event);
}
@ -765,36 +786,35 @@ fn advance_substream<TUserData>(
>,
>,
bool,
)
{
) {
match state {
SubstreamState::OutPendingOpen(msg, user_data) => {
let ev = ProtocolsHandlerEvent::OutboundSubstreamRequest {
protocol: SubstreamProtocol::new(upgrade, (msg, user_data))
protocol: SubstreamProtocol::new(upgrade, (msg, user_data)),
};
(None, Some(ev), false)
}
SubstreamState::OutPendingSend(mut substream, msg, user_data) => {
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 {
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
};
user_data,
},
))
} else {
None
};
(None, event, false)
}
(None, event, false)
}
},
Poll::Pending => (
@ -804,10 +824,12 @@ fn advance_substream<TUserData>(
),
Poll::Ready(Err(error)) => {
let event = if let Some(user_data) = user_data {
Some(ProtocolsHandlerEvent::Custom(KademliaHandlerEvent::QueryError {
error: KademliaHandlerQueryErr::Io(error),
user_data
}))
Some(ProtocolsHandlerEvent::Custom(
KademliaHandlerEvent::QueryError {
error: KademliaHandlerQueryErr::Io(error),
user_data,
},
))
} else {
None
};
@ -836,10 +858,12 @@ fn advance_substream<TUserData>(
),
Poll::Ready(Err(error)) => {
let event = if let Some(user_data) = user_data {
Some(ProtocolsHandlerEvent::Custom(KademliaHandlerEvent::QueryError {
error: KademliaHandlerQueryErr::Io(error),
user_data,
}))
Some(ProtocolsHandlerEvent::Custom(
KademliaHandlerEvent::QueryError {
error: KademliaHandlerQueryErr::Io(error),
user_data,
},
))
} else {
None
};
@ -848,110 +872,121 @@ fn advance_substream<TUserData>(
}
}
}
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);
(
Some(new_state),
Some(ProtocolsHandlerEvent::Custom(event)),
true,
)
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);
(
Some(new_state),
Some(ProtocolsHandlerEvent::Custom(event)),
true,
)
}
Poll::Pending => (
Some(SubstreamState::OutWaitingAnswer(substream, user_data)),
None,
false,
),
Poll::Ready(Some(Err(error))) => {
let event = KademliaHandlerEvent::QueryError {
error: KademliaHandlerQueryErr::Io(error),
user_data,
};
(None, Some(ProtocolsHandlerEvent::Custom(event)), false)
}
Poll::Ready(None) => {
let event = KademliaHandlerEvent::QueryError {
error: KademliaHandlerQueryErr::Io(io::ErrorKind::UnexpectedEof.into()),
user_data,
};
(None, Some(ProtocolsHandlerEvent::Custom(event)), false)
}
}
Poll::Pending => (
Some(SubstreamState::OutWaitingAnswer(substream, user_data)),
None,
false,
),
Poll::Ready(Some(Err(error))) => {
let event = KademliaHandlerEvent::QueryError {
error: KademliaHandlerQueryErr::Io(error),
user_data,
};
(None, Some(ProtocolsHandlerEvent::Custom(event)), false)
}
Poll::Ready(None) => {
let event = KademliaHandlerEvent::QueryError {
error: KademliaHandlerQueryErr::Io(io::ErrorKind::UnexpectedEof.into()),
user_data,
};
(None, Some(ProtocolsHandlerEvent::Custom(event)), false)
}
},
}
SubstreamState::OutReportError(error, user_data) => {
let event = KademliaHandlerEvent::QueryError { error, user_data };
(None, Some(ProtocolsHandlerEvent::Custom(event)), false)
}
SubstreamState::OutClosing(mut stream) => match Sink::poll_close(Pin::new(&mut stream), cx) {
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 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)),
Some(ProtocolsHandlerEvent::Custom(ev)),
false,
)
} else {
(Some(SubstreamState::InClosing(substream)), None, true)
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)),
Some(ProtocolsHandlerEvent::Custom(ev)),
false,
)
} else {
(Some(SubstreamState::InClosing(substream)), None, true)
}
}
Poll::Pending => (
Some(SubstreamState::InWaitingMessage(id, substream)),
None,
false,
),
Poll::Ready(None) => {
trace!("Inbound substream: EOF");
(None, None, false)
}
Poll::Ready(Some(Err(e))) => {
trace!("Inbound substream error: {:?}", e);
(None, None, false)
}
}
Poll::Pending => (
Some(SubstreamState::InWaitingMessage(id, substream)),
None,
false,
),
Poll::Ready(None) => {
trace!("Inbound substream: EOF");
(None, None, false)
}
Poll::Ready(Some(Err(e))) => {
trace!("Inbound substream error: {:?}", e);
(None, None, false)
},
},
}
SubstreamState::InWaitingUser(id, substream) => (
Some(SubstreamState::InWaitingUser(id, substream)),
None,
false,
),
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)),
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,
),
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,
),
Err(_) => (None, None, false),
},
Poll::Pending => (
Some(SubstreamState::InPendingSend(id, substream, msg)),
None,
false,
),
Poll::Ready(Err(_)) => (None, None, false),
Poll::Pending => (
Some(SubstreamState::InPendingFlush(id, substream)),
None,
false,
),
Poll::Ready(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),
}
}
SubstreamState::InPendingFlush(id, mut substream) => match Sink::poll_flush(Pin::new(&mut substream), cx) {
Poll::Ready(Ok(())) => (
Some(SubstreamState::InWaitingMessage(id, substream)),
None,
true,
),
Poll::Pending => (
Some(SubstreamState::InPendingFlush(id, substream)),
None,
false,
),
Poll::Ready(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),
},
}
}
@ -987,7 +1022,7 @@ fn process_kad_request<TUserData>(
KadRequestMsg::PutValue { record } => Ok(KademliaHandlerEvent::PutRecord {
record,
request_id: KademliaRequestId { connec_unique_id },
})
}),
}
}
@ -1005,11 +1040,9 @@ fn process_kad_response<TUserData>(
user_data,
}
}
KadResponseMsg::FindNode { closer_peers } => {
KademliaHandlerEvent::FindNodeRes {
closer_peers,
user_data,
}
KadResponseMsg::FindNode { closer_peers } => KademliaHandlerEvent::FindNodeRes {
closer_peers,
user_data,
},
KadResponseMsg::GetProviders {
closer_peers,
@ -1027,12 +1060,10 @@ fn process_kad_response<TUserData>(
closer_peers,
user_data,
},
KadResponseMsg::PutValue { key, value, .. } => {
KademliaHandlerEvent::PutRecordRes {
key,
value,
user_data,
}
}
KadResponseMsg::PutValue { key, value, .. } => KademliaHandlerEvent::PutRecordRes {
key,
value,
user_data,
},
}
}