refactor: switch back to RwLock

Author: shumkov

Cargo.lock

@@ -37,7 +37,6 @@ lru = { version = "0.12.3" }
 serde = { version = "1.0.197", optional = true, features = ["derive"] }
 serde_json = { version = "1.0.120", optional = true }
 chrono = { version = "0.4.38", features = ["serde"] }
-dashmap = "6.1.0"
 
 [dev-dependencies]
 tokio = { version = "1.40", features = ["macros"] }

packages/rs-dapi-client/Cargo.toml

@@ -3,25 +3,21 @@
 use chrono::Utc;
 use dapi_grpc::tonic::codegen::http;
 use dapi_grpc::tonic::transport::Uri;
-use dashmap::setref::multiple::RefMulti;
-use dashmap::DashSet;
 use rand::{rngs::SmallRng, seq::IteratorRandom, SeedableRng};
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
+use std::mem;
 use std::str::FromStr;
-use std::sync::Arc;
+use std::sync::{Arc, RwLock};
 use std::time::Duration;
 
 const DEFAULT_BASE_BAN_PERIOD: Duration = Duration::from_secs(60);
 
 /// DAPI address.
 #[derive(Debug, Clone, Eq)]
 #[cfg_attr(feature = "mocks", derive(serde::Serialize, serde::Deserialize))]
-pub struct Address {
-    ban_count: usize,
-    banned_until: Option<chrono::DateTime<Utc>>,
-    #[cfg_attr(feature = "mocks", serde(with = "http_serde::uri"))]
-    uri: Uri,
-}
+pub struct Address(#[cfg_attr(feature = "mocks", serde(with = "http_serde::uri"))] Uri);
 
 impl FromStr for Address {
     type Err = AddressListError;
@@ -35,35 +31,46 @@ impl FromStr for Address {
 
 impl PartialEq<Self> for Address {
     fn eq(&self, other: &Self) -> bool {
-        self.uri == other.uri
+        self.0 == other.0
     }
 }
 
 impl PartialEq<Uri> for Address {
     fn eq(&self, other: &Uri) -> bool {
-        self.uri == *other
+        self.0 == *other
     }
 }
 
 impl Hash for Address {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        self.uri.hash(state);
+        self.0.hash(state);
     }
 }
 
 impl From<Uri> for Address {
     fn from(uri: Uri) -> Self {
-        Address {
-            ban_count: 0,
-            banned_until: None,
-            uri,
-        }
+        Address(uri)
     }
 }
 
 impl Address {
+    /// Get [Uri] of a node.
+    pub fn uri(&self) -> &Uri {
+        &self.0
+    }
+}
+
+/// Address status
+/// Contains information about the number of bans and the time until the next ban is lifted.
+#[derive(Debug, Default, Clone)]
+pub struct AddressStatus {
+    ban_count: usize,
+    banned_until: Option<chrono::DateTime<Utc>>,
+}
+
+impl AddressStatus {
     /// Ban the [Address] so it won't be available through [AddressList::get_live_address] for some time.
-    fn ban(&mut self, base_ban_period: &Duration) {
+    pub fn ban(&mut self, base_ban_period: &Duration) {
         let coefficient = (self.ban_count as f64).exp();
         let ban_period = Duration::from_secs_f64(base_ban_period.as_secs_f64() * coefficient);
 
@@ -77,24 +84,16 @@ impl Address {
     }
 
     /// Clears ban record.
-    fn unban(&mut self) {
+    pub fn unban(&mut self) {
         self.ban_count = 0;
         self.banned_until = None;
     }
-
-    /// Get [Uri] of a node.
-    pub fn uri(&self) -> &Uri {
-        &self.uri
-    }
 }
 
 /// [AddressList] errors
 #[derive(Debug, thiserror::Error)]
 #[cfg_attr(feature = "mocks", derive(serde::Serialize, serde::Deserialize))]
 pub enum AddressListError {
-    /// Specified address is not present in the list
-    #[error("address {0} not found in the list")]
-    AddressNotFound(#[cfg_attr(feature = "mocks", serde(with = "http_serde::uri"))] Uri),
     /// A valid uri is required to create an Address
     #[error("unable parse address: {0}")]
     #[cfg_attr(feature = "mocks", serde(skip))]
@@ -105,7 +104,7 @@ pub enum AddressListError {
 /// for [DapiRequest](crate::DapiRequest) execution.
 #[derive(Debug, Clone)]
 pub struct AddressList {
-    addresses: Arc<DashSet<Address>>,
+    addresses: Arc<RwLock<HashMap<Address, AddressStatus>>>,
     base_ban_period: Duration,
 }
 
@@ -117,7 +116,7 @@ impl Default for AddressList {
 
 impl std::fmt::Display for Address {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.uri.fmt(f)
+        self.0.fmt(f)
     }
 }
 
@@ -130,43 +129,70 @@ impl AddressList {
     /// Creates an empty [AddressList] with adjustable base ban time.
     pub fn with_settings(base_ban_period: Duration) -> Self {
         AddressList {
-            addresses: Arc::new(DashSet::new()),
+            addresses: Arc::new(RwLock::new(HashMap::new())),
             base_ban_period,
         }
     }
 
     /// Bans address
-    pub fn ban_address(&self, address: &Address) -> Result<(), AddressListError> {
-        if self.addresses.remove(address).is_none() {
-            return Err(AddressListError::AddressNotFound(address.uri.clone()));
-        };
+    /// Returns false if the address is not in the list.
+    pub fn ban(&self, address: &Address) -> bool {
+        let mut guard = self.addresses.write().unwrap();
 
-        let mut banned_address = address.clone();
-        banned_address.ban(&self.base_ban_period);
+        let Some(mut status) = guard.get_mut(address) else {
+            return false;
+        };
 
-        self.addresses.insert(banned_address);
+        status.ban(&self.base_ban_period);
 
-        Ok(())
+        true
     }
 
     /// Clears address' ban record
-    pub fn unban_address(&self, address: &Address) -> Result<(), AddressListError> {
-        if self.addresses.remove(address).is_none() {
-            return Err(AddressListError::AddressNotFound(address.uri.clone()));
+    /// Returns false if the address is not in the list.
+    pub fn unban(&self, address: &Address) -> bool {
+        let mut guard = self.addresses.write().unwrap();
+
+        let Some(mut status) = guard.get_mut(address) else {
+            return false;
         };
 
-        let mut unbanned_address = address.clone();
-        unbanned_address.unban();
+        status.unban();
+
+        true
+    }
 
-        self.addresses.insert(unbanned_address);
+    /// Check if the address is banned.
+    pub fn is_banned(&self, address: &Address) -> bool {
+        let guard = self.addresses.read().unwrap();
 
-        Ok(())
+        guard
+            .get(address)
+            .map(|status| status.is_banned())
+            .unwrap_or(false)
     }
 
     /// Adds a node [Address] to [AddressList]
     /// Returns false if the address is already in the list.
     pub fn add(&mut self, address: Address) -> bool {
-        self.addresses.insert(address)
+        let mut guard = self.addresses.write().unwrap();
+
+        match guard.entry(address) {
+            Entry::Occupied(_) => false,
+            Entry::Vacant(e) => {
+                e.insert(AddressStatus::default());
+
+                true
+            }
+        }
+    }
+
+    /// Remove address from the list
+    /// Returns [AddressStatus] if the address was in the list.
+    pub fn remove(&mut self, address: &Address) -> Option<AddressStatus> {
+        let mut guard = self.addresses.write().unwrap();
+
+        guard.remove(address)
     }
 
     // TODO: this is the most simple way to add an address
@@ -175,41 +201,53 @@ impl AddressList {
     /// Add a node [Address] to [AddressList] by [Uri].
     /// Returns false if the address is already in the list.
     pub fn add_uri(&mut self, uri: Uri) -> bool {
-        self.addresses.insert(uri.into())
+        self.add(Address::from(uri))
     }
 
     /// Randomly select a not banned address.
-    pub fn get_live_address(&self) -> Option<RefMulti<Address>> {
+    pub fn get_live_address(&self) -> Option<Address> {
+        let mut guard = self.addresses.read().unwrap();
+
         let mut rng = SmallRng::from_entropy();
 
         let now = chrono::Utc::now();
 
-        self.addresses
+        guard
             .iter()
-            .filter(|addr| {
-                addr.banned_until
+            .filter(|(addr, status)| {
+                status
+                    .banned_until
                     .map(|banned_until| banned_until < now)
                     .unwrap_or(true)
             })
             .choose(&mut rng)
+            .map(|(addr, _)| addr.clone())
     }
 
     /// Get number of all addresses, both banned and not banned.
     pub fn len(&self) -> usize {
-        self.addresses.len()
+        self.addresses.read().unwrap().len()
     }
 
     /// Check if the list is empty.
     /// Returns true if there are no addresses in the list.
     /// Returns false if there is at least one address in the list.
     /// Banned addresses are also counted.
     pub fn is_empty(&self) -> bool {
-        self.addresses.is_empty()
+        self.addresses.read().unwrap().is_empty()
     }
+}
+
+impl IntoIterator for AddressList {
+    type Item = (Address, AddressStatus);
+    type IntoIter = std::collections::hash_map::IntoIter<Address, AddressStatus>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        let mut guard = self.addresses.write().unwrap();
+
+        let addresses_map = mem::take(&mut *guard);
 
-    /// Get an iterator over all addresses.
-    pub fn iter(&self) -> impl Iterator<Item = RefMulti<Address>> {
-        self.addresses.iter()
+        addresses_map.into_iter()
     }
 }