2019-10-17 15:42:19 -07:00
|
|
|
//! The addressbook manages information about what peers exist, when they were
|
|
|
|
//! seen, and what services they provide.
|
|
|
|
|
|
|
|
use std::{
|
2019-10-17 21:19:23 -07:00
|
|
|
collections::{BTreeSet, HashMap},
|
2019-10-17 17:54:08 -07:00
|
|
|
iter::Extend,
|
2019-10-17 15:42:19 -07:00
|
|
|
net::SocketAddr,
|
|
|
|
};
|
|
|
|
|
|
|
|
use chrono::{DateTime, Utc};
|
2019-10-21 15:56:16 -07:00
|
|
|
use tracing::Span;
|
2019-10-17 15:42:19 -07:00
|
|
|
|
2021-02-17 17:18:32 -08:00
|
|
|
use crate::{constants, types::MetaAddr, PeerAddrState};
|
2019-10-17 15:42:19 -07:00
|
|
|
|
|
|
|
/// A database of peers, their advertised services, and information on when they
|
|
|
|
/// were last seen.
|
2019-10-21 15:56:16 -07:00
|
|
|
#[derive(Debug)]
|
2019-10-17 15:42:19 -07:00
|
|
|
pub struct AddressBook {
|
2021-02-17 17:18:32 -08:00
|
|
|
/// Each known peer address has a matching `MetaAddr`
|
|
|
|
by_addr: HashMap<SocketAddr, MetaAddr>,
|
|
|
|
|
|
|
|
/// The span for operations on this address book.
|
2019-10-21 15:56:16 -07:00
|
|
|
span: Span,
|
2019-10-17 15:42:19 -07:00
|
|
|
}
|
|
|
|
|
2021-03-15 04:52:58 -07:00
|
|
|
/// Metrics about the states of the addresses in an [`AddressBook`].
|
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct AddressMetrics {
|
|
|
|
/// The number of addresses in the `Responded` state.
|
|
|
|
responded: usize,
|
|
|
|
|
|
|
|
/// The number of addresses in the `NeverAttempted` state.
|
|
|
|
never_attempted: usize,
|
|
|
|
|
|
|
|
/// The number of addresses in the `Failed` state.
|
|
|
|
failed: usize,
|
|
|
|
|
|
|
|
/// The number of addresses in the `AttemptPending` state.
|
|
|
|
attempt_pending: usize,
|
|
|
|
|
|
|
|
/// The number of `Responded` addresses within the liveness limit.
|
|
|
|
recently_live: usize,
|
|
|
|
|
|
|
|
/// The number of `Responded` addresses outside the liveness limit.
|
|
|
|
recently_stopped_responding: usize,
|
|
|
|
}
|
|
|
|
|
2020-02-04 22:53:24 -08:00
|
|
|
#[allow(clippy::len_without_is_empty)]
|
2019-10-17 15:42:19 -07:00
|
|
|
impl AddressBook {
|
2019-10-21 15:56:16 -07:00
|
|
|
/// Construct an `AddressBook` with the given [`tracing::Span`].
|
|
|
|
pub fn new(span: Span) -> AddressBook {
|
2021-02-17 17:18:32 -08:00
|
|
|
let constructor_span = span.clone();
|
|
|
|
let _guard = constructor_span.enter();
|
|
|
|
|
|
|
|
let new_book = AddressBook {
|
2019-10-21 15:56:16 -07:00
|
|
|
by_addr: HashMap::default(),
|
|
|
|
span,
|
2021-02-17 17:18:32 -08:00
|
|
|
};
|
|
|
|
|
|
|
|
new_book.update_metrics();
|
|
|
|
new_book
|
2019-10-21 15:56:16 -07:00
|
|
|
}
|
|
|
|
|
2020-08-11 13:07:44 -07:00
|
|
|
/// Get the contents of `self` in random order with sanitized timestamps.
|
|
|
|
pub fn sanitized(&self) -> Vec<MetaAddr> {
|
|
|
|
use rand::seq::SliceRandom;
|
2021-02-17 17:18:32 -08:00
|
|
|
let _guard = self.span.enter();
|
2020-08-11 13:07:44 -07:00
|
|
|
let mut peers = self.peers().map(MetaAddr::sanitize).collect::<Vec<_>>();
|
|
|
|
peers.shuffle(&mut rand::thread_rng());
|
|
|
|
peers
|
|
|
|
}
|
|
|
|
|
2019-10-18 11:04:38 -07:00
|
|
|
/// Returns true if the address book has an entry for `addr`.
|
|
|
|
pub fn contains_addr(&self, addr: &SocketAddr) -> bool {
|
2019-10-21 15:56:16 -07:00
|
|
|
let _guard = self.span.enter();
|
2019-10-18 11:04:38 -07:00
|
|
|
self.by_addr.contains_key(addr)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns the entry corresponding to `addr`, or `None` if it does not exist.
|
|
|
|
pub fn get_by_addr(&self, addr: SocketAddr) -> Option<MetaAddr> {
|
2019-10-21 15:56:16 -07:00
|
|
|
let _guard = self.span.enter();
|
2021-02-17 17:18:32 -08:00
|
|
|
self.by_addr.get(&addr).cloned()
|
2019-10-18 11:04:38 -07:00
|
|
|
}
|
2019-10-17 15:42:19 -07:00
|
|
|
|
2019-10-18 11:04:38 -07:00
|
|
|
/// Add `new` to the address book, updating the previous entry if `new` is
|
|
|
|
/// more recent or discarding `new` if it is stale.
|
2021-02-17 17:18:32 -08:00
|
|
|
///
|
|
|
|
/// ## Note
|
|
|
|
///
|
|
|
|
/// All changes should go through `update` or `take`, to ensure accurate metrics.
|
2019-10-18 11:04:38 -07:00
|
|
|
pub fn update(&mut self, new: MetaAddr) {
|
2019-10-21 15:56:16 -07:00
|
|
|
let _guard = self.span.enter();
|
2019-10-17 21:19:23 -07:00
|
|
|
trace!(
|
2019-10-18 11:04:38 -07:00
|
|
|
?new,
|
2021-02-17 17:18:32 -08:00
|
|
|
total_peers = self.by_addr.len(),
|
|
|
|
recent_peers = self.recently_live_peers().count(),
|
2019-10-17 15:42:19 -07:00
|
|
|
);
|
|
|
|
|
2020-02-04 22:53:24 -08:00
|
|
|
if let Some(prev) = self.get_by_addr(new.addr) {
|
|
|
|
if prev.last_seen > new.last_seen {
|
|
|
|
return;
|
2019-10-17 15:42:19 -07:00
|
|
|
}
|
|
|
|
}
|
2019-10-18 11:04:38 -07:00
|
|
|
|
2021-02-17 17:18:32 -08:00
|
|
|
self.by_addr.insert(new.addr, new);
|
|
|
|
self.update_metrics();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Removes the entry with `addr`, returning it if it exists
|
|
|
|
///
|
|
|
|
/// ## Note
|
|
|
|
///
|
|
|
|
/// All changes should go through `update` or `take`, to ensure accurate metrics.
|
|
|
|
fn take(&mut self, removed_addr: SocketAddr) -> Option<MetaAddr> {
|
|
|
|
let _guard = self.span.enter();
|
|
|
|
trace!(
|
|
|
|
?removed_addr,
|
|
|
|
total_peers = self.by_addr.len(),
|
|
|
|
recent_peers = self.recently_live_peers().count(),
|
|
|
|
);
|
|
|
|
|
|
|
|
if let Some(entry) = self.by_addr.remove(&removed_addr) {
|
|
|
|
self.update_metrics();
|
|
|
|
Some(entry)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
2019-10-17 15:42:19 -07:00
|
|
|
}
|
2019-10-17 16:25:24 -07:00
|
|
|
|
2019-10-18 09:54:34 -07:00
|
|
|
/// Compute a cutoff time that can determine whether an entry
|
|
|
|
/// in an address book being updated with peer message timestamps
|
2021-02-17 17:18:32 -08:00
|
|
|
/// represents a likely-dead (or hung) peer, or a potentially-connected peer.
|
2019-10-18 09:54:34 -07:00
|
|
|
///
|
|
|
|
/// [`constants::LIVE_PEER_DURATION`] represents the time interval in which
|
2021-02-17 17:18:32 -08:00
|
|
|
/// we should receive at least one message from a peer, or close the
|
|
|
|
/// connection. Therefore, if the last-seen timestamp is older than
|
|
|
|
/// [`constants::LIVE_PEER_DURATION`] ago, we know we should have
|
|
|
|
/// disconnected from it. Otherwise, we could potentially be connected to it.
|
|
|
|
fn liveness_cutoff_time() -> DateTime<Utc> {
|
2019-10-18 09:54:34 -07:00
|
|
|
// chrono uses signed durations while stdlib uses unsigned durations
|
|
|
|
use chrono::Duration as CD;
|
|
|
|
Utc::now() - CD::from_std(constants::LIVE_PEER_DURATION).unwrap()
|
|
|
|
}
|
|
|
|
|
2021-02-17 17:18:32 -08:00
|
|
|
/// Returns true if the given [`SocketAddr`] has recently sent us a message.
|
|
|
|
pub fn recently_live_addr(&self, addr: &SocketAddr) -> bool {
|
|
|
|
let _guard = self.span.enter();
|
|
|
|
match self.by_addr.get(addr) {
|
|
|
|
None => false,
|
|
|
|
// NeverAttempted, Failed, and AttemptPending peers should never be live
|
|
|
|
Some(peer) => {
|
|
|
|
peer.last_connection_state == PeerAddrState::Responded
|
|
|
|
&& peer.last_seen > AddressBook::liveness_cutoff_time()
|
|
|
|
}
|
2020-09-03 10:09:25 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-17 17:18:32 -08:00
|
|
|
/// Returns true if the given [`SocketAddr`] is pending a reconnection
|
|
|
|
/// attempt.
|
|
|
|
pub fn pending_reconnection_addr(&self, addr: &SocketAddr) -> bool {
|
2019-10-21 15:56:16 -07:00
|
|
|
let _guard = self.span.enter();
|
2019-10-18 09:54:34 -07:00
|
|
|
match self.by_addr.get(addr) {
|
2020-02-04 22:53:24 -08:00
|
|
|
None => false,
|
2021-02-17 17:18:32 -08:00
|
|
|
Some(peer) => peer.last_connection_state == PeerAddrState::AttemptPending,
|
2019-10-18 09:54:34 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-17 17:18:32 -08:00
|
|
|
/// Returns true if the given [`SocketAddr`] might be connected to a node
|
|
|
|
/// feeding timestamps into this address book.
|
|
|
|
pub fn maybe_connected_addr(&self, addr: &SocketAddr) -> bool {
|
|
|
|
self.recently_live_addr(addr) || self.pending_reconnection_addr(addr)
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Return an iterator over all peers.
|
|
|
|
///
|
|
|
|
/// Returns peers in reconnection attempt order, then recently live peers in
|
|
|
|
/// an arbitrary order.
|
2020-10-11 15:32:05 -07:00
|
|
|
pub fn peers(&'_ self) -> impl Iterator<Item = MetaAddr> + '_ {
|
2019-10-21 15:56:16 -07:00
|
|
|
let _guard = self.span.enter();
|
2021-02-17 17:18:32 -08:00
|
|
|
self.reconnection_peers()
|
|
|
|
.chain(self.maybe_connected_peers())
|
2019-10-17 16:25:24 -07:00
|
|
|
}
|
|
|
|
|
2021-02-17 17:18:32 -08:00
|
|
|
/// Return an iterator over peers that are due for a reconnection attempt,
|
|
|
|
/// in reconnection attempt order.
|
|
|
|
pub fn reconnection_peers(&'_ self) -> impl Iterator<Item = MetaAddr> + '_ {
|
2019-10-21 15:56:16 -07:00
|
|
|
let _guard = self.span.enter();
|
2019-10-17 16:25:24 -07:00
|
|
|
|
2021-02-17 17:18:32 -08:00
|
|
|
// TODO: optimise, if needed, or get rid of older peers
|
|
|
|
|
|
|
|
// Skip live peers, and peers pending a reconnect attempt, then sort using BTreeSet
|
|
|
|
self.by_addr
|
|
|
|
.values()
|
|
|
|
.filter(move |peer| !self.maybe_connected_addr(&peer.addr))
|
|
|
|
.collect::<BTreeSet<_>>()
|
|
|
|
.into_iter()
|
2020-09-03 10:09:25 -07:00
|
|
|
.cloned()
|
|
|
|
}
|
|
|
|
|
2021-02-17 17:18:32 -08:00
|
|
|
/// Return an iterator over all the peers in `state`, in arbitrary order.
|
|
|
|
pub fn state_peers(&'_ self, state: PeerAddrState) -> impl Iterator<Item = MetaAddr> + '_ {
|
2020-09-03 10:09:25 -07:00
|
|
|
let _guard = self.span.enter();
|
|
|
|
|
2021-02-17 17:18:32 -08:00
|
|
|
self.by_addr
|
|
|
|
.values()
|
|
|
|
.filter(move |peer| peer.last_connection_state == state)
|
2019-10-17 21:19:23 -07:00
|
|
|
.cloned()
|
2019-10-17 16:25:24 -07:00
|
|
|
}
|
2019-10-17 17:54:08 -07:00
|
|
|
|
2021-02-17 17:18:32 -08:00
|
|
|
/// Return an iterator over peers that might be connected, in arbitrary
|
|
|
|
/// order.
|
|
|
|
pub fn maybe_connected_peers(&'_ self) -> impl Iterator<Item = MetaAddr> + '_ {
|
|
|
|
let _guard = self.span.enter();
|
|
|
|
|
|
|
|
self.by_addr
|
|
|
|
.values()
|
|
|
|
.filter(move |peer| self.maybe_connected_addr(&peer.addr))
|
|
|
|
.cloned()
|
2019-10-18 09:27:28 -07:00
|
|
|
}
|
|
|
|
|
2021-02-17 17:18:32 -08:00
|
|
|
/// Return an iterator over peers we've seen recently, in arbitrary order.
|
|
|
|
pub fn recently_live_peers(&'_ self) -> impl Iterator<Item = MetaAddr> + '_ {
|
|
|
|
let _guard = self.span.enter();
|
|
|
|
|
|
|
|
self.by_addr
|
|
|
|
.values()
|
|
|
|
.filter(move |peer| self.recently_live_addr(&peer.addr))
|
|
|
|
.cloned()
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns an iterator that drains entries from the address book.
|
|
|
|
///
|
|
|
|
/// Removes entries in reconnection attempt then arbitrary order,
|
|
|
|
/// see [`peers`] for details.
|
|
|
|
pub fn drain(&'_ mut self) -> impl Iterator<Item = MetaAddr> + '_ {
|
|
|
|
Drain { book: self }
|
2019-10-17 17:54:08 -07:00
|
|
|
}
|
2019-10-21 15:24:17 -07:00
|
|
|
|
|
|
|
/// Returns the number of entries in this address book.
|
|
|
|
pub fn len(&self) -> usize {
|
2021-02-17 17:18:32 -08:00
|
|
|
self.by_addr.len()
|
|
|
|
}
|
|
|
|
|
2021-03-15 04:52:58 -07:00
|
|
|
/// Returns metrics for the addresses in this address book.
|
|
|
|
pub fn address_metrics(&self) -> AddressMetrics {
|
2021-02-17 17:18:32 -08:00
|
|
|
let responded = self.state_peers(PeerAddrState::Responded).count();
|
|
|
|
let never_attempted = self.state_peers(PeerAddrState::NeverAttempted).count();
|
|
|
|
let failed = self.state_peers(PeerAddrState::Failed).count();
|
2021-03-15 04:52:58 -07:00
|
|
|
let attempt_pending = self.state_peers(PeerAddrState::AttemptPending).count();
|
2021-02-17 17:18:32 -08:00
|
|
|
|
|
|
|
let recently_live = self.recently_live_peers().count();
|
|
|
|
let recently_stopped_responding = responded
|
|
|
|
.checked_sub(recently_live)
|
|
|
|
.expect("all recently live peers must have responded");
|
|
|
|
|
2021-03-15 04:52:58 -07:00
|
|
|
AddressMetrics {
|
|
|
|
responded,
|
|
|
|
never_attempted,
|
|
|
|
failed,
|
|
|
|
attempt_pending,
|
|
|
|
recently_live,
|
|
|
|
recently_stopped_responding,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Update the metrics for this address book.
|
|
|
|
fn update_metrics(&self) {
|
|
|
|
let _guard = self.span.enter();
|
|
|
|
|
|
|
|
let m = self.address_metrics();
|
|
|
|
|
|
|
|
// TODO: rename to address_book.[state_name]
|
|
|
|
metrics::gauge!("candidate_set.responded", m.responded as f64);
|
|
|
|
metrics::gauge!("candidate_set.gossiped", m.never_attempted as f64);
|
|
|
|
metrics::gauge!("candidate_set.failed", m.failed as f64);
|
|
|
|
metrics::gauge!("candidate_set.pending", m.attempt_pending as f64);
|
|
|
|
|
2021-02-17 17:18:32 -08:00
|
|
|
// TODO: rename to address_book.responded.recently_live
|
2021-03-15 04:52:58 -07:00
|
|
|
metrics::gauge!("candidate_set.recently_live", m.recently_live as f64);
|
2021-02-17 17:18:32 -08:00
|
|
|
// TODO: rename to address_book.responded.stopped_responding
|
|
|
|
metrics::gauge!(
|
|
|
|
"candidate_set.disconnected",
|
2021-03-15 04:52:58 -07:00
|
|
|
m.recently_stopped_responding as f64
|
2021-02-17 17:18:32 -08:00
|
|
|
);
|
|
|
|
|
|
|
|
debug!(
|
2021-03-15 04:52:58 -07:00
|
|
|
address_metrics = ?m,
|
2021-02-17 17:18:32 -08:00
|
|
|
);
|
2019-10-21 15:24:17 -07:00
|
|
|
}
|
2019-10-17 16:25:24 -07:00
|
|
|
}
|
|
|
|
|
2019-10-17 17:54:08 -07:00
|
|
|
impl Extend<MetaAddr> for AddressBook {
|
|
|
|
fn extend<T>(&mut self, iter: T)
|
|
|
|
where
|
|
|
|
T: IntoIterator<Item = MetaAddr>,
|
|
|
|
{
|
|
|
|
for meta in iter.into_iter() {
|
|
|
|
self.update(meta);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
struct Drain<'a> {
|
|
|
|
book: &'a mut AddressBook,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> Iterator for Drain<'a> {
|
|
|
|
type Item = MetaAddr;
|
|
|
|
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
2021-02-17 17:18:32 -08:00
|
|
|
let next_item_addr = self.book.peers().next()?.addr;
|
|
|
|
self.book.take(next_item_addr)
|
2019-10-17 17:54:08 -07:00
|
|
|
}
|
2019-10-17 21:19:23 -07:00
|
|
|
}
|