feat: better logging, and allow ban manager to come from config. Rele…

…ase v5.7.4

server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "stratum-server"
-version = "5.7.3"
+version = "5.7.4"
 authors = ["Sean Kilgarriff [email protected]"]
 rust-version = "1.67.1"
 edition = "2021"

server/src/builder.rs

@@ -1,5 +1,5 @@
 use crate::{
-    config::{ConnectionConfig, DifficultyConfig},
+    config::{BanManagerConfig, ConnectionConfig, DifficultyConfig},
     id_manager::IDManager,
     router::Router,
     types::ReadyIndicator,
@@ -27,6 +27,7 @@ pub struct StratumServerBuilder<State, CState> {
     pub ready_indicator: ReadyIndicator,
     pub shutdown_message: Option<Buffer>,
     pub cancel_token: Option<CancellationToken>,
+    pub ban_manager_enabled: bool,
 }
 
 impl<State: Clone + Send + Sync + 'static, CState: Default + Clone + Send + Sync + 'static>
@@ -62,6 +63,7 @@ impl<State: Clone + Send + Sync + 'static, CState: Default + Clone + Send + Sync
             // },
             shutdown_message: None,
             cancel_token: None,
+            ban_manager_enabled: false,
         }
     }
 
@@ -163,16 +165,28 @@ impl<State: Clone + Send + Sync + 'static, CState: Default + Clone + Send + Sync
         self
     }
 
+    #[must_use]
+    pub fn with_ban_manager(mut self, enabled: bool) -> Self {
+        self.ban_manager_enabled = enabled;
+        self
+    }
+
     pub async fn build(self) -> Result<StratumServer<State, CState>> {
+        let ban_manager_config = BanManagerConfig {
+            enabled: self.ban_manager_enabled,
+            ..Default::default()
+        };
+
         let config = Config {
             connection: self.connection_config,
             difficulty: self.var_diff_config,
-            bans: crate::config::BanManagerConfig::default(),
+            bans: ban_manager_config,
         };
 
         let config_manager = ConfigManager::new(config);
 
         let listener = TcpListener::bind(format!("{}:{}", self.host, self.port)).await?;
+
         //This will fail if unable to find a local port.
         let listen_address = listener.local_addr()?;
         let listener = TcpListenerStream::new(listener);

server/src/config.rs

@@ -31,6 +31,10 @@ impl ConfigManager {
     pub(crate) fn difficulty_config(&self) -> &DifficultyConfig {
         &self.config.difficulty
     }
+
+    pub(crate) fn ban_manager_enabled(&self) -> bool {
+        self.config.bans.enabled
+    }
 }
 
 #[derive(Clone, Debug, Default)]
@@ -42,6 +46,7 @@ pub struct Config {
 
 #[derive(Clone, Debug)]
 pub struct BanManagerConfig {
+    pub(crate) enabled: bool,
     pub(crate) default_ban_duration: Duration,
     pub(crate) _ban_score_allowed: u64,
     pub(crate) _whitelisted_ips: Vec<IpAddr>,
@@ -51,6 +56,7 @@ pub struct BanManagerConfig {
 impl Default for BanManagerConfig {
     fn default() -> Self {
         BanManagerConfig {
+            enabled: false,
             default_ban_duration: Duration::from_secs(3600),
             _ban_score_allowed: 100,
             _whitelisted_ips: Vec::new(),

server/src/router.rs

@@ -49,6 +49,7 @@ impl<State: Clone + Send + Sync + 'static, CState: Clone + Send + Sync + 'static
         // );
         // } else {
         tracing::debug!(
+            ip = connection.ip().to_string(),
             "Calling method: {} for connection: {}",
             value.method(),
             connection.id()

server/src/session.rs

@@ -7,6 +7,7 @@ use extended_primitives::Buffer;
 use parking_lot::{Mutex, RwLock};
 use serde::Serialize;
 use std::{
+    net::SocketAddr,
     sync::Arc,
     time::{Duration, Instant, SystemTime},
 };
@@ -78,9 +79,11 @@ pub struct Session<State> {
     difficulty_settings: Arc<RwLock<DifficultySettings>>,
 }
 
+//@todo I want to get IP here and return it
 struct Inner<State> {
     pub id: ConnectionID,
     pub session_id: SessionID,
+    pub ip: SocketAddr,
     pub state: State,
 }
 
@@ -100,6 +103,7 @@ impl<State: Clone> Session<State> {
     pub fn new(
         id: ConnectionID,
         session_id: SessionID,
+        ip: SocketAddr,
         sender: UnboundedSender<SendInformation>,
         config_manager: ConfigManager,
         cancel_token: CancellationToken,
@@ -118,6 +122,7 @@ impl<State: Clone> Session<State> {
         let inner = Inner {
             id,
             session_id,
+            ip,
             state,
         };
 
@@ -376,6 +381,11 @@ impl<State: Clone> Session<State> {
         self.shared.lock().last_active = Instant::now();
     }
 
+    #[must_use]
+    pub fn ip(&self) -> SocketAddr {
+        self.inner.ip
+    }
+
     //@todo Use internal URLs if they exist otherwise use the default URL?
     //Figure out how to do this gracefully.
     // pub(crate) fn graceful_shutdown(&self) {

server/src/tcp.rs

@@ -44,9 +44,9 @@ impl<State: Clone + Send + Sync + 'static, CState: Default + Clone + Send + Sync
             self.connection.address
         };
 
-        //@todo this seems dangerous on Global Accelerator As they all use the same address ->
-        //Let's think about if we use this by default or not.
-        // self.ban_manager.check_banned(address)?;
+        if self.config_manager.ban_manager_enabled() {
+            self.ban_manager.check_banned(address)?;
+        }
 
         let (mut reader, tx, handle) = self.connection.init();
 
@@ -57,6 +57,7 @@ impl<State: Clone + Send + Sync + 'static, CState: Default + Clone + Send + Sync
         let session = Session::new(
             self.id.clone(),
             session_id,
+            address,
             tx,
             self.config_manager.clone(),
             session_cancel_token.clone(),