pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-14 01:41:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

Run cargo fmt on the whole code base (#9394)

Browse Source 
* Run cargo fmt on the whole code base

* Second run

* Add CI check

* Fix compilation

* More unnecessary braces

* Handle weights

* Use --all

* Use correct attributes...

* Fix UI tests

* AHHHHHHHHH

* 🤦

* Docs

* Fix compilation

* 🤷

* Please stop

* 🤦 x 2

* More

* make rustfmt.toml consistent with polkadot

Co-authored-by: André Silva <andrerfosilva@gmail.com>
This commit is contained in:
Bastian Köcher
2021-07-21 16:32:32 +02:00
committed by GitHub
parent d451c38c1c
commit 7b56ab15b4
1010 changed files with 53339 additions and 51208 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/client/peerset/src/lib.rs
+97 -86
View File
@@ -34,13 +34,17 @@
mod peersstate;
use std::{collections::HashSet, collections::VecDeque};
use futures::prelude::*;
use log::{debug, error, trace};
use serde_json::json;
use std::{collections::HashMap, pin::Pin, task::{Context, Poll}, time::Duration};
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender};
use std::{
collections::{HashMap, HashSet, VecDeque},
pin::Pin,
task::{Context, Poll},
time::Duration,
};
use wasm_timer::{Delay, Instant};
use sp_utils::mpsc::{tracing_unbounded, TracingUnboundedSender, TracingUnboundedReceiver};
pub use libp2p::PeerId;
@@ -262,23 +266,22 @@ impl Peerset {
pub fn from_config(config: PeersetConfig) -> (Peerset, PeersetHandle) {
let (tx, rx) = tracing_unbounded("mpsc_peerset_messages");
let handle = PeersetHandle {
tx: tx.clone(),
};
let handle = PeersetHandle { tx: tx.clone() };
let mut peerset = {
let now = Instant::now();
Peerset {
data: peersstate::PeersState::new(config.sets.iter().map(|set| peersstate::SetConfig {
in_peers: set.in_peers,
out_peers: set.out_peers,
data: peersstate::PeersState::new(config.sets.iter().map(|set| {
peersstate::SetConfig { in_peers: set.in_peers, out_peers: set.out_peers }
})),
tx,
rx,
reserved_nodes: config.sets.iter().map(|set| {
(set.reserved_nodes.clone(), set.reserved_only)
}).collect(),
reserved_nodes: config
.sets
.iter()
.map(|set| (set.reserved_nodes.clone(), set.reserved_only))
.collect(),
message_queue: VecDeque::new(),
created: now,
latest_time_update: now,
@@ -310,7 +313,7 @@ impl Peerset {
fn on_add_reserved_peer(&mut self, set_id: SetId, peer_id: PeerId) {
let newly_inserted = self.reserved_nodes[set_id.0].0.insert(peer_id.clone());
if !newly_inserted {
return;
return
}
self.data.add_no_slot_node(set_id.0, peer_id);
@@ -319,34 +322,36 @@ impl Peerset {
fn on_remove_reserved_peer(&mut self, set_id: SetId, peer_id: PeerId) {
if !self.reserved_nodes[set_id.0].0.remove(&peer_id) {
return;
return
}
self.data.remove_no_slot_node(set_id.0, &peer_id);
// Nothing more to do if not in reserved-only mode.
if !self.reserved_nodes[set_id.0].1 {
return;
return
}
// If, however, the peerset is in reserved-only mode, then the removed node needs to be
// disconnected.
if let peersstate::Peer::Connected(peer) = self.data.peer(set_id.0, &peer_id) {
peer.disconnect();
self.message_queue.push_back(Message::Drop {
set_id,
peer_id,
});
self.message_queue.push_back(Message::Drop { set_id, peer_id });
}
}
fn on_set_reserved_peers(&mut self, set_id: SetId, peer_ids: HashSet<PeerId>) {
// Determine the difference between the current group and the new list.
let (to_insert, to_remove) = {
let to_insert = peer_ids.difference(&self.reserved_nodes[set_id.0].0)
.cloned().collect::<Vec<_>>();
let to_remove = self.reserved_nodes[set_id.0].0.difference(&peer_ids)
.cloned().collect::<Vec<_>>();
let to_insert = peer_ids
.difference(&self.reserved_nodes[set_id.0].0)
.cloned()
.collect::<Vec<_>>();
let to_remove = self.reserved_nodes[set_id.0]
.0
.difference(&peer_ids)
.cloned()
.collect::<Vec<_>>();
(to_insert, to_remove)
};
@@ -364,20 +369,19 @@ impl Peerset {
if reserved_only {
// Disconnect all the nodes that aren't reserved.
for peer_id in self.data.connected_peers(set_id.0).cloned().collect::<Vec<_>>().into_iter() {
for peer_id in
self.data.connected_peers(set_id.0).cloned().collect::<Vec<_>>().into_iter()
{
if self.reserved_nodes[set_id.0].0.contains(&peer_id) {
continue;
continue
}
let peer = self.data.peer(set_id.0, &peer_id).into_connected()
.expect("We are enumerating connected peers, therefore the peer is connected; qed");
let peer = self.data.peer(set_id.0, &peer_id).into_connected().expect(
"We are enumerating connected peers, therefore the peer is connected; qed",
);
peer.disconnect();
self.message_queue.push_back(Message::Drop {
set_id,
peer_id
});
self.message_queue.push_back(Message::Drop { set_id, peer_id });
}
} else {
self.alloc_slots(set_id);
}
@@ -402,19 +406,19 @@ impl Peerset {
fn on_remove_from_peers_set(&mut self, set_id: SetId, peer_id: PeerId) {
// Don't do anything if node is reserved.
if self.reserved_nodes[set_id.0].0.contains(&peer_id) {
return;
return
}
match self.data.peer(set_id.0, &peer_id) {
peersstate::Peer::Connected(peer) => {
self.message_queue.push_back(Message::Drop {
set_id,
peer_id: peer.peer_id().clone(),
});
self.message_queue
.push_back(Message::Drop { set_id, peer_id: peer.peer_id().clone() });
peer.disconnect().forget_peer();
}
peersstate::Peer::NotConnected(peer) => { peer.forget_peer(); }
peersstate::Peer::Unknown(_) => {}
},
peersstate::Peer::NotConnected(peer) => {
peer.forget_peer();
},
peersstate::Peer::Unknown(_) => {},
}
}
@@ -428,7 +432,7 @@ impl Peerset {
trace!(target: "peerset", "Report {}: {:+} to {}. Reason: {}",
peer_id, change.value, reputation.reputation(), change.reason
);
return;
return
}
debug!(target: "peerset", "Report {}: {:+} to {}. Reason: {}, Disconnecting",
@@ -490,7 +494,7 @@ impl Peerset {
peer_reputation.set_reputation(after);
if after != 0 {
continue;
continue
}
drop(peer_reputation);
@@ -499,15 +503,15 @@ impl Peerset {
// forget it.
for set_index in 0..self.data.num_sets() {
match self.data.peer(set_index, &peer_id) {
peersstate::Peer::Connected(_) => {}
peersstate::Peer::Connected(_) => {},
peersstate::Peer::NotConnected(peer) => {
if peer.last_connected_or_discovered() + FORGET_AFTER < now {
peer.forget_peer();
}
}
},
peersstate::Peer::Unknown(_) => {
// Happens if this peer does not belong to this set.
}
},
}
}
}
@@ -531,14 +535,13 @@ impl Peerset {
// remove that check. If necessary, the peerset should be refactored to give more
// control over what happens in that situation.
if entry.reputation() < BANNED_THRESHOLD {
break;
break
}
match entry.try_outgoing() {
Ok(conn) => self.message_queue.push_back(Message::Connect {
set_id,
peer_id: conn.into_peer_id()
}),
Ok(conn) => self
.message_queue
.push_back(Message::Connect { set_id, peer_id: conn.into_peer_id() }),
Err(_) => {
// An error is returned only if no slot is available. Reserved nodes are
// marked in the state machine with a flag saying "doesn't occupy a slot",
@@ -548,7 +551,7 @@ impl Peerset {
target: "peerset",
"Not enough slots to connect to reserved node"
);
}
},
}
}
@@ -556,7 +559,7 @@ impl Peerset {
// Nothing more to do if we're in reserved mode.
if self.reserved_nodes[set_id.0].1 {
return;
return
}
// Try to grab the next node to attempt to connect to.
@@ -565,25 +568,24 @@ impl Peerset {
while self.data.has_free_outgoing_slot(set_id.0) {
let next = match self.data.highest_not_connected_peer(set_id.0) {
Some(n) => n,
None => break
None => break,
};
// Don't connect to nodes with an abysmal reputation.
if next.reputation() < BANNED_THRESHOLD {
break;
break
}
match next.try_outgoing() {
Ok(conn) => self.message_queue.push_back(Message::Connect {
set_id,
peer_id: conn.into_peer_id()
}),
Ok(conn) => self
.message_queue
.push_back(Message::Connect { set_id, peer_id: conn.into_peer_id() }),
Err(_) => {
// This branch can only be entered if there is no free slot, which is
// checked above.
debug_assert!(false);
break;
}
break
},
}
}
}
@@ -594,7 +596,6 @@ impl Peerset {
/// Note that this mechanism is orthogonal to `Connect`/`Drop`. Accepting an incoming
/// connection implicitly means `Connect`, but incoming connections aren't cancelled by
/// `dropped`.
///
// Implementation note: because of concurrency issues, it is possible that we push a `Connect`
// message to the output channel with a `PeerId`, and that `incoming` gets called with the same
// `PeerId` before that message has been read by the user. In this situation we must not answer.
@@ -606,7 +607,7 @@ impl Peerset {
if self.reserved_nodes[set_id.0].1 {
if !self.reserved_nodes[set_id.0].0.contains(&peer_id) {
self.message_queue.push_back(Message::Reject(index));
return;
return
}
}
@@ -646,7 +647,7 @@ impl Peerset {
trace!(target: "peerset", "Dropping {}: {:+} to {}",
peer_id, DISCONNECT_REPUTATION_CHANGE, entry.reputation());
entry.disconnect();
}
},
peersstate::Peer::NotConnected(_) | peersstate::Peer::Unknown(_) =>
error!(target: "peerset", "Received dropped() for non-connected node"),
}
@@ -710,10 +711,11 @@ impl Stream for Peerset {
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
loop {
if let Some(message) = self.message_queue.pop_front() {
return Poll::Ready(Some(message));
return Poll::Ready(Some(message))
}
if let Poll::Ready(_) = Future::poll(Pin::new(&mut self.next_periodic_alloc_slots), cx) {
if let Poll::Ready(_) = Future::poll(Pin::new(&mut self.next_periodic_alloc_slots), cx)
{
self.next_periodic_alloc_slots = Delay::new(Duration::new(1, 0));
for set_index in 0..self.data.num_sets() {
@@ -736,8 +738,7 @@ impl Stream for Peerset {
self.on_set_reserved_peers(set_id, peer_ids),
Action::SetReservedOnly(set_id, reserved) =>
self.on_set_reserved_only(set_id, reserved),
Action::ReportPeer(peer_id, score_diff) =>
self.on_report_peer(peer_id, score_diff),
Action::ReportPeer(peer_id, score_diff) => self.on_report_peer(peer_id, score_diff),
Action::AddToPeersSet(sets_name, peer_id) =>
self.add_to_peers_set(sets_name, peer_id),
Action::RemoveFromPeersSet(sets_name, peer_id) =>
@@ -760,9 +761,12 @@ pub enum DropReason {
#[cfg(test)]
mod tests {
use libp2p::PeerId;
use super::{
IncomingIndex, Message, Peerset, PeersetConfig, ReputationChange, SetConfig, SetId,
BANNED_THRESHOLD,
};
use futures::prelude::*;
use super::{PeersetConfig, Peerset, Message, IncomingIndex, ReputationChange, SetConfig, SetId, BANNED_THRESHOLD};
use libp2p::PeerId;
use std::{pin::Pin, task::Poll, thread, time::Duration};
fn assert_messages(mut peerset: Peerset, messages: Vec<Message>) -> Peerset {
@@ -799,10 +803,13 @@ mod tests {
handle.add_reserved_peer(SetId::from(0), reserved_peer.clone());
handle.add_reserved_peer(SetId::from(0), reserved_peer2.clone());
assert_messages(peerset, vec![
Message::Connect { set_id: SetId::from(0), peer_id: reserved_peer },
Message::Connect { set_id: SetId::from(0), peer_id: reserved_peer2 }
]);
assert_messages(
peerset,
vec![
Message::Connect { set_id: SetId::from(0), peer_id: reserved_peer },
Message::Connect { set_id: SetId::from(0), peer_id: reserved_peer2 },
],
);
}
#[test]
@@ -831,12 +838,15 @@ mod tests {
peerset.incoming(SetId::from(0), incoming2.clone(), ii2);
peerset.incoming(SetId::from(0), incoming3.clone(), ii3);
assert_messages(peerset, vec![
Message::Connect { set_id: SetId::from(0), peer_id: bootnode.clone() },
Message::Accept(ii),
Message::Accept(ii2),
Message::Reject(ii3),
]);
assert_messages(
peerset,
vec![
Message::Connect { set_id: SetId::from(0), peer_id: bootnode.clone() },
Message::Accept(ii),
Message::Accept(ii2),
Message::Reject(ii3),
],
);
}
#[test]
@@ -856,9 +866,7 @@ mod tests {
let (mut peerset, _) = Peerset::from_config(config);
peerset.incoming(SetId::from(0), incoming.clone(), ii);
assert_messages(peerset, vec![
Message::Reject(ii),
]);
assert_messages(peerset, vec![Message::Reject(ii)]);
}
#[test]
@@ -881,10 +889,13 @@ mod tests {
peerset.add_to_peers_set(SetId::from(0), discovered.clone());
peerset.add_to_peers_set(SetId::from(0), discovered2);
assert_messages(peerset, vec![
Message::Connect { set_id: SetId::from(0), peer_id: bootnode },
Message::Connect { set_id: SetId::from(0), peer_id: discovered },
]);
assert_messages(
peerset,
vec![
Message::Connect { set_id: SetId::from(0), peer_id: bootnode },
Message::Connect { set_id: SetId::from(0), peer_id: discovered },
],
);
}
#[test]
substrate/client/peerset/src/peersstate.rs
+65 -180
View File
@@ -32,7 +32,10 @@ use libp2p::PeerId;
use log::error;
use std::{
borrow::Cow,
collections::{HashMap, HashSet, hash_map::{Entry, OccupiedEntry}},
collections::{
hash_map::{Entry, OccupiedEntry},
HashMap, HashSet,
},
};
use wasm_timer::Instant;
@@ -42,7 +45,6 @@ use wasm_timer::Instant;
///
/// This struct is nothing more but a data structure containing a list of nodes, where each node
/// has a reputation and is either connected to us or not.
///
#[derive(Debug, Clone)]
pub struct PeersState {
/// List of nodes that we know about.
@@ -104,10 +106,7 @@ struct Node {
impl Node {
fn new(num_sets: usize) -> Node {
Node {
sets: (0..num_sets).map(|_| MembershipState::NotMember).collect(),
reputation: 0,
}
Node { sets: (0..num_sets).map(|_| MembershipState::NotMember).collect(), reputation: 0 }
}
}
@@ -185,25 +184,16 @@ impl PeersState {
/// # Panic
///
/// `set` must be within range of the sets passed to [`PeersState::new`].
///
pub fn peer<'a>(&'a mut self, set: usize, peer_id: &'a PeerId) -> Peer<'a> {
// The code below will panic anyway if this happens to be false, but this earlier assert
// makes it explicit what is wrong.
assert!(set < self.sets.len());
match self.nodes.get_mut(peer_id).map(|p| &p.sets[set]) {
None | Some(MembershipState::NotMember) => Peer::Unknown(UnknownPeer {
parent: self,
set,
peer_id: Cow::Borrowed(peer_id),
}),
Some(MembershipState::In) | Some(MembershipState::Out) => {
Peer::Connected(ConnectedPeer {
state: self,
set,
peer_id: Cow::Borrowed(peer_id),
})
}
None | Some(MembershipState::NotMember) =>
Peer::Unknown(UnknownPeer { parent: self, set, peer_id: Cow::Borrowed(peer_id) }),
Some(MembershipState::In) | Some(MembershipState::Out) =>
Peer::Connected(ConnectedPeer { state: self, set, peer_id: Cow::Borrowed(peer_id) }),
Some(MembershipState::NotConnected { .. }) => Peer::NotConnected(NotConnectedPeer {
state: self,
set,
@@ -224,7 +214,6 @@ impl PeersState {
/// # Panic
///
/// `set` must be within range of the sets passed to [`PeersState::new`].
///
// Note: this method could theoretically return a `ConnectedPeer`, but implementing that
// isn't simple.
pub fn connected_peers(&self, set: usize) -> impl Iterator<Item = &PeerId> {
@@ -245,7 +234,6 @@ impl PeersState {
/// # Panic
///
/// `set` must be within range of the sets passed to [`PeersState::new`].
///
pub fn highest_not_connected_peer(&mut self, set: usize) -> Option<NotConnectedPeer> {
// The code below will panic anyway if this happens to be false, but this earlier assert
// makes it explicit what is wrong.
@@ -254,18 +242,16 @@ impl PeersState {
let outcome = self
.nodes
.iter_mut()
.filter(|(_, Node { sets, .. })| {
match sets[set] {
MembershipState::NotMember => false,
MembershipState::In => false,
MembershipState::Out => false,
MembershipState::NotConnected { .. } => true,
}
.filter(|(_, Node { sets, .. })| match sets[set] {
MembershipState::NotMember => false,
MembershipState::In => false,
MembershipState::Out => false,
MembershipState::NotConnected { .. } => true,
})
.fold(None::<(&PeerId, &mut Node)>, |mut cur_node, to_try| {
if let Some(cur_node) = cur_node.take() {
if cur_node.1.reputation >= to_try.1.reputation {
return Some(cur_node);
return Some(cur_node)
}
}
Some(to_try)
@@ -273,10 +259,10 @@ impl PeersState {
.map(|(peer_id, _)| peer_id.clone());
outcome.map(move |peer_id| NotConnectedPeer {
state: self,
set,
peer_id: Cow::Owned(peer_id),
})
state: self,
set,
peer_id: Cow::Owned(peer_id),
})
}
/// Returns `true` if there is a free outgoing slot available related to this set.
@@ -290,14 +276,14 @@ impl PeersState {
pub fn add_no_slot_node(&mut self, set: usize, peer_id: PeerId) {
// Reminder: `HashSet::insert` returns false if the node was already in the set
if !self.sets[set].no_slot_nodes.insert(peer_id.clone()) {
return;
return
}
if let Some(peer) = self.nodes.get_mut(&peer_id) {
match peer.sets[set] {
MembershipState::In => self.sets[set].num_in -= 1,
MembershipState::Out => self.sets[set].num_out -= 1,
MembershipState::NotConnected { .. } | MembershipState::NotMember => {}
MembershipState::NotConnected { .. } | MembershipState::NotMember => {},
}
}
}
@@ -308,14 +294,14 @@ impl PeersState {
pub fn remove_no_slot_node(&mut self, set: usize, peer_id: &PeerId) {
// Reminder: `HashSet::remove` returns false if the node was already not in the set
if !self.sets[set].no_slot_nodes.remove(peer_id) {
return;
return
}
if let Some(peer) = self.nodes.get_mut(peer_id) {
match peer.sets[set] {
MembershipState::In => self.sets[set].num_in += 1,
MembershipState::Out => self.sets[set].num_out += 1,
MembershipState::NotConnected { .. } | MembershipState::NotMember => {}
MembershipState::NotConnected { .. } | MembershipState::NotMember => {},
}
}
}
@@ -396,24 +382,15 @@ impl<'a> ConnectedPeer<'a> {
false,
"State inconsistency: disconnecting a disconnected node"
)
}
},
}
}
node.sets[self.set] = MembershipState::NotConnected {
last_connected: Instant::now(),
};
node.sets[self.set] = MembershipState::NotConnected { last_connected: Instant::now() };
} else {
debug_assert!(
false,
"State inconsistency: disconnecting a disconnected node"
);
debug_assert!(false, "State inconsistency: disconnecting a disconnected node");
}
NotConnectedPeer {
state: self.state,
set: self.set,
peer_id: self.peer_id,
}
NotConnectedPeer { state: self.state, set: self.set, peer_id: self.peer_id }
}
/// Performs an arithmetic addition on the reputation score of that peer.
@@ -425,10 +402,7 @@ impl<'a> ConnectedPeer<'a> {
if let Some(node) = self.state.nodes.get_mut(&*self.peer_id) {
node.reputation = node.reputation.saturating_add(modifier);
} else {
debug_assert!(
false,
"State inconsistency: add_reputation on an unknown node"
);
debug_assert!(false, "State inconsistency: add_reputation on an unknown node");
}
}
@@ -436,10 +410,7 @@ impl<'a> ConnectedPeer<'a> {
///
/// > **Note**: Reputation values aren't specific to a set but are global per peer.
pub fn reputation(&self) -> i32 {
self.state
.nodes
.get(&*self.peer_id)
.map_or(0, |p| p.reputation)
self.state.nodes.get(&*self.peer_id).map_or(0, |p| p.reputation)
}
}
@@ -483,8 +454,8 @@ impl<'a> NotConnectedPeer<'a> {
"State inconsistency with {}; not connected after borrow",
self.peer_id
);
return Instant::now();
}
return Instant::now()
},
};
match state.sets[self.set] {
@@ -492,7 +463,7 @@ impl<'a> NotConnectedPeer<'a> {
_ => {
error!(target: "peerset", "State inconsistency with {}", self.peer_id);
Instant::now()
}
},
}
}
@@ -508,7 +479,7 @@ impl<'a> NotConnectedPeer<'a> {
// Note that it is possible for num_out to be strictly superior to the max, in case we were
// connected to reserved node then marked them as not reserved.
if !self.state.has_free_outgoing_slot(self.set) && !is_no_slot_occupy {
return Err(self);
return Err(self)
}
if let Some(peer) = self.state.nodes.get_mut(&*self.peer_id) {
@@ -517,17 +488,10 @@ impl<'a> NotConnectedPeer<'a> {
self.state.sets[self.set].num_out += 1;
}
} else {
debug_assert!(
false,
"State inconsistency: try_outgoing on an unknown node"
);
debug_assert!(false, "State inconsistency: try_outgoing on an unknown node");
}
Ok(ConnectedPeer {
state: self.state,
set: self.set,
peer_id: self.peer_id,
})
Ok(ConnectedPeer { state: self.state, set: self.set, peer_id: self.peer_id })
}
/// Tries to accept the peer as an incoming connection.
@@ -541,10 +505,10 @@ impl<'a> NotConnectedPeer<'a> {
// Note that it is possible for num_in to be strictly superior to the max, in case we were
// connected to reserved node then marked them as not reserved.
if self.state.sets[self.set].num_in >= self.state.sets[self.set].max_in
&& !is_no_slot_occupy
if self.state.sets[self.set].num_in >= self.state.sets[self.set].max_in &&
!is_no_slot_occupy
{
return Err(self);
return Err(self)
}
if let Some(peer) = self.state.nodes.get_mut(&*self.peer_id) {
@@ -553,27 +517,17 @@ impl<'a> NotConnectedPeer<'a> {
self.state.sets[self.set].num_in += 1;
}
} else {
debug_assert!(
false,
"State inconsistency: try_accept_incoming on an unknown node"
);
debug_assert!(false, "State inconsistency: try_accept_incoming on an unknown node");
}
Ok(ConnectedPeer {
state: self.state,
set: self.set,
peer_id: self.peer_id,
})
Ok(ConnectedPeer { state: self.state, set: self.set, peer_id: self.peer_id })
}
/// Returns the reputation value of the node.
///
/// > **Note**: Reputation values aren't specific to a set but are global per peer.
pub fn reputation(&self) -> i32 {
self.state
.nodes
.get(&*self.peer_id)
.map_or(0, |p| p.reputation)
self.state.nodes.get(&*self.peer_id).map_or(0, |p| p.reputation)
}
/// Sets the reputation of the peer.
@@ -584,10 +538,7 @@ impl<'a> NotConnectedPeer<'a> {
if let Some(node) = self.state.nodes.get_mut(&*self.peer_id) {
node.reputation = value;
} else {
debug_assert!(
false,
"State inconsistency: set_reputation on an unknown node"
);
debug_assert!(false, "State inconsistency: set_reputation on an unknown node");
}
}
@@ -598,10 +549,8 @@ impl<'a> NotConnectedPeer<'a> {
peer.sets[self.set] = MembershipState::NotMember;
// Remove the peer from `self.state.nodes` entirely if it isn't a member of any set.
if peer.reputation == 0 && peer
.sets
.iter()
.all(|set| matches!(set, MembershipState::NotMember))
if peer.reputation == 0 &&
peer.sets.iter().all(|set| matches!(set, MembershipState::NotMember))
{
self.state.nodes.remove(&*self.peer_id);
}
@@ -614,11 +563,7 @@ impl<'a> NotConnectedPeer<'a> {
);
};
UnknownPeer {
parent: self.state,
set: self.set,
peer_id: self.peer_id,
}
UnknownPeer { parent: self.state, set: self.set, peer_id: self.peer_id }
}
}
@@ -641,15 +586,9 @@ impl<'a> UnknownPeer<'a> {
.nodes
.entry(self.peer_id.clone().into_owned())
.or_insert_with(|| Node::new(num_sets))
.sets[self.set] = MembershipState::NotConnected {
last_connected: Instant::now(),
};
.sets[self.set] = MembershipState::NotConnected { last_connected: Instant::now() };
NotConnectedPeer {
state: self.parent,
set: self.set,
peer_id: self.peer_id,
}
NotConnectedPeer { state: self.parent, set: self.set, peer_id: self.peer_id }
}
}
@@ -699,10 +638,7 @@ mod tests {
#[test]
fn full_slots_in() {
let mut peers_state = PeersState::new(iter::once(SetConfig {
in_peers: 1,
out_peers: 1,
}));
let mut peers_state = PeersState::new(iter::once(SetConfig { in_peers: 1, out_peers: 1 }));
let id1 = PeerId::random();
let id2 = PeerId::random();
@@ -717,10 +653,7 @@ mod tests {
#[test]
fn no_slot_node_doesnt_use_slot() {
let mut peers_state = PeersState::new(iter::once(SetConfig {
in_peers: 1,
out_peers: 1,
}));
let mut peers_state = PeersState::new(iter::once(SetConfig { in_peers: 1, out_peers: 1 }));
let id1 = PeerId::random();
let id2 = PeerId::random();
@@ -740,10 +673,7 @@ mod tests {
#[test]
fn disconnecting_frees_slot() {
let mut peers_state = PeersState::new(iter::once(SetConfig {
in_peers: 1,
out_peers: 1,
}));
let mut peers_state = PeersState::new(iter::once(SetConfig { in_peers: 1, out_peers: 1 }));
let id1 = PeerId::random();
let id2 = PeerId::random();
@@ -761,11 +691,7 @@ mod tests {
.discover()
.try_accept_incoming()
.is_err());
peers_state
.peer(0, &id1)
.into_connected()
.unwrap()
.disconnect();
peers_state.peer(0, &id1).into_connected().unwrap().disconnect();
assert!(peers_state
.peer(0, &id2)
.into_not_connected()
@@ -776,41 +702,21 @@ mod tests {
#[test]
fn highest_not_connected_peer() {
let mut peers_state = PeersState::new(iter::once(SetConfig {
in_peers: 25,
out_peers: 25,
}));
let mut peers_state =
PeersState::new(iter::once(SetConfig { in_peers: 25, out_peers: 25 }));
let id1 = PeerId::random();
let id2 = PeerId::random();
assert!(peers_state.highest_not_connected_peer(0).is_none());
peers_state
.peer(0, &id1)
.into_unknown()
.unwrap()
.discover()
.set_reputation(50);
peers_state
.peer(0, &id2)
.into_unknown()
.unwrap()
.discover()
.set_reputation(25);
peers_state.peer(0, &id1).into_unknown().unwrap().discover().set_reputation(50);
peers_state.peer(0, &id2).into_unknown().unwrap().discover().set_reputation(25);
assert_eq!(
peers_state
.highest_not_connected_peer(0)
.map(|p| p.into_peer_id()),
peers_state.highest_not_connected_peer(0).map(|p| p.into_peer_id()),
Some(id1.clone())
);
peers_state
.peer(0, &id2)
.into_not_connected()
.unwrap()
.set_reputation(75);
peers_state.peer(0, &id2).into_not_connected().unwrap().set_reputation(75);
assert_eq!(
peers_state
.highest_not_connected_peer(0)
.map(|p| p.into_peer_id()),
peers_state.highest_not_connected_peer(0).map(|p| p.into_peer_id()),
Some(id2.clone())
);
peers_state
@@ -820,46 +726,25 @@ mod tests {
.try_accept_incoming()
.unwrap();
assert_eq!(
peers_state
.highest_not_connected_peer(0)
.map(|p| p.into_peer_id()),
peers_state.highest_not_connected_peer(0).map(|p| p.into_peer_id()),
Some(id1.clone())
);
peers_state
.peer(0, &id1)
.into_not_connected()
.unwrap()
.set_reputation(100);
peers_state
.peer(0, &id2)
.into_connected()
.unwrap()
.disconnect();
peers_state.peer(0, &id1).into_not_connected().unwrap().set_reputation(100);
peers_state.peer(0, &id2).into_connected().unwrap().disconnect();
assert_eq!(
peers_state
.highest_not_connected_peer(0)
.map(|p| p.into_peer_id()),
peers_state.highest_not_connected_peer(0).map(|p| p.into_peer_id()),
Some(id1.clone())
);
peers_state
.peer(0, &id1)
.into_not_connected()
.unwrap()
.set_reputation(-100);
peers_state.peer(0, &id1).into_not_connected().unwrap().set_reputation(-100);
assert_eq!(
peers_state
.highest_not_connected_peer(0)
.map(|p| p.into_peer_id()),
peers_state.highest_not_connected_peer(0).map(|p| p.into_peer_id()),
Some(id2.clone())
);
}
#[test]
fn disconnect_no_slot_doesnt_panic() {
let mut peers_state = PeersState::new(iter::once(SetConfig {
in_peers: 1,
out_peers: 1,
}));
let mut peers_state = PeersState::new(iter::once(SetConfig { in_peers: 1, out_peers: 1 }));
let id = PeerId::random();
peers_state.add_no_slot_node(0, id.clone());
let peer = peers_state