Rename PeerConnectionState to PeerAddrState

zebra-network/src/address_book.rs

@@ -10,7 +10,7 @@ use std::{
 use chrono::{DateTime, Utc};
 use tracing::Span;
 
-use crate::{constants, types::MetaAddr, PeerConnectionState};
+use crate::{constants, types::MetaAddr, PeerAddrState};
 
 /// A database of peers, their advertised services, and information on when they
 /// were last seen.
@@ -127,7 +127,7 @@ impl AddressBook {
             None => false,
             // NeverAttempted, Failed, and AttemptPending peers should never be live
             Some(peer) => {
-                peer.last_connection_state == PeerConnectionState::Responded
+                peer.last_connection_state == PeerAddrState::Responded
                     && peer.last_seen > AddressBook::liveness_cutoff_time()
             }
         }
@@ -139,7 +139,7 @@ impl AddressBook {
         let _guard = self.span.enter();
         match self.by_addr.get(addr) {
             None => false,
-            Some(peer) => peer.last_connection_state == PeerConnectionState::AttemptPending,
+            Some(peer) => peer.last_connection_state == PeerAddrState::AttemptPending,
         }
     }
 
@@ -176,10 +176,7 @@ impl AddressBook {
     }
 
     /// Return an iterator over all the peers in `state`, in arbitrary order.
-    pub fn state_peers(
-        &'_ self,
-        state: PeerConnectionState,
-    ) -> impl Iterator<Item = MetaAddr> + '_ {
+    pub fn state_peers(&'_ self, state: PeerAddrState) -> impl Iterator<Item = MetaAddr> + '_ {
         let _guard = self.span.enter();
 
         self.by_addr
@@ -226,14 +223,10 @@ impl AddressBook {
     fn update_metrics(&self) {
         let _guard = self.span.enter();
 
-        let responded = self.state_peers(PeerConnectionState::Responded).count();
-        let never_attempted = self
-            .state_peers(PeerConnectionState::NeverAttempted)
-            .count();
-        let failed = self.state_peers(PeerConnectionState::Failed).count();
-        let pending = self
-            .state_peers(PeerConnectionState::AttemptPending)
-            .count();
+        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();
+        let pending = self.state_peers(PeerAddrState::AttemptPending).count();
 
         let recently_live = self.recently_live_peers().count();
         let recently_stopped_responding = responded

zebra-network/src/lib.rs

@@ -79,7 +79,7 @@ pub use crate::{
     address_book::AddressBook,
     config::Config,
     isolated::connect_isolated,
-    meta_addr::PeerConnectionState,
+    meta_addr::PeerAddrState,
     peer_set::init,
     policies::{RetryErrors, RetryLimit},
     protocol::internal::{Request, Response},

zebra-network/src/meta_addr.rs

@@ -22,7 +22,7 @@ use crate::protocol::types::PeerServices;
 /// [`AddressBook::maybe_connected_peers`] and
 /// [`AddressBook::reconnection_peers`].
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub enum PeerConnectionState {
+pub enum PeerAddrState {
     /// The peer has sent us a valid message.
     ///
     /// Peers remain in this state, even if they stop responding to requests.
@@ -42,19 +42,19 @@ pub enum PeerConnectionState {
     AttemptPending,
 }
 
-impl Default for PeerConnectionState {
+impl Default for PeerAddrState {
     fn default() -> Self {
-        PeerConnectionState::NeverAttempted
+        PeerAddrState::NeverAttempted
     }
 }
 
-impl Ord for PeerConnectionState {
-    /// `PeerConnectionState`s are sorted in approximate reconnection attempt
+impl Ord for PeerAddrState {
+    /// `PeerAddrState`s are sorted in approximate reconnection attempt
     /// order, ignoring liveness.
     ///
     /// See [`CandidateSet`] and [`MetaAddr::cmp`] for more details.
     fn cmp(&self, other: &Self) -> Ordering {
-        use PeerConnectionState::*;
+        use PeerAddrState::*;
         match (self, other) {
             (Responded, Responded)
             | (NeverAttempted, NeverAttempted)
@@ -73,7 +73,7 @@ impl Ord for PeerConnectionState {
     }
 }
 
-impl PartialOrd for PeerConnectionState {
+impl PartialOrd for PeerAddrState {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.cmp(other))
     }
@@ -120,7 +120,7 @@ pub struct MetaAddr {
     pub last_seen: DateTime<Utc>,
 
     /// The outcome of our most recent communication attempt with this peer.
-    pub last_connection_state: PeerConnectionState,
+    pub last_connection_state: PeerAddrState,
 }
 
 impl MetaAddr {
@@ -144,7 +144,7 @@ impl Ord for MetaAddr {
     /// See [`CandidateSet`] for more details.
     fn cmp(&self, other: &Self) -> Ordering {
         use std::net::IpAddr::{V4, V6};
-        use PeerConnectionState::*;
+        use PeerAddrState::*;
 
         let oldest_first = self.last_seen.cmp(&other.last_seen);
         let newest_first = oldest_first.reverse();
@@ -216,7 +216,7 @@ mod tests {
             services,
             addr,
             last_seen: Utc.timestamp(1_573_680_222, 0),
-            last_connection_state: PeerConnectionState::Responded,
+            last_connection_state: PeerAddrState::Responded,
         }
         .sanitize();
 

zebra-network/src/peer/handshake.rs

@@ -27,7 +27,7 @@ use crate::{
         internal::{Request, Response},
     },
     types::MetaAddr,
-    BoxError, Config, PeerConnectionState,
+    BoxError, Config, PeerAddrState,
 };
 
 use super::{Client, Connection, ErrorSlot, HandshakeError, PeerError};
@@ -390,7 +390,7 @@ where
                                     addr,
                                     services: remote_services,
                                     last_seen: Utc::now(),
-                                    last_connection_state: PeerConnectionState::Responded,
+                                    last_connection_state: PeerAddrState::Responded,
                                 })
                                 .await;
                         }

zebra-network/src/peer_set/candidate_set.rs

@@ -4,12 +4,12 @@ use chrono::Utc;
 use futures::stream::{FuturesUnordered, StreamExt};
 use tower::{Service, ServiceExt};
 
-use crate::{types::MetaAddr, AddressBook, BoxError, PeerConnectionState, Request, Response};
+use crate::{types::MetaAddr, AddressBook, BoxError, PeerAddrState, Request, Response};
 
 /// The `CandidateSet` manages the `PeerSet`'s peer reconnection attempts.
 ///
 /// It divides the set of all possible candidate peers into disjoint subsets,
-/// using the `PeerConnectionState`:
+/// using the `PeerAddrState`:
 ///
 /// 1. `Responded` peers, which we previously connected to. If we have not received
 ///    any messages from a `Responded` peer within a cutoff time, we assume that it
@@ -54,7 +54,7 @@ use crate::{types::MetaAddr, AddressBook, BoxError, PeerConnectionState, Request
 ///  │ #1 oldest_first        #2 newest_first        #3 oldest_first ││
 ///  │        │                      │                      │        ││
 ///  │        ├──────────────────────┴──────────────────────┘        ││
-///  │        │      disjoint `PeerConnectionState`s                 ││
+///  │        │         disjoint `PeerAddrState`s                    ││
 ///  ├────────┼──────────────────────────────────────────────────────┘│
 ///  │        ▼                                                       │
 ///  │        Λ                                                       │
@@ -193,7 +193,7 @@ where
         let mut reconnect = peer_set_guard.reconnection_peers().next()?;
 
         reconnect.last_seen = Utc::now();
-        reconnect.last_connection_state = PeerConnectionState::AttemptPending;
+        reconnect.last_connection_state = PeerAddrState::AttemptPending;
         peer_set_guard.update(reconnect);
 
         Some(reconnect)
@@ -202,7 +202,7 @@ where
     /// Mark `addr` as a failed peer.
     pub fn report_failed(&mut self, mut addr: MetaAddr) {
         addr.last_seen = Utc::now();
-        addr.last_connection_state = PeerConnectionState::Failed;
+        addr.last_connection_state = PeerAddrState::Failed;
         self.peer_set.lock().unwrap().update(addr);
     }
 }