net: use sync Mutex for HostContainer

Rationale: using a sync Mutex wherever possible is the recommended
method.

Additionally, using a sync Mutex here fixes some really weird fairness
behaviors we observed in the smol::lock::RwLock where writers in the
priority queue were occassionally ignored.

bin/lilith/src/main.rs

@@ -91,7 +91,6 @@ impl Spawn {
             .hosts()
             .container
             .fetch_all(HostColor::White)
-            .await
             .iter()
             .map(|(addr, _url)| JsonValue::String(addr.to_string()))
             .collect()
@@ -102,7 +101,6 @@ impl Spawn {
             .hosts()
             .container
             .fetch_all(HostColor::Grey)
-            .await
             .iter()
             .map(|(addr, _url)| JsonValue::String(addr.to_string()))
             .collect()
@@ -113,7 +111,6 @@ impl Spawn {
             .hosts()
             .container
             .fetch_all(HostColor::Gold)
-            .await
             .iter()
             .map(|(addr, _url)| JsonValue::String(addr.to_string()))
             .collect()
@@ -186,7 +183,7 @@ impl Lilith {
         loop {
             sleep(refinery_interval).await;
 
-            match hosts.container.fetch_last(HostColor::White).await {
+            match hosts.container.fetch_last(HostColor::White) {
                 Some(entry) => {
                     let url = &entry.0;
                     let last_seen = &entry.1;
@@ -202,7 +199,7 @@ impl Lilith {
                         debug!(target: "net::refinery:::whitelist_refinery",
                        "Host {} is not responsive. Downgrading from whitelist", url);
 
-                        hosts.greylist_host(url, *last_seen).await?;
+                        hosts.greylist_host(url, *last_seen)?;
 
                         continue
                     }
@@ -212,10 +209,11 @@ impl Lilith {
 
                     // This node is active. Update the last seen field.
                     let last_seen = UNIX_EPOCH.elapsed().unwrap().as_secs();
-                    hosts
-                        .container
-                        .update_last_seen(HostColor::White as usize, url.clone(), last_seen)
-                        .await;
+                    hosts.container.update_last_seen(
+                        HostColor::White as usize,
+                        url.clone(),
+                        last_seen,
+                    );
                 }
                 None => {
                     debug!(target: "net::refinery::whitelist_refinery",

src/net/acceptor.rs

@@ -119,8 +119,8 @@ impl Acceptor {
             match listener.next().await {
                 Ok((stream, url)) => {
                     // Check if we reject this peer
-                    if hosts.container.contains(HostColor::Black as usize, &url).await ||
-                        hosts.block_all_ports(url.host_str().unwrap().to_string()).await
+                    if hosts.container.contains(HostColor::Black as usize, &url) ||
+                        hosts.block_all_ports(url.host_str().unwrap().to_string())
                     {
                         warn!(target: "net::acceptor::run_accept_loop()", "Peer {} is blacklisted", url);
                         continue

src/net/channel.rs

@@ -391,7 +391,7 @@ impl Channel {
     pub async fn ban(&self, peer: &Url) {
         debug!(target: "net::channel::ban()", "START {:?}", self);
         let last_seen = UNIX_EPOCH.elapsed().unwrap().as_secs();
-        self.p2p().hosts().move_host(peer, last_seen, HostColor::Black).await.unwrap();
+        self.p2p().hosts().move_host(peer, last_seen, HostColor::Black).unwrap();
 
         self.stop().await;
         debug!(target: "net::channel::ban()", "STOP {:?}", self);

src/net/connector.rs

@@ -53,8 +53,8 @@ impl Connector {
     /// Establish an outbound connection
     pub async fn connect(&self, url: &Url) -> Result<(Url, ChannelPtr)> {
         let hosts = self.session.upgrade().unwrap().p2p().hosts();
-        if hosts.container.contains(HostColor::Black as usize, url).await ||
-            hosts.block_all_ports(url.host_str().unwrap().to_string()).await
+        if hosts.container.contains(HostColor::Black as usize, url) ||
+            hosts.block_all_ports(url.host_str().unwrap().to_string())
         {
             warn!(target: "net::connector::connect", "Peer {} is blacklisted", url);
             return Err(Error::ConnectFailed)

src/net/hosts.rs

@@ -20,13 +20,12 @@ use std::{
     collections::HashMap,
     fmt, fs,
     fs::File,
-    sync::{Arc, Mutex},
+    sync::{Arc, Mutex, RwLock},
     time::Instant,
 };
 
 use log::{debug, error, info, trace, warn};
 use rand::{prelude::IteratorRandom, rngs::OsRng, Rng};
-use smol::lock::RwLock;
 use url::Url;
 
 use super::{settings::SettingsPtr, ChannelPtr};
@@ -304,11 +303,11 @@ impl HostContainer {
     }
 
     /// Append host to a hostlist. Called when initalizing the hostlist in load_hosts().
-    async fn store(&self, color: usize, addr: Url, last_seen: u64) {
+    fn store(&self, color: usize, addr: Url, last_seen: u64) {
         trace!(target: "net::hosts::store()", "[START] list={:?}",
         HostColor::try_from(color).unwrap());
 
-        let mut list = self.hostlists[color].write().await;
+        let mut list = self.hostlists[color].write().unwrap();
         list.push((addr.clone(), last_seen));
         debug!(target: "net::hosts::store()", "Added [{}] to {:?} list",
                addr, HostColor::try_from(color).unwrap());
@@ -347,10 +346,10 @@ impl HostContainer {
 
     /// Stores an address on a hostlist or updates its last_seen field if
     /// we already have the address.
-    async fn store_or_update(&self, color: HostColor, addr: Url, last_seen: u64) {
+    fn store_or_update(&self, color: HostColor, addr: Url, last_seen: u64) {
         trace!(target: "net::hosts::store_or_update()", "[START]");
         let color_code = color.clone() as usize;
-        let mut list = self.hostlists[color_code].write().await;
+        let mut list = self.hostlists[color_code].write().unwrap();
         if let Some(entry) = list.iter_mut().find(|(u, _)| *u == addr) {
             entry.1 = last_seen;
             debug!(target: "net::hosts::store_or_update()", "Updated [{}] entry on {:?} list",
@@ -391,11 +390,11 @@ impl HostContainer {
     }
 
     /// Update the last_seen field of a peer on a hostlist.
-    pub async fn update_last_seen(&self, color: usize, addr: Url, last_seen: u64) {
+    pub fn update_last_seen(&self, color: usize, addr: Url, last_seen: u64) {
         trace!(target: "net::hosts::update_last_seen()", "[START] list={:?}",
         HostColor::try_from(color).unwrap());
 
-        let mut list = self.hostlists[color].write().await;
+        let mut list = self.hostlists[color].write().unwrap();
         if let Some(entry) = list.iter_mut().find(|(u, _)| *u == addr) {
             entry.1 = last_seen;
             list.sort_by_key(|entry| entry.1);
@@ -406,20 +405,20 @@ impl HostContainer {
     }
 
     /// Return all known hosts on a hostlist.
-    pub async fn fetch_all(&self, color: HostColor) -> Vec<(Url, u64)> {
-        self.hostlists[color as usize].read().await.iter().cloned().collect()
+    pub fn fetch_all(&self, color: HostColor) -> Vec<(Url, u64)> {
+        self.hostlists[color as usize].read().unwrap().iter().cloned().collect()
     }
 
     /// Get the oldest entry from a hostlist.
-    pub async fn fetch_last(&self, color: HostColor) -> Option<(Url, u64)> {
-        let list = self.hostlists[color as usize].read().await;
+    pub fn fetch_last(&self, color: HostColor) -> Option<(Url, u64)> {
+        let list = self.hostlists[color as usize].read().unwrap();
         list.last().cloned()
     }
 
     /// Fetch addresses that match the provided transports or acceptable
     /// mixed transports.  Will return an empty Vector if no such addresses
     /// were found.
-    pub(in crate::net) async fn fetch(
+    pub(in crate::net) fn fetch(
         &self,
         color: HostColor,
         transports: &[String],
@@ -435,7 +434,7 @@ impl HostContainer {
         macro_rules! mix_transport {
             ($a:expr, $b:expr) => {
                 if transports.contains(&$a.to_string()) && transport_mixing {
-                    let mut a_to_b = self.fetch_with_schemes(index, &[$b.to_string()], None).await;
+                    let mut a_to_b = self.fetch_with_schemes(index, &[$b.to_string()], None);
                     for (addr, last_seen) in a_to_b.iter_mut() {
                         addr.set_scheme($a).unwrap();
                         hosts.push((addr.clone(), last_seen.clone()));
@@ -450,7 +449,7 @@ impl HostContainer {
         mix_transport!("nym+tls", "tcp+tls");
 
         // And now the actual requested transports
-        for (addr, last_seen) in self.fetch_with_schemes(index, transports, None).await {
+        for (addr, last_seen) in self.fetch_with_schemes(index, transports, None) {
             hosts.push((addr, last_seen));
         }
 
@@ -461,7 +460,7 @@ impl HostContainer {
 
     /// Get up to limit peers that match the given transport schemes from
     /// a hostlist.  If limit was not provided, return all matching peers.
-    async fn fetch_with_schemes(
+    fn fetch_with_schemes(
         &self,
         color: usize,
         schemes: &[String],
@@ -470,7 +469,7 @@ impl HostContainer {
         trace!(target: "net::hosts::fetch_with_schemes()", "[START] {:?}",
                HostColor::try_from(color).unwrap());
 
-        let list = self.hostlists[color].read().await;
+        let list = self.hostlists[color].read().unwrap();
 
         let mut limit = match limit {
             Some(l) => l.min(list.len()),
@@ -506,7 +505,7 @@ impl HostContainer {
     /// Get up to limit peers that don't match the given transport schemes
     /// from a hostlist.  If limit was not provided, return all matching
     /// peers.
-    async fn fetch_excluding_schemes(
+    fn fetch_excluding_schemes(
         &self,
         color: usize,
         schemes: &[String],
@@ -515,7 +514,7 @@ impl HostContainer {
         trace!(target: "net::hosts::fetch_with_schemes()", "[START] {:?}",
                HostColor::try_from(color).unwrap());
 
-        let list = self.hostlists[color].read().await;
+        let list = self.hostlists[color].read().unwrap();
 
         let mut limit = match limit {
             Some(l) => l.min(list.len()),
@@ -546,14 +545,14 @@ impl HostContainer {
 
     /// Get a random peer from a hostlist that matches the given transport
     /// schemes.
-    pub(in crate::net) async fn fetch_random_with_schemes(
+    pub(in crate::net) fn fetch_random_with_schemes(
         &self,
         color: HostColor,
         schemes: &[String],
     ) -> Option<((Url, u64), usize)> {
         // Retrieve all peers corresponding to that transport schemes
         trace!(target: "net::hosts::fetch_random_with_schemes()", "[START] {:?}", color);
-        let list = self.fetch_with_schemes(color as usize, schemes, None).await;
+        let list = self.fetch_with_schemes(color as usize, schemes, None);
 
         if list.is_empty() {
             return None
@@ -565,7 +564,7 @@ impl HostContainer {
     }
 
     /// Get up to n random peers. Schemes are not taken into account.
-    pub(in crate::net) async fn fetch_n_random(&self, color: HostColor, n: u32) -> Vec<(Url, u64)> {
+    pub(in crate::net) fn fetch_n_random(&self, color: HostColor, n: u32) -> Vec<(Url, u64)> {
         trace!(target: "net::hosts::fetch_n_random()", "[START] {:?}", color);
         let n = n as usize;
         if n == 0 {
@@ -573,7 +572,7 @@ impl HostContainer {
         }
         let mut hosts = vec![];
 
-        let list = self.hostlists[color as usize].read().await;
+        let list = self.hostlists[color as usize].read().unwrap();
 
         for (addr, last_seen) in list.iter() {
             hosts.push((addr.clone(), *last_seen));
@@ -590,7 +589,7 @@ impl HostContainer {
     }
 
     /// Get up to n random peers that match the given transport schemes.
-    pub(in crate::net) async fn fetch_n_random_with_schemes(
+    pub(in crate::net) fn fetch_n_random_with_schemes(
         &self,
         color: HostColor,
         schemes: &[String],
@@ -604,7 +603,7 @@ impl HostContainer {
         }
 
         // Retrieve all peers corresponding to that transport schemes
-        let hosts = self.fetch_with_schemes(index, schemes, None).await;
+        let hosts = self.fetch_with_schemes(index, schemes, None);
         if hosts.is_empty() {
             debug!(target: "net::hosts::fetch_n_random_with_schemes()",
                   "No such schemes found!");
@@ -618,7 +617,7 @@ impl HostContainer {
 
     /// Get up to n random peers that don't match the given transport schemes
     /// from a hostlist.
-    pub(in crate::net) async fn fetch_n_random_excluding_schemes(
+    pub(in crate::net) fn fetch_n_random_excluding_schemes(
         &self,
         color: HostColor,
         schemes: &[String],
@@ -631,7 +630,7 @@ impl HostContainer {
             return vec![]
         }
         // Retrieve all peers not corresponding to that transport schemes
-        let hosts = self.fetch_excluding_schemes(index, schemes, None).await;
+        let hosts = self.fetch_excluding_schemes(index, schemes, None);
 
         if hosts.is_empty() {
             debug!(target: "net::hosts::fetch_n_random_excluding_schemes()",
@@ -645,9 +644,9 @@ impl HostContainer {
     }
 
     /// Remove an entry from a hostlist if it exists.
-    pub async fn remove_if_exists(&self, color: HostColor, addr: &Url) {
+    pub fn remove_if_exists(&self, color: HostColor, addr: &Url) {
         let color_code = color.clone() as usize;
-        let mut list = self.hostlists[color_code].write().await;
+        let mut list = self.hostlists[color_code].write().unwrap();
         if let Some(position) = list.iter().position(|(u, _)| u == addr) {
             debug!(target: "net::hosts::remove_if_exists()", "Removing addr={} list={:?}", addr, color);
             list.remove(position);
@@ -655,32 +654,32 @@ impl HostContainer {
     }
 
     /// Check if a hostlist is empty.
-    pub async fn is_empty(&self, color: HostColor) -> bool {
-        self.hostlists[color as usize].read().await.is_empty()
+    pub fn is_empty(&self, color: HostColor) -> bool {
+        self.hostlists[color as usize].read().unwrap().is_empty()
     }
 
     /// Check if host is in a hostlist
-    pub async fn contains(&self, color: usize, addr: &Url) -> bool {
-        self.hostlists[color].read().await.iter().any(|(u, _t)| u == addr)
+    pub fn contains(&self, color: usize, addr: &Url) -> bool {
+        self.hostlists[color].read().unwrap().iter().any(|(u, _t)| u == addr)
     }
 
     /// Get the index for a given addr on a hostlist.
-    pub async fn get_index_at_addr(&self, color: usize, addr: Url) -> Option<usize> {
-        self.hostlists[color].read().await.iter().position(|a| a.0 == addr)
+    pub fn get_index_at_addr(&self, color: usize, addr: Url) -> Option<usize> {
+        self.hostlists[color].read().unwrap().iter().position(|a| a.0 == addr)
     }
 
     /// Get the last_seen field for a given entry on a hostlist.
-    pub async fn get_last_seen(&self, color: usize, addr: &Url) -> Option<u64> {
+    pub fn get_last_seen(&self, color: usize, addr: &Url) -> Option<u64> {
         self.hostlists[color]
             .read()
-            .await
+            .unwrap()
             .iter()
             .find(|(url, _)| url == addr)
             .map(|(_, last_seen)| *last_seen)
     }
 
     /// Load the hostlists from a file.
-    pub(in crate::net) async fn load_all(&self, path: &str) -> Result<()> {
+    pub(in crate::net) fn load_all(&self, path: &str) -> Result<()> {
         let path = expand_path(path)?;
 
         if !path.exists() {
@@ -718,16 +717,16 @@ impl HostContainer {
 
             match data[0] {
                 "gold" => {
-                    self.store(HostColor::Gold as usize, url, last_seen).await;
+                    self.store(HostColor::Gold as usize, url, last_seen);
                 }
                 "white" => {
-                    self.store(HostColor::White as usize, url, last_seen).await;
+                    self.store(HostColor::White as usize, url, last_seen);
                 }
                 "grey" => {
-                    self.store(HostColor::Grey as usize, url, last_seen).await;
+                    self.store(HostColor::Grey as usize, url, last_seen);
                 }
                 "dark" => {
-                    self.store(HostColor::Dark as usize, url, last_seen).await;
+                    self.store(HostColor::Dark as usize, url, last_seen);
                 }
                 _ => {
                     debug!(target: "net::hosts::load_hosts()", "Malformed list name...");
@@ -739,16 +738,16 @@ impl HostContainer {
     }
 
     /// Save the hostlist to a file.
-    pub(in crate::net) async fn save_all(&self, path: &str) -> Result<()> {
+    pub(in crate::net) fn save_all(&self, path: &str) -> Result<()> {
         let path = expand_path(path)?;
 
         let mut tsv = String::new();
         let mut hostlist: HashMap<String, Vec<(Url, u64)>> = HashMap::new();
 
-        hostlist.insert("dark".to_string(), self.fetch_all(HostColor::Dark).await);
-        hostlist.insert("grey".to_string(), self.fetch_all(HostColor::Grey).await);
-        hostlist.insert("white".to_string(), self.fetch_all(HostColor::White).await);
-        hostlist.insert("gold".to_string(), self.fetch_all(HostColor::Gold).await);
+        hostlist.insert("dark".to_string(), self.fetch_all(HostColor::Dark));
+        hostlist.insert("grey".to_string(), self.fetch_all(HostColor::Grey));
+        hostlist.insert("white".to_string(), self.fetch_all(HostColor::White));
+        hostlist.insert("gold".to_string(), self.fetch_all(HostColor::Gold));
 
         for (name, list) in hostlist {
             for (url, last_seen) in list {
@@ -823,7 +822,7 @@ impl Hosts {
         // First filter these address to ensure this peer doesn't exist in our black, gold or
         // whitelist and apply transport filtering. If we don't support this transport,
         // store the peer on our dark list to broadcast to other nodes.
-        let filtered_addrs = self.filter_addresses(self.settings.clone(), addrs).await;
+        let filtered_addrs = self.filter_addresses(self.settings.clone(), addrs);
         let mut addrs_len = 0;
 
         if filtered_addrs.is_empty() {
@@ -840,7 +839,7 @@ impl Hosts {
             }
 
             addrs_len += i + 1;
-            self.container.store_or_update(color.clone(), addr.clone(), *last_seen).await;
+            self.container.store_or_update(color.clone(), addr.clone(), *last_seen);
 
             // Free up this peer for usage by other parts of the code base.
             // This is a safe since the hostlist modification is now complete.
@@ -901,7 +900,7 @@ impl Hosts {
 
     // Loop through hosts selected by Outbound Session and see if any of them are
     // free to connect to.
-    pub(in crate::net) async fn check_addrs(&self, hosts: Vec<(Url, u64)>) -> Option<(Url, u64)> {
+    pub(in crate::net) fn check_addrs(&self, hosts: Vec<(Url, u64)>) -> Option<(Url, u64)> {
         trace!(target: "net::hosts::check_addrs()", "[START]");
         for (host, last_seen) in hosts {
             // Print a warning if we are trying to connect to a seed node in
@@ -1009,7 +1008,7 @@ impl Hosts {
     // to move this function to a more appropriate location
     // in the codebase.
     /// Check whether a URL is local host
-    pub async fn is_local_host(&self, url: Url) -> bool {
+    pub fn is_local_host(&self, url: Url) -> bool {
         // Reject Urls without host strings.
         if url.host_str().is_none() {
             return false
@@ -1040,7 +1039,7 @@ impl Hosts {
     }
 
     /// Check whether a URL is IPV6
-    pub async fn is_ipv6(&self, url: Url) -> bool {
+    pub fn is_ipv6(&self, url: Url) -> bool {
         // Reject Urls without host strings.
         if url.host_str().is_none() {
             return false
@@ -1056,18 +1055,18 @@ impl Hosts {
     }
 
     /// Import blacklisted peers specified in the config file.
-    pub(in crate::net) async fn import_blacklist(&self) -> Result<()> {
+    pub(in crate::net) fn import_blacklist(&self) -> Result<()> {
         for (mut host, ports) in self.settings.blacklist.clone() {
             // If the ports are empty, simply store the host_str. We will use this to
             // blacklist all ports of a given peer in `block_all_ports()`.
             if ports.is_empty() {
-                self.container.store(HostColor::Black as usize, host.clone(), 0).await;
+                self.container.store(HostColor::Black as usize, host.clone(), 0);
             }
             // Otherwise, store all the specified ports.
             else {
                 for port in ports {
                     host.set_port(Some(port))?;
-                    self.container.store(HostColor::Black as usize, host.clone(), 0).await;
+                    self.container.store(HostColor::Black as usize, host.clone(), 0);
                 }
             }
         }
@@ -1076,21 +1075,17 @@ impl Hosts {
 
     /// If we have the Host of the Url in the hostlist, and there are no ports stored,
     /// we should block all ports of this peer.
-    pub(in crate::net) async fn block_all_ports(&self, addr: String) -> bool {
+    pub(in crate::net) fn block_all_ports(&self, addr: String) -> bool {
         self.container.hostlists[HostColor::Black as usize]
             .read()
-            .await
+            .unwrap()
             .iter()
             .any(|(u, _t)| u.host_str().unwrap() == addr && u.port().is_none())
     }
 
     /// Filter given addresses based on certain rulesets and validity. Strictly called only on
     /// the first time learning of new peers.
-    async fn filter_addresses(
-        &self,
-        settings: SettingsPtr,
-        addrs: &[(Url, u64)],
-    ) -> Vec<(Url, u64)> {
+    fn filter_addresses(&self, settings: SettingsPtr, addrs: &[(Url, u64)]) -> Vec<(Url, u64)> {
         debug!(target: "net::hosts::filter_addresses()", "Filtering addrs: {:?}", addrs);
         let mut ret = vec![];
         let localnet = self.settings.localnet;
@@ -1116,8 +1111,8 @@ impl Hosts {
             }
 
             // Blacklist peers should never enter the hostlist.
-            if self.container.contains(HostColor::Black as usize, addr_).await ||
-                self.block_all_ports(addr_.host_str().unwrap().to_string()).await
+            if self.container.contains(HostColor::Black as usize, addr_) ||
+                self.block_all_ports(addr_.host_str().unwrap().to_string())
             {
                 warn!(target: "net::hosts::filter_addresses()",
                       "[{}] is blacklisted", addr_);
@@ -1153,7 +1148,7 @@ impl Hosts {
             // Filter non-global ranges if we're not allowing localnet.
             // Should never be allowed in production, so we don't really care
             // about some of them (e.g. 0.0.0.0, or broadcast, etc.).
-            if !localnet && self.is_local_host(addr).await {
+            if !localnet && self.is_local_host(addr) {
                 debug!(target: "net::hosts::filter_addresses()",
                        "[{}] Filtering non-global ranges", addr_);
                 continue
@@ -1188,9 +1183,9 @@ impl Hosts {
             // We will personally ignore this peer but still send it to others in
             // Protocol Addr to ensure all transports get propagated.
             if !settings.allowed_transports.contains(&addr_.scheme().to_string()) ||
-                (!ipv6_available && self.is_ipv6(addr_.clone()).await)
+                (!ipv6_available && self.is_ipv6(addr_.clone()))
             {
-                self.container.store_or_update(HostColor::Dark, addr_.clone(), *last_seen).await;
+                self.container.store_or_update(HostColor::Dark, addr_.clone(), *last_seen);
 
                 continue
             }
@@ -1198,9 +1193,9 @@ impl Hosts {
             // Reject this peer if it's already stored on the Gold, White or Grey list.
             //
             // We do this last since it is the most expensive operation.
-            if self.container.contains(HostColor::Gold as usize, addr_).await ||
-                self.container.contains(HostColor::White as usize, addr_).await ||
-                self.container.contains(HostColor::Grey as usize, addr_).await
+            if self.container.contains(HostColor::Gold as usize, addr_) ||
+                self.container.contains(HostColor::White as usize, addr_) ||
+                self.container.contains(HostColor::Grey as usize, addr_)
             {
                 debug!(target: "net::hosts::filter_addresses()", "[{}] exists! Skipping", addr_);
                 continue
@@ -1214,22 +1209,22 @@ impl Hosts {
 
     /// Method to fetch the last_seen field for a give address when we do
     /// not know what hostlist it is on.
-    pub async fn fetch_last_seen(&self, addr: &Url) -> Option<u64> {
-        if self.container.contains(HostColor::Gold as usize, addr).await {
-            self.container.get_last_seen(HostColor::Gold as usize, addr).await
-        } else if self.container.contains(HostColor::White as usize, addr).await {
-            self.container.get_last_seen(HostColor::White as usize, addr).await
-        } else if self.container.contains(HostColor::Grey as usize, addr).await {
-            self.container.get_last_seen(HostColor::Grey as usize, addr).await
+    pub fn fetch_last_seen(&self, addr: &Url) -> Option<u64> {
+        if self.container.contains(HostColor::Gold as usize, addr) {
+            self.container.get_last_seen(HostColor::Gold as usize, addr)
+        } else if self.container.contains(HostColor::White as usize, addr) {
+            self.container.get_last_seen(HostColor::White as usize, addr)
+        } else if self.container.contains(HostColor::Grey as usize, addr) {
+            self.container.get_last_seen(HostColor::Grey as usize, addr)
         } else {
             None
         }
     }
 
     /// Downgrade host to Greylist, remove from Gold or White list.
-    pub async fn greylist_host(&self, addr: &Url, last_seen: u64) -> Result<()> {
+    pub fn greylist_host(&self, addr: &Url, last_seen: u64) -> Result<()> {
         debug!(target: "net::hosts:greylist_host()", "Downgrading addr={}", addr);
-        self.move_host(addr, last_seen, HostColor::Grey).await?;
+        self.move_host(addr, last_seen, HostColor::Grey)?;
 
         // Free up this addr for future operations.
         self.unregister(addr);
@@ -1244,7 +1239,7 @@ impl Hosts {
     /// * When the refinery passes successfully: move to white, remove from greylist.
     /// * When we connect to a peer, move to gold, remove from white or grey.
     /// * When we add a peer to the black list: move to black, remove from all other lists.
-    pub(in crate::net) async fn move_host(
+    pub(in crate::net) fn move_host(
         &self,
         addr: &Url,
         last_seen: u64,
@@ -1259,22 +1254,22 @@ impl Hosts {
         match destination {
             // Downgrade to grey. Remove from white and gold.
             HostColor::Grey => {
-                self.container.remove_if_exists(HostColor::Gold, addr).await;
-                self.container.remove_if_exists(HostColor::White, addr).await;
-                self.container.store_or_update(HostColor::Grey, addr.clone(), last_seen).await;
+                self.container.remove_if_exists(HostColor::Gold, addr);
+                self.container.remove_if_exists(HostColor::White, addr);
+                self.container.store_or_update(HostColor::Grey, addr.clone(), last_seen);
             }
 
             // Remove from Greylist, add to Whitelist. Called by the Refinery.
             HostColor::White => {
-                self.container.remove_if_exists(HostColor::Grey, addr).await;
-                self.container.store_or_update(HostColor::White, addr.clone(), last_seen).await;
+                self.container.remove_if_exists(HostColor::Grey, addr);
+                self.container.store_or_update(HostColor::White, addr.clone(), last_seen);
             }
 
             // Upgrade to gold. Remove from white or grey.
             HostColor::Gold => {
-                self.container.remove_if_exists(HostColor::Grey, addr).await;
-                self.container.remove_if_exists(HostColor::White, addr).await;
-                self.container.store_or_update(HostColor::Gold, addr.clone(), last_seen).await;
+                self.container.remove_if_exists(HostColor::Grey, addr);
+                self.container.remove_if_exists(HostColor::White, addr);
+                self.container.store_or_update(HostColor::Gold, addr.clone(), last_seen);
             }
 
             // Move to black. Remove from all other lists.
@@ -1284,14 +1279,14 @@ impl Hosts {
                 if addr.host_str().is_some() {
                     // Localhost connections should never enter the blacklist
                     // This however allows any Tor and Nym connections.
-                    if self.is_local_host(addr.clone()).await {
+                    if self.is_local_host(addr.clone()) {
                         return Ok(());
                     }
 
-                    self.container.remove_if_exists(HostColor::Grey, addr).await;
-                    self.container.remove_if_exists(HostColor::White, addr).await;
-                    self.container.remove_if_exists(HostColor::Gold, addr).await;
-                    self.container.store_or_update(HostColor::Black, addr.clone(), last_seen).await;
+                    self.container.remove_if_exists(HostColor::Grey, addr);
+                    self.container.remove_if_exists(HostColor::White, addr);
+                    self.container.remove_if_exists(HostColor::Gold, addr);
+                    self.container.store_or_update(HostColor::Black, addr.clone(), last_seen);
                 }
             }
 
@@ -1311,134 +1306,126 @@ mod tests {
 
     #[test]
     fn test_is_local_host() {
-        smol::block_on(async {
-            let settings = Settings {
-                localnet: false,
-                external_addrs: vec![
-                    Url::parse("tcp://foo.bar:123").unwrap(),
-                    Url::parse("tcp://lol.cat:321").unwrap(),
-                ],
-                ..Default::default()
-            };
-            let hosts = Hosts::new(Arc::new(settings.clone()));
-
-            let local_hosts: Vec<Url> = vec![
-                Url::parse("tcp://localhost").unwrap(),
-                Url::parse("tcp://127.0.0.1").unwrap(),
-                Url::parse("tcp+tls://[::1]").unwrap(),
-                Url::parse("tcp://localhost.localdomain").unwrap(),
-                Url::parse("tcp://192.168.10.65").unwrap(),
-            ];
-            for host in local_hosts {
-                eprintln!("{}", host);
-                assert!(hosts.is_local_host(host).await);
-            }
-            let remote_hosts: Vec<Url> = vec![
-                Url::parse("https://dyne.org").unwrap(),
-                Url::parse("tcp://77.168.10.65:2222").unwrap(),
-                Url::parse("tcp://[2345:0425:2CA1:0000:0000:0567:5673:23b5]").unwrap(),
-                Url::parse("http://eweiibe6tdjsdprb4px6rqrzzcsi22m4koia44kc5pcjr7nec2rlxyad.onion")
-                    .unwrap(),
-            ];
-            for host in remote_hosts {
-                assert!(!hosts.is_local_host(host).await)
-            }
-        });
+        let settings = Settings {
+            localnet: false,
+            external_addrs: vec![
+                Url::parse("tcp://foo.bar:123").unwrap(),
+                Url::parse("tcp://lol.cat:321").unwrap(),
+            ],
+            ..Default::default()
+        };
+        let hosts = Hosts::new(Arc::new(settings.clone()));
+
+        let local_hosts: Vec<Url> = vec![
+            Url::parse("tcp://localhost").unwrap(),
+            Url::parse("tcp://127.0.0.1").unwrap(),
+            Url::parse("tcp+tls://[::1]").unwrap(),
+            Url::parse("tcp://localhost.localdomain").unwrap(),
+            Url::parse("tcp://192.168.10.65").unwrap(),
+        ];
+        for host in local_hosts {
+            eprintln!("{}", host);
+            assert!(hosts.is_local_host(host));
+        }
+        let remote_hosts: Vec<Url> = vec![
+            Url::parse("https://dyne.org").unwrap(),
+            Url::parse("tcp://77.168.10.65:2222").unwrap(),
+            Url::parse("tcp://[2345:0425:2CA1:0000:0000:0567:5673:23b5]").unwrap(),
+            Url::parse("http://eweiibe6tdjsdprb4px6rqrzzcsi22m4koia44kc5pcjr7nec2rlxyad.onion")
+                .unwrap(),
+        ];
+        for host in remote_hosts {
+            assert!(!hosts.is_local_host(host))
+        }
     }
 
     #[test]
     fn test_is_ipv6() {
-        smol::block_on(async {
-            let settings = Settings { ..Default::default() };
-            let hosts = Hosts::new(Arc::new(settings.clone()));
+        let settings = Settings { ..Default::default() };
+        let hosts = Hosts::new(Arc::new(settings.clone()));
 
-            let ipv6_hosts: Vec<Url> = vec![
-                Url::parse("tcp+tls://[::1]").unwrap(),
-                Url::parse("tcp://[2001:0000:130F:0000:0000:09C0:876A:130B]").unwrap(),
-                Url::parse("tcp://[2345:0425:2CA1:0000:0000:0567:5673:23b5]").unwrap(),
-            ];
+        let ipv6_hosts: Vec<Url> = vec![
+            Url::parse("tcp+tls://[::1]").unwrap(),
+            Url::parse("tcp://[2001:0000:130F:0000:0000:09C0:876A:130B]").unwrap(),
+            Url::parse("tcp://[2345:0425:2CA1:0000:0000:0567:5673:23b5]").unwrap(),
+        ];
 
-            let ipv4_hosts: Vec<Url> = vec![
-                Url::parse("tcp://192.168.10.65").unwrap(),
-                Url::parse("https://dyne.org").unwrap(),
-                Url::parse("tcp+tls://agorism.xyz").unwrap(),
-            ];
+        let ipv4_hosts: Vec<Url> = vec![
+            Url::parse("tcp://192.168.10.65").unwrap(),
+            Url::parse("https://dyne.org").unwrap(),
+            Url::parse("tcp+tls://agorism.xyz").unwrap(),
+        ];
 
-            for host in ipv6_hosts {
-                assert!(hosts.is_ipv6(host).await)
-            }
+        for host in ipv6_hosts {
+            assert!(hosts.is_ipv6(host))
+        }
 
-            for host in ipv4_hosts {
-                assert!(!hosts.is_ipv6(host).await)
-            }
-        });
+        for host in ipv4_hosts {
+            assert!(!hosts.is_ipv6(host))
+        }
     }
 
     #[test]
     fn test_block_all_ports() {
-        smol::block_on(async {
-            let settings = Settings { ..Default::default() };
+        let settings = Settings { ..Default::default() };
 
-            let hosts = Hosts::new(Arc::new(settings.clone()));
-            let blacklist1 = Url::parse("tcp+tls://nietzsche.king:333").unwrap();
-            let blacklist2 = Url::parse("tcp+tls://agorism.xyz").unwrap();
+        let hosts = Hosts::new(Arc::new(settings.clone()));
+        let blacklist1 = Url::parse("tcp+tls://nietzsche.king:333").unwrap();
+        let blacklist2 = Url::parse("tcp+tls://agorism.xyz").unwrap();
 
-            hosts.container.store(HostColor::Black as usize, blacklist1.clone(), 0).await;
-            hosts.container.store(HostColor::Black as usize, blacklist2.clone(), 0).await;
+        hosts.container.store(HostColor::Black as usize, blacklist1.clone(), 0);
+        hosts.container.store(HostColor::Black as usize, blacklist2.clone(), 0);
 
-            assert!(hosts.block_all_ports(blacklist2.host_str().unwrap().to_string()).await);
-            assert!(!hosts.block_all_ports(blacklist1.host_str().unwrap().to_string()).await);
-        });
+        assert!(hosts.block_all_ports(blacklist2.host_str().unwrap().to_string()));
+        assert!(!hosts.block_all_ports(blacklist1.host_str().unwrap().to_string()));
     }
 
     #[test]
     fn test_store() {
         let last_seen = UNIX_EPOCH.elapsed().unwrap().as_secs();
 
-        smol::block_on(async {
-            let settings = Settings { ..Default::default() };
+        let settings = Settings { ..Default::default() };
 
-            let hosts = Hosts::new(Arc::new(settings.clone()));
-            let grey_hosts = vec![
-                Url::parse("tcp://localhost:3921").unwrap(),
-                Url::parse("tor://[::1]:21481").unwrap(),
-                Url::parse("tcp://192.168.10.65:311").unwrap(),
-                Url::parse("tcp+tls://0.0.0.0:2312").unwrap(),
-                Url::parse("tcp://255.255.255.255:2131").unwrap(),
-            ];
-
-            for addr in &grey_hosts {
-                hosts.container.store(HostColor::Grey as usize, addr.clone(), last_seen).await;
-            }
-            assert!(!hosts.container.is_empty(HostColor::Grey).await);
-
-            let white_hosts = vec![
-                Url::parse("tcp://localhost:3921").unwrap(),
-                Url::parse("tor://[::1]:21481").unwrap(),
-                Url::parse("tcp://192.168.10.65:311").unwrap(),
-                Url::parse("tcp+tls://0.0.0.0:2312").unwrap(),
-                Url::parse("tcp://255.255.255.255:2131").unwrap(),
-            ];
-
-            for host in &white_hosts {
-                hosts.container.store(HostColor::White as usize, host.clone(), last_seen).await;
-            }
-            assert!(!hosts.container.is_empty(HostColor::White).await);
+        let hosts = Hosts::new(Arc::new(settings.clone()));
+        let grey_hosts = vec![
+            Url::parse("tcp://localhost:3921").unwrap(),
+            Url::parse("tor://[::1]:21481").unwrap(),
+            Url::parse("tcp://192.168.10.65:311").unwrap(),
+            Url::parse("tcp+tls://0.0.0.0:2312").unwrap(),
+            Url::parse("tcp://255.255.255.255:2131").unwrap(),
+        ];
 
-            let gold_hosts = vec![
-                Url::parse("tcp://dark.fi:80").unwrap(),
-                Url::parse("tcp://http.cat:401").unwrap(),
-                Url::parse("tcp://foo.bar:111").unwrap(),
-            ];
+        for addr in &grey_hosts {
+            hosts.container.store(HostColor::Grey as usize, addr.clone(), last_seen);
+        }
+        assert!(!hosts.container.is_empty(HostColor::Grey));
+
+        let white_hosts = vec![
+            Url::parse("tcp://localhost:3921").unwrap(),
+            Url::parse("tor://[::1]:21481").unwrap(),
+            Url::parse("tcp://192.168.10.65:311").unwrap(),
+            Url::parse("tcp+tls://0.0.0.0:2312").unwrap(),
+            Url::parse("tcp://255.255.255.255:2131").unwrap(),
+        ];
 
-            for host in &gold_hosts {
-                hosts.container.store(HostColor::Gold as usize, host.clone(), last_seen).await;
-            }
+        for host in &white_hosts {
+            hosts.container.store(HostColor::White as usize, host.clone(), last_seen);
+        }
+        assert!(!hosts.container.is_empty(HostColor::White));
 
-            assert!(hosts.container.contains(HostColor::Grey as usize, &grey_hosts[0]).await);
-            assert!(hosts.container.contains(HostColor::White as usize, &white_hosts[1]).await);
-            assert!(hosts.container.contains(HostColor::Gold as usize, &gold_hosts[2]).await);
-        });
+        let gold_hosts = vec![
+            Url::parse("tcp://dark.fi:80").unwrap(),
+            Url::parse("tcp://http.cat:401").unwrap(),
+            Url::parse("tcp://foo.bar:111").unwrap(),
+        ];
+
+        for host in &gold_hosts {
+            hosts.container.store(HostColor::Gold as usize, host.clone(), last_seen);
+        }
+
+        assert!(hosts.container.contains(HostColor::Grey as usize, &grey_hosts[0]));
+        assert!(hosts.container.contains(HostColor::White as usize, &white_hosts[1]));
+        assert!(hosts.container.contains(HostColor::Gold as usize, &gold_hosts[2]));
     }
 
     #[test]
@@ -1452,16 +1439,16 @@ mod tests {
                 sleep(1).await;
                 let last_seen = UNIX_EPOCH.elapsed().unwrap().as_secs();
                 let url = Url::parse(&format!("tcp://whitelist{}:123", i)).unwrap();
-                hosts.container.store(HostColor::White as usize, url.clone(), last_seen).await;
+                hosts.container.store(HostColor::White as usize, url.clone(), last_seen);
             }
 
             for (url, last_seen) in
-                hosts.container.hostlists[HostColor::White as usize].read().await.iter()
+                hosts.container.hostlists[HostColor::White as usize].read().unwrap().iter()
             {
                 println!("{} {}", url, last_seen);
             }
 
-            let entry = hosts.container.fetch_last(HostColor::White).await.unwrap();
+            let entry = hosts.container.fetch_last(HostColor::White).unwrap();
             println!("last entry: {} {}", entry.0, entry.1);
         });
     }

src/net/protocol/protocol_address.rs

@@ -151,30 +151,20 @@ impl ProtocolAddress {
             // First we grab address with the requested transports from the gold list
             debug!(target: "net::protocol_address::handle_receive_get_addrs()",
             "Fetching gold entries with schemes");
-            let mut addrs = self
-                .hosts
-                .container
-                .fetch_n_random_with_schemes(
-                    HostColor::Gold,
-                    &get_addrs_msg.transports,
-                    get_addrs_msg.max,
-                )
-                .await;
+            let mut addrs = self.hosts.container.fetch_n_random_with_schemes(
+                HostColor::Gold,
+                &get_addrs_msg.transports,
+                get_addrs_msg.max,
+            );
 
             // Then we grab address with the requested transports from the whitelist
             debug!(target: "net::protocol_address::handle_receive_get_addrs()",
             "Fetching whitelist entries with schemes");
-            addrs.append(
-                &mut self
-                    .hosts
-                    .container
-                    .fetch_n_random_with_schemes(
-                        HostColor::White,
-                        &get_addrs_msg.transports,
-                        get_addrs_msg.max,
-                    )
-                    .await,
-            );
+            addrs.append(&mut self.hosts.container.fetch_n_random_with_schemes(
+                HostColor::White,
+                &get_addrs_msg.transports,
+                get_addrs_msg.max,
+            ));
 
             // Next we grab addresses without the requested transports
             // to fill a 2 * max length vector.
@@ -183,33 +173,21 @@ impl ProtocolAddress {
             debug!(target: "net::protocol_address::handle_receive_get_addrs()",
             "Fetching gold entries without schemes");
             let remain = 2 * get_addrs_msg.max - addrs.len() as u32;
-            addrs.append(
-                &mut self
-                    .hosts
-                    .container
-                    .fetch_n_random_excluding_schemes(
-                        HostColor::Gold,
-                        &get_addrs_msg.transports,
-                        remain,
-                    )
-                    .await,
-            );
+            addrs.append(&mut self.hosts.container.fetch_n_random_excluding_schemes(
+                HostColor::Gold,
+                &get_addrs_msg.transports,
+                remain,
+            ));
 
             // Then we grab address without the requested transports from the white list
             debug!(target: "net::protocol_address::handle_receive_get_addrs()",
             "Fetching white entries without schemes");
             let remain = 2 * get_addrs_msg.max - addrs.len() as u32;
-            addrs.append(
-                &mut self
-                    .hosts
-                    .container
-                    .fetch_n_random_excluding_schemes(
-                        HostColor::White,
-                        &get_addrs_msg.transports,
-                        remain,
-                    )
-                    .await,
-            );
+            addrs.append(&mut self.hosts.container.fetch_n_random_excluding_schemes(
+                HostColor::White,
+                &get_addrs_msg.transports,
+                remain,
+            ));
 
             // If there's still space available, take from the Dark list.
 
@@ -221,7 +199,7 @@ impl ProtocolAddress {
             debug!(target: "net::protocol_address::handle_receive_get_addrs()",
             "Fetching dark entries");
             let remain = 2 * get_addrs_msg.max - addrs.len() as u32;
-            addrs.append(&mut self.hosts.container.fetch_n_random(HostColor::Dark, remain).await);
+            addrs.append(&mut self.hosts.container.fetch_n_random(HostColor::Dark, remain));
 
             debug!(
                 target: "net::protocol_address::handle_receive_get_addrs()",

src/net/session/mod.rs

@@ -78,8 +78,8 @@ pub async fn remove_sub_on_stop(p2p: P2pPtr, channel: ChannelPtr, type_id: Sessi
             "Downgrading {}", addr,
         );
 
-        let last_seen = hosts.fetch_last_seen(addr).await.unwrap();
-        hosts.move_host(addr, last_seen, HostColor::Grey).await.unwrap();
+        let last_seen = hosts.fetch_last_seen(addr).unwrap();
+        hosts.move_host(addr, last_seen, HostColor::Grey).unwrap();
     }
 
     // Remove channel from the HostRegistry. Free up this addr for any future operation.
@@ -181,7 +181,6 @@ pub trait Session: Sync {
                     self.p2p()
                         .hosts()
                         .move_host(channel.address(), last_seen, HostColor::Gold)
-                        .await
                         .unwrap();
                 }
 

src/net/session/outbound_session.rs

@@ -203,7 +203,7 @@ impl Slot {
     /// and healthy since we require the network retains some unreliable
     /// connections. A network that purely favors uptime over unreliable
     /// connections may be vulnerable to sybil by attackers with good uptime.
-    async fn fetch_addrs(&self) -> Option<(Url, u64)> {
+    fn fetch_addrs(&self) -> Option<(Url, u64)> {
         let hosts = self.p2p().hosts();
         let slot = self.slot as usize;
         let settings = self.p2p().settings();
@@ -216,22 +216,22 @@ impl Slot {
         let transport_mixing = settings.transport_mixing;
         let preference_strict = &settings.slot_preference_strict;
 
-        let grey_only = hosts.container.is_empty(HostColor::White).await &&
-            hosts.container.is_empty(HostColor::Gold).await &&
-            !hosts.container.is_empty(HostColor::Grey).await;
+        let grey_only = hosts.container.is_empty(HostColor::White) &&
+            hosts.container.is_empty(HostColor::Gold) &&
+            !hosts.container.is_empty(HostColor::Grey);
 
         // If we only have grey entries, select from the greylist. Otherwise,
         // use the preference defined in settings.
         let addrs = if grey_only && !preference_strict {
-            container.fetch(HostColor::Grey, transports, transport_mixing).await
+            container.fetch(HostColor::Grey, transports, transport_mixing)
         } else if slot < gold_count {
-            container.fetch(HostColor::Gold, transports, transport_mixing).await
+            container.fetch(HostColor::Gold, transports, transport_mixing)
         } else if slot < white_count {
-            container.fetch(HostColor::White, transports, transport_mixing).await
+            container.fetch(HostColor::White, transports, transport_mixing)
         } else {
-            container.fetch(HostColor::Grey, transports, transport_mixing).await
+            container.fetch(HostColor::Grey, transports, transport_mixing)
         };
-        hosts.check_addrs(addrs).await
+        hosts.check_addrs(addrs)
     }
 
     // We first try to make connections to the addresses on our gold list. We then find some
@@ -250,9 +250,9 @@ impl Slot {
 
             // Do peer discovery if we don't have any peers on the Grey, White or Gold list
             // (first time connecting to the network).
-            if hosts.container.is_empty(HostColor::Grey).await &&
-                hosts.container.is_empty(HostColor::White).await &&
-                hosts.container.is_empty(HostColor::Gold).await
+            if hosts.container.is_empty(HostColor::Grey) &&
+                hosts.container.is_empty(HostColor::White) &&
+                hosts.container.is_empty(HostColor::Gold)
             {
                 dnetev!(self, OutboundSlotSleeping, {
                     slot: self.slot,
@@ -267,7 +267,7 @@ impl Slot {
                 continue
             }
 
-            let addr = if let Some(addr) = self.fetch_addrs().await {
+            let addr = if let Some(addr) = self.fetch_addrs() {
                 debug!(target: "net::outbound_session::run()", "Fetched addr={}, slot #{}", addr.0,
                 self.slot);
                 addr
@@ -360,7 +360,7 @@ impl Slot {
                 );
 
                 // At this point we failed to connect. We'll downgrade this peer now.
-                self.p2p().hosts().move_host(&addr, last_seen, HostColor::Grey).await?;
+                self.p2p().hosts().move_host(&addr, last_seen, HostColor::Grey)?;
 
                 // Mark its state as Suspend, which sends this node to the Refinery for processing.
                 self.p2p().hosts().try_register(addr.clone(), HostState::Suspend).unwrap();
@@ -403,7 +403,7 @@ impl Slot {
                 }
 
                 // At this point we failed to connect. We'll downgrade this peer now.
-                self.p2p().hosts().move_host(&addr, last_seen, HostColor::Grey).await?;
+                self.p2p().hosts().move_host(&addr, last_seen, HostColor::Grey)?;
 
                 // Mark its state as Suspend, which sends it to the Refinery for processing.
                 self.p2p().hosts().try_register(addr.clone(), HostState::Suspend).unwrap();

src/net/session/refine_session.rs

@@ -71,7 +71,7 @@ impl RefineSession {
 
     /// Start the refinery and self handshake processes.
     pub(crate) async fn start(self: Arc<Self>) {
-        match self.p2p().hosts().container.load_all(&self.p2p().settings().hostlist).await {
+        match self.p2p().hosts().container.load_all(&self.p2p().settings().hostlist) {
             Ok(()) => {
                 debug!(target: "net::refine_session::start()", "Load hosts successful!");
             }
@@ -79,7 +79,7 @@ impl RefineSession {
                 warn!(target: "net::refine_session::start()", "Error loading hosts {}", e);
             }
         }
-        match self.p2p().hosts().import_blacklist().await {
+        match self.p2p().hosts().import_blacklist() {
             Ok(()) => {
                 debug!(target: "net::refine_session::start()", "Import blacklist successful!");
             }
@@ -98,7 +98,7 @@ impl RefineSession {
         debug!(target: "net::refine_session", "Stopping refinery process");
         self.refinery.clone().stop().await;
 
-        match self.p2p().hosts().container.save_all(&self.p2p().settings().hostlist).await {
+        match self.p2p().hosts().container.save_all(&self.p2p().settings().hostlist) {
             Ok(()) => {
                 debug!(target: "net::refine_session::stop()", "Save hosts successful!");
             }
@@ -225,7 +225,7 @@ impl GreylistRefinery {
         loop {
             sleep(settings.greylist_refinery_interval).await;
 
-            if hosts.container.is_empty(HostColor::Grey).await {
+            if hosts.container.is_empty(HostColor::Grey) {
                 debug!(target: "net::refinery",
                 "Greylist is empty! Cannot start refinery process");
 
@@ -259,7 +259,6 @@ impl GreylistRefinery {
             match hosts
                 .container
                 .fetch_random_with_schemes(HostColor::Grey, &settings.allowed_transports)
-                .await
             {
                 Some((entry, _)) => {
                     let url = &entry.0;
@@ -271,7 +270,7 @@ impl GreylistRefinery {
                     }
 
                     if !self.session().handshake_node(url.clone(), p2p.clone()).await {
-                        hosts.container.remove_if_exists(HostColor::Grey, url).await;
+                        hosts.container.remove_if_exists(HostColor::Grey, url);
 
                         debug!(
                             target: "net::refinery",
@@ -292,7 +291,7 @@ impl GreylistRefinery {
                     let last_seen = UNIX_EPOCH.elapsed().unwrap().as_secs();
 
                     // Add to the whitelist and remove from the greylist.
-                    hosts.move_host(url, last_seen, HostColor::White).await.unwrap();
+                    hosts.move_host(url, last_seen, HostColor::White).unwrap();
 
                     // When move is complete we can safely stop tracking this peer.
                     hosts.unregister(url);

src/net/session/seedsync_session.rs

@@ -240,7 +240,7 @@ impl Slot {
             }
 
             // Seed process complete
-            if self.p2p().hosts().container.is_empty(HostColor::Grey).await {
+            if self.p2p().hosts().container.is_empty(HostColor::Grey) {
                 warn!(target: "net::session::seedsync_session()",
                 "[P2P] Greylist empty after seeding");
             }

src/net/tests.rs

@@ -184,7 +184,7 @@ async fn get_random_gold_host(
     info!("Getting gold addr from node={}", external_addr);
     info!("========================================================");
 
-    let list = hosts.container.hostlists[HostColor::Gold as usize].read().await;
+    let list = hosts.container.hostlists[HostColor::Gold as usize].read().unwrap();
     assert!(!list.is_empty());
     let position = rand::thread_rng().gen_range(0..list.len());
     let entry = &list[position];
@@ -200,9 +200,9 @@ async fn _check_random_hostlist(outbound_instances: &Vec<Arc<P2p>>, rng: &mut Th
     info!("Checking node={}", external_addr);
     info!("========================================================");
 
-    let greylist = random_node.hosts().container.fetch_all(HostColor::Grey).await;
-    let whitelist = random_node.hosts().container.fetch_all(HostColor::White).await;
-    let goldlist = random_node.hosts().container.fetch_all(HostColor::Gold).await;
+    let greylist = random_node.hosts().container.fetch_all(HostColor::Grey);
+    let whitelist = random_node.hosts().container.fetch_all(HostColor::White);
+    let goldlist = random_node.hosts().container.fetch_all(HostColor::Gold);
 
     for (url, _) in greylist {
         assert!(urls.insert(url));
@@ -224,9 +224,9 @@ async fn check_all_hostlist(outbound_instances: &Vec<Arc<P2p>>) {
         info!("========================================================");
 
         let mut urls = HashSet::new();
-        let greylist = node.hosts().container.fetch_all(HostColor::Grey).await;
-        let whitelist = node.hosts().container.fetch_all(HostColor::White).await;
-        let goldlist = node.hosts().container.fetch_all(HostColor::Gold).await;
+        let greylist = node.hosts().container.fetch_all(HostColor::Grey);
+        let whitelist = node.hosts().container.fetch_all(HostColor::White);
+        let goldlist = node.hosts().container.fetch_all(HostColor::Gold);
 
         for (url, _) in greylist {
             assert!(urls.insert(url));
@@ -328,7 +328,7 @@ async fn p2p_test_real(ex: Arc<Executor<'static>>) {
     // 3. Assert that all nodes have shared their external addr
     //    with the seed node.
     // ===========================================================
-    let greylist = seed.hosts().container.fetch_all(HostColor::Grey).await;
+    let greylist = seed.hosts().container.fetch_all(HostColor::Grey);
     assert!(greylist.len() == N_NODES);
     info!("========================================================");
     info!("Seedsync session successful!");
@@ -343,16 +343,16 @@ async fn p2p_test_real(ex: Arc<Executor<'static>>) {
     // 4. Assert that seed node has at least one whitelist entry,
     //    indicating that the refinery process is happening correctly.
     // ===========================================================
-    assert!(!seed.hosts().container.is_empty(HostColor::White).await);
+    assert!(!seed.hosts().container.is_empty(HostColor::White));
 
     info!("========================================================");
     info!("Checking seed={}", seed.settings().inbound_addrs[0]);
     info!("========================================================");
 
     let mut urls = HashSet::new();
-    let greylist = seed.hosts().container.fetch_all(HostColor::Grey).await;
-    let whitelist = seed.hosts().container.fetch_all(HostColor::White).await;
-    let goldlist = seed.hosts().container.fetch_all(HostColor::Gold).await;
+    let greylist = seed.hosts().container.fetch_all(HostColor::Grey);
+    let whitelist = seed.hosts().container.fetch_all(HostColor::White);
+    let goldlist = seed.hosts().container.fetch_all(HostColor::Gold);
 
     for (url, _) in greylist {
         info!("Found grey url: {}", url);
@@ -377,7 +377,7 @@ async fn p2p_test_real(ex: Arc<Executor<'static>>) {
     info!("========================================================");
     sleep(10).await;
 
-    let whitelist = seed.hosts().container.fetch_all(HostColor::White).await;
+    let whitelist = seed.hosts().container.fetch_all(HostColor::White);
     assert!(whitelist.len() >= 2);
     // ===========================================================
     // 5. Select a random peer and ensure that its hostlist is not
@@ -417,8 +417,7 @@ async fn p2p_test_real(ex: Arc<Executor<'static>>) {
     outbound_instances[random_node_index]
         .hosts()
         .container
-        .contains(HostColor::Grey as usize, &addr)
-        .await;
+        .contains(HostColor::Grey as usize, &addr);
     info!("========================================================");
     info!("Greylist downgrade occured successfully!");
     info!("========================================================");