remove currently_live_peers and just use filtered `recently_live_pe…

…ers` instead

zebra-network/src/address_book.rs

@@ -819,16 +819,6 @@ impl AddressBookPeers for AddressBook {
             .cloned()
             .collect()
     }
-
-    fn currently_live_peers(&self, now: chrono::DateTime<Utc>) -> Vec<MetaAddr> {
-        let _guard = self.span.enter();
-
-        self.by_addr
-            .descending_values()
-            .filter(|peer| peer.has_connection_recently_responded(now))
-            .cloned()
-            .collect()
-    }
 }
 
 impl AddressBookPeers for Arc<Mutex<AddressBook>> {
@@ -837,12 +827,6 @@ impl AddressBookPeers for Arc<Mutex<AddressBook>> {
             .expect("panic in a previous thread that was holding the mutex")
             .recently_live_peers(now)
     }
-
-    fn currently_live_peers(&self, now: chrono::DateTime<Utc>) -> Vec<MetaAddr> {
-        self.lock()
-            .expect("panic in a previous thread that was holding the mutex")
-            .currently_live_peers(now)
-    }
 }
 
 impl Extend<MetaAddrChange> for AddressBook {

zebra-network/src/address_book_peers.rs

@@ -14,7 +14,4 @@ pub use mock::MockAddressBookPeers;
 pub trait AddressBookPeers {
     /// Return an Vec of peers we've seen recently, in reconnection attempt order.
     fn recently_live_peers(&self, now: chrono::DateTime<Utc>) -> Vec<MetaAddr>;
-
-    /// Return an Vec of peers that are likely to be live, in reconnection attempt order.
-    fn currently_live_peers(&self, now: chrono::DateTime<Utc>) -> Vec<MetaAddr>;
 }

zebra-network/src/address_book_peers/mock.rs

@@ -7,17 +7,13 @@ use crate::{meta_addr::MetaAddr, AddressBookPeers};
 pub struct MockAddressBookPeers {
     /// Return value for mock `recently_live_peers` method.
     recently_live_peers: Vec<MetaAddr>,
-
-    /// Return value for mock `currently_live_peers` method.
-    currently_live_peers: Vec<MetaAddr>,
 }
 
 impl MockAddressBookPeers {
     /// Creates a new [`MockAddressBookPeers`]
-    pub fn new(recently_live_peers: Vec<MetaAddr>, currently_live_peers: Vec<MetaAddr>) -> Self {
+    pub fn new(recently_live_peers: Vec<MetaAddr>) -> Self {
         Self {
             recently_live_peers,
-            currently_live_peers,
         }
     }
 }
@@ -26,8 +22,4 @@ impl AddressBookPeers for MockAddressBookPeers {
     fn recently_live_peers(&self, _now: chrono::DateTime<chrono::Utc>) -> Vec<MetaAddr> {
         self.recently_live_peers.clone()
     }
-
-    fn currently_live_peers(&self, _now: chrono::DateTime<chrono::Utc>) -> Vec<MetaAddr> {
-        self.currently_live_peers.clone()
-    }
 }

zebra-rpc/src/methods/get_block_template_rpcs.rs

@@ -1103,8 +1103,9 @@ where
         let address_book = self.address_book.clone();
 
         Ok(address_book
-            .currently_live_peers(chrono::Utc::now())
+            .recently_live_peers(chrono::Utc::now())
             .into_iter()
+            .filter(|meta_addr| meta_addr.has_connection_recently_responded(chrono::Utc::now()))
             .map(|meta_addr| PeerInfo::new(meta_addr, meta_addr.is_inbound()))
             .collect())
     }

zebra-rpc/src/methods/tests/snapshot/get_block_template_rpcs.rs

@@ -25,7 +25,10 @@ use zebra_chain::{
     transparent,
     work::difficulty::{CompactDifficulty, ParameterDifficulty as _},
 };
-use zebra_network::{address_book_peers::MockAddressBookPeers, types::MetaAddr};
+use zebra_network::{
+    address_book_peers::MockAddressBookPeers,
+    types::{MetaAddr, PeerServices},
+};
 use zebra_node_services::mempool;
 
 use zebra_state::{GetBlockTemplateChainInfo, ReadRequest, ReadResponse};
@@ -132,17 +135,16 @@ pub async fn test_responses<State, ReadState>(
     mock_chain_tip_sender.send_best_tip_hash(fake_tip_hash);
     mock_chain_tip_sender.send_estimated_distance_to_network_chain_tip(Some(0));
 
-    let mock_address_book = MockAddressBookPeers::new(
-        vec![],
-        vec![MetaAddr::new_initial_peer(
-            SocketAddr::new(
-                IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
-                network.default_port(),
-            )
-            .into(),
+    let mock_address_book = MockAddressBookPeers::new(vec![MetaAddr::new_connected(
+        SocketAddr::new(
+            IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
+            network.default_port(),
         )
-        .into_new_meta_addr(Instant::now(), DateTime32::now())],
-    );
+        .into(),
+        &PeerServices::NODE_NETWORK,
+        false,
+    )
+    .into_new_meta_addr(Instant::now(), DateTime32::now())]);
 
     // get an rpc instance with continuous blockchain state
     let get_block_template_rpc = GetBlockTemplateRpcImpl::new(

zebra-rpc/src/methods/tests/vectors.rs

@@ -1311,18 +1311,22 @@ async fn rpc_getpeerinfo() {
     )
     .await;
 
-    let outbound_mock_peer_address = zebra_network::types::MetaAddr::new_initial_peer(
+    // Add a connected outbound peer
+    let outbound_mock_peer_address = zebra_network::types::MetaAddr::new_connected(
         std::net::SocketAddr::new(
             std::net::IpAddr::V4(std::net::Ipv4Addr::new(127, 0, 0, 1)),
             network.default_port(),
         )
         .into(),
+        &PeerServices::NODE_NETWORK,
+        false,
     )
     .into_new_meta_addr(
         std::time::Instant::now(),
         zebra_chain::serialization::DateTime32::now(),
     );
 
+    // Add a connected inbound peer
     let inbound_mock_peer_address = zebra_network::types::MetaAddr::new_connected(
         std::net::SocketAddr::new(
             std::net::IpAddr::V4(std::net::Ipv4Addr::new(127, 0, 0, 1)),
@@ -1337,11 +1341,25 @@ async fn rpc_getpeerinfo() {
         zebra_chain::serialization::DateTime32::now(),
     );
 
-    let mock_address_book = MockAddressBookPeers::new(
-        vec![],
-        vec![outbound_mock_peer_address, inbound_mock_peer_address],
+    // Add a peer that is not connected and will not be displayed in the RPC output
+    let not_connected_mock_peer_adderess = zebra_network::types::MetaAddr::new_initial_peer(
+        std::net::SocketAddr::new(
+            std::net::IpAddr::V4(std::net::Ipv4Addr::new(127, 0, 0, 1)),
+            55555,
+        )
+        .into(),
+    )
+    .into_new_meta_addr(
+        std::time::Instant::now(),
+        zebra_chain::serialization::DateTime32::now(),
     );
 
+    let mock_address_book = MockAddressBookPeers::new(vec![
+        outbound_mock_peer_address,
+        inbound_mock_peer_address,
+        not_connected_mock_peer_adderess,
+    ]);
+
     // Init RPC
     let get_block_template_rpc = get_block_template_rpcs::GetBlockTemplateRpcImpl::new(
         &network,
@@ -1361,6 +1379,9 @@ async fn rpc_getpeerinfo() {
         .await
         .expect("We should have an array of addresses");
 
+    // Response of lenght should be 2. We have 2 connected peers and 1 unconnected peer in the address book.
+    assert_eq!(get_peer_info.len(), 2);
+
     let mut res_iter = get_peer_info.into_iter();
     // Check for the outbound peer
     assert_eq!(