patch.diff

From ed15584e0ae07d157d1c0f79adc9b140c7bc5826 Mon Sep 17 00:00:00 2001
From: Power2All <info@power2all.com>
Date: Fri, 8 May 2026 11:54:21 +0200
Subject: [PATCH] First big fix and improvements

---
 src/api/api.rs                                |  10 +-
 src/common/common.rs                          |  67 +++---
 src/config/impls/configuration.rs             | 200 +++++++++++-------
 .../impls/database_connector_mysql.rs         |  33 +--
 .../impls/database_connector_pgsql.rs         |  21 +-
 .../impls/database_connector_sqlite.rs        |  21 +-
 src/http/http.rs                              |  41 ++--
 src/main.rs                                   |  20 +-
 src/stats/impls/torrent_tracker.rs            |   2 +-
 src/structs.rs                                |  30 +--
 src/tracker/impls/info_hash.rs                |  10 +-
 src/tracker/impls/peer_id.rs                  |  20 +-
 src/tracker/impls/torrent_tracker_handlers.rs |  19 +-
 src/tracker/impls/torrent_tracker_torrents.rs |   8 +
 src/tracker/impls/user_id.rs                  |   9 +-
 src/tracker/structs.rs                        |   3 +-
 src/tracker/structs/scrape_query_request.rs   |   1 -
 src/tracker/structs/torrent_counts.rs         |  37 ++++
 src/udp/impls/parse_pool.rs                   |   2 -
 src/udp/impls/udp_server.rs                   |  12 +-
 src/websocket/websocket.rs                    |  15 +-
 tests/udp_tests.rs                            |   6 +-
 22 files changed, 335 insertions(+), 252 deletions(-)
 create mode 100644 src/tracker/structs/torrent_counts.rs

diff --git a/src/api/api.rs b/src/api/api.rs
index cefdeb4..72c174b 100644
--- a/src/api/api.rs
+++ b/src/api/api.rs
@@ -254,7 +254,10 @@ pub async fn api_service(
             .client_disconnect_timeout(Duration::from_secs(disconnect_timeout))
             .workers(worker_threads)
             .bind_rustls_0_23((addr.ip(), addr.port()), tls_config)
-            .unwrap()
+            .unwrap_or_else(|e| {
+                error!("[APIS] Unable to bind to {addr}: {e}");
+                exit(1);
+            })
             .disable_signals()
             .run();
         return (server.handle(), server);
@@ -266,7 +269,10 @@ pub async fn api_service(
         .client_disconnect_timeout(Duration::from_secs(disconnect_timeout))
         .workers(worker_threads)
         .bind((addr.ip(), addr.port()))
-        .unwrap()
+        .unwrap_or_else(|e| {
+            error!("[API] Unable to bind to {addr}: {e}");
+            exit(1);
+        })
         .disable_signals()
         .run();
     (server.handle(), server)
diff --git a/src/common/common.rs b/src/common/common.rs
index d584b28..97c2bc5 100644
--- a/src/common/common.rs
+++ b/src/common/common.rs
@@ -74,11 +74,15 @@ pub fn parse_query(query: Option<String>) -> Result<HashMap<String, QueryValues>
     Ok(queries)
 }
 
-pub fn udp_check_host_and_port_used(bind_address: String) {
-    if cfg!(target_os = "windows") && let Err(data) = std::net::UdpSocket::bind(&bind_address) {
-        sentry::capture_error(&data);
-        panic!("Unable to bind to {} ! Exiting...", &bind_address);
+pub fn udp_check_host_and_port_used(bind_address: &str) -> std::io::Result<()> {
+    if cfg!(target_os = "windows")
+        && let Err(e) = std::net::UdpSocket::bind(bind_address)
+    {
+        sentry::capture_error(&e);
+        log::error!("Unable to bind UDP socket to {bind_address}: {e}");
+        return Err(e);
     }
+    Ok(())
 }
 
 pub(crate) fn bin2hex(data: &[u8; 20], f: &mut Formatter) -> fmt::Result {
@@ -87,6 +91,34 @@ pub(crate) fn bin2hex(data: &[u8; 20], f: &mut Formatter) -> fmt::Result {
     write!(f, "{}", std::str::from_utf8(&chars).unwrap())
 }
 
+/// Stack-allocated hex buffer for serialising 20-byte ids (info_hash,
+/// peer_id, user_id).  Use [`Hex20::as_str`] to borrow the contents as
+/// `&str`.  The single `unsafe` block is contained here, in one place,
+/// rather than repeated at each `Serialize` impl.
+pub struct Hex20(pub [u8; 40]);
+
+impl Hex20 {
+    #[inline]
+    pub fn as_str(&self) -> &str {
+        // SAFETY: `bin20_to_hex` only writes ASCII hex digits ('0'-'9',
+        // 'a'-'f') from the constant table below, so the buffer is always
+        // valid UTF-8.
+        unsafe { std::str::from_utf8_unchecked(&self.0) }
+    }
+}
+
+#[inline]
+pub fn bin20_to_hex(data: &[u8; 20]) -> Hex20 {
+    const HEX_CHARS: &[u8; 16] = b"0123456789abcdef";
+    let mut buffer = [0u8; 40];
+    for (i, &byte) in data.iter().enumerate() {
+        let idx = i * 2;
+        buffer[idx] = HEX_CHARS[(byte >> 4) as usize];
+        buffer[idx + 1] = HEX_CHARS[(byte & 0xf) as usize];
+    }
+    Hex20(buffer)
+}
+
 pub fn hex2bin(data: String) -> Result<[u8; 20], CustomError> {
     hex::decode(data)
         .map_err(|data| {
@@ -101,23 +133,6 @@ pub fn hex2bin(data: String) -> Result<[u8; 20], CustomError> {
         })
 }
 
-pub fn print_type<T>(_: &T) {
-    println!("{:?}", std::any::type_name::<T>());
-}
-
-pub fn return_type<T>(_: &T) -> String {
-    format!("{:?}", std::any::type_name::<T>())
-}
-
-pub fn equal_string_check(source: &str, check: &str) -> bool {
-    if source == check {
-        return true;
-    }
-    println!("Source: {source}");
-    println!("Check:  {check}");
-    false
-}
-
 pub fn setup_logging(config: &Configuration) {
     let level = match config.log_level.as_str() {
         "off" => log::LevelFilter::Off,
@@ -199,16 +214,6 @@ pub fn hex_to_nibble(c: u8) -> u8 {
     }
 }
 
-#[inline(always)]
-pub fn hex_char_to_nibble(c: u8) -> u8 {
-    match c {
-        b'0'..=b'9' => c - b'0',
-        b'a'..=b'f' => c - b'a' + 10,
-        b'A'..=b'F' => c - b'A' + 10,
-        _ => 0xFF,
-    }
-}
-
 pub fn init_compression(enabled: bool, algorithm: CompressionAlgorithm, level: u32) {
     let _ = COMPRESSION.set(CompressionState { enabled, algorithm, level });
 }
\ No newline at end of file
diff --git a/src/config/impls/configuration.rs b/src/config/impls/configuration.rs
index b8a69b5..da23d85 100644
--- a/src/config/impls/configuration.rs
+++ b/src/config/impls/configuration.rs
@@ -186,45 +186,44 @@ impl Configuration {
             ),
         }
     }
-
     pub fn env_overrides(config: &mut Configuration) -> &mut Configuration {
         if let Ok(value) = env::var("LOG_LEVEL") { config.log_level = value; }
-        if let Ok(value) = env::var("LOG_CONSOLE_INTERVAL") { config.log_console_interval = value.parse::<u64>().unwrap_or(60u64); }
+        if let Ok(value) = env::var("LOG_CONSOLE_INTERVAL") { config.log_console_interval = parse_env_num::<u64>("LOG_CONSOLE_INTERVAL", &value, 60); }
         if let Ok(value) = env::var("TRACKER__API_KEY") {
             config.tracker_config.api_key = value;
         }
         if let Ok(value) = env::var("TRACKER__WHITELIST_ENABLED") {
-            config.tracker_config.whitelist_enabled = match value.as_str() { "true" => { true } "false" => { false } _ => { false } };
+            config.tracker_config.whitelist_enabled = parse_env_bool("TRACKER__WHITELIST_ENABLED", &value, false);
         }
         if let Ok(value) = env::var("TRACKER__BLACKLIST_ENABLED") {
-            config.tracker_config.blacklist_enabled = match value.as_str() { "true" => { true } "false" => { false } _ => { false } };
+            config.tracker_config.blacklist_enabled = parse_env_bool("TRACKER__BLACKLIST_ENABLED", &value, false);
         }
         if let Ok(value) = env::var("TRACKER__KEYS_ENABLED") {
-            config.tracker_config.keys_enabled = match value.as_str() { "true" => { true } "false" => { false } _ => { false } };
+            config.tracker_config.keys_enabled = parse_env_bool("TRACKER__KEYS_ENABLED", &value, false);
         }
         if let Ok(value) = env::var("TRACKER__USERS_ENABLED") {
-            config.tracker_config.users_enabled = match value.as_str() { "true" => { true } "false" => { false } _ => { false } };
+            config.tracker_config.users_enabled = parse_env_bool("TRACKER__USERS_ENABLED", &value, false);
         }
         if let Ok(value) = env::var("TRACKER__SWAGGER") {
-            config.tracker_config.swagger = match value.as_str() { "true" => { true } "false" => { false } _ => { false } };
+            config.tracker_config.swagger = parse_env_bool("TRACKER__SWAGGER", &value, false);
         }
         if let Ok(value) = env::var("TRACKER__KEYS_CLEANUP_INTERVAL") {
-            config.tracker_config.keys_cleanup_interval = value.parse::<u64>().unwrap_or(60u64);
+            config.tracker_config.keys_cleanup_interval = parse_env_num::<u64>("TRACKER__KEYS_CLEANUP_INTERVAL", &value, 60);
         }
         if let Ok(value) = env::var("TRACKER__REQUEST_INTERVAL") {
-            config.tracker_config.request_interval = value.parse::<u64>().unwrap_or(1800u64);
+            config.tracker_config.request_interval = parse_env_num::<u64>("TRACKER__REQUEST_INTERVAL", &value, 1800);
         }
         if let Ok(value) = env::var("TRACKER__REQUEST_INTERVAL_MINIMUM") {
-            config.tracker_config.request_interval_minimum = value.parse::<u64>().unwrap_or(1800u64);
+            config.tracker_config.request_interval_minimum = parse_env_num::<u64>("TRACKER__REQUEST_INTERVAL_MINIMUM", &value, 1800);
         }
         if let Ok(value) = env::var("TRACKER__PEERS_TIMEOUT") {
-            config.tracker_config.peers_timeout = value.parse::<u64>().unwrap_or(2700u64);
+            config.tracker_config.peers_timeout = parse_env_num::<u64>("TRACKER__PEERS_TIMEOUT", &value, 2700);
         }
         if let Ok(value) = env::var("TRACKER__PEERS_CLEANUP_INTERVAL") {
-            config.tracker_config.peers_cleanup_interval = value.parse::<u64>().unwrap_or(900u64);
+            config.tracker_config.peers_cleanup_interval = parse_env_num::<u64>("TRACKER__PEERS_CLEANUP_INTERVAL", &value, 900);
         }
         if let Ok(value) = env::var("TRACKER__PEERS_CLEANUP_THREADS") {
-            config.tracker_config.peers_cleanup_threads = value.parse::<u64>().unwrap_or(256u64);
+            config.tracker_config.peers_cleanup_threads = parse_env_num::<u64>("TRACKER__PEERS_CLEANUP_THREADS", &value, 256);
         }
         if let Ok(value) = env::var("TRACKER__PROMETHEUS_ID") {
             config.tracker_config.prometheus_id = value;
@@ -255,25 +254,25 @@ impl Configuration {
             config.tracker_config.cluster_master_address = value;
         }
         if let Ok(value) = env::var("TRACKER__CLUSTER_KEEP_ALIVE") {
-            config.tracker_config.cluster_keep_alive = value.parse::<u64>().unwrap_or(60u64);
+            config.tracker_config.cluster_keep_alive = parse_env_num::<u64>("TRACKER__CLUSTER_KEEP_ALIVE", &value, 60);
         }
         if let Ok(value) = env::var("TRACKER__CLUSTER_REQUEST_TIMEOUT") {
-            config.tracker_config.cluster_request_timeout = value.parse::<u64>().unwrap_or(15u64);
+            config.tracker_config.cluster_request_timeout = parse_env_num::<u64>("TRACKER__CLUSTER_REQUEST_TIMEOUT", &value, 15);
         }
         if let Ok(value) = env::var("TRACKER__CLUSTER_DISCONNECT_TIMEOUT") {
-            config.tracker_config.cluster_disconnect_timeout = value.parse::<u64>().unwrap_or(15u64);
+            config.tracker_config.cluster_disconnect_timeout = parse_env_num::<u64>("TRACKER__CLUSTER_DISCONNECT_TIMEOUT", &value, 15);
         }
         if let Ok(value) = env::var("TRACKER__CLUSTER_RECONNECT_INTERVAL") {
-            config.tracker_config.cluster_reconnect_interval = value.parse::<u64>().unwrap_or(5u64);
+            config.tracker_config.cluster_reconnect_interval = parse_env_num::<u64>("TRACKER__CLUSTER_RECONNECT_INTERVAL", &value, 5);
         }
         if let Ok(value) = env::var("TRACKER__CLUSTER_MAX_CONNECTIONS") {
-            config.tracker_config.cluster_max_connections = value.parse::<u64>().unwrap_or(25000u64);
+            config.tracker_config.cluster_max_connections = parse_env_num::<u64>("TRACKER__CLUSTER_MAX_CONNECTIONS", &value, 25000);
         }
         if let Ok(value) = env::var("TRACKER__CLUSTER_THREADS") {
-            config.tracker_config.cluster_threads = value.parse::<u64>().unwrap_or(available_parallelism().unwrap().get() as u64);
+            config.tracker_config.cluster_threads = parse_env_num::<u64>("TRACKER__CLUSTER_THREADS", &value, available_parallelism().unwrap().get() as u64);
         }
         if let Ok(value) = env::var("TRACKER__CLUSTER_SSL") {
-            config.tracker_config.cluster_ssl = match value.as_str() { "true" => true, "false" => false, _ => false };
+            config.tracker_config.cluster_ssl = parse_env_bool("TRACKER__CLUSTER_SSL", &value, false);
         }
         if let Ok(value) = env::var("TRACKER__CLUSTER_SSL_KEY") {
             config.tracker_config.cluster_ssl_key = value;
@@ -282,19 +281,19 @@ impl Configuration {
             config.tracker_config.cluster_ssl_cert = value;
         }
         if let Ok(value) = env::var("TRACKER__CLUSTER_TLS_CONNECTION_RATE") {
-            config.tracker_config.cluster_tls_connection_rate = value.parse::<u64>().unwrap_or(256u64);
+            config.tracker_config.cluster_tls_connection_rate = parse_env_num::<u64>("TRACKER__CLUSTER_TLS_CONNECTION_RATE", &value, 256);
         }
         if let Ok(value) = env::var("TRACKER__RTC_INTERVAL") {
-            config.tracker_config.rtc_interval = value.parse::<u64>().unwrap_or(10u64);
+            config.tracker_config.rtc_interval = parse_env_num::<u64>("TRACKER__RTC_INTERVAL", &value, 10);
         }
         if let Ok(value) = env::var("TRACKER__RTC_PEERS_TIMEOUT") {
-            config.tracker_config.rtc_peers_timeout = value.parse::<u64>().unwrap_or(120u64);
+            config.tracker_config.rtc_peers_timeout = parse_env_num::<u64>("TRACKER__RTC_PEERS_TIMEOUT", &value, 120);
         }
         if let Ok(value) = env::var("TRACKER__TOTAL_DOWNLOADS") {
-            config.tracker_config.total_downloads = value.parse::<u64>().unwrap_or(0u64);
+            config.tracker_config.total_downloads = parse_env_num::<u64>("TRACKER__TOTAL_DOWNLOADS", &value, 0);
         }
         if let Ok(value) = env::var("TRACKER__RTC_COMPRESSION_ENABLED") {
-            config.tracker_config.rtc_compression_enabled = match value.as_str() { "true" => true, "false" => false, _ => true };
+            config.tracker_config.rtc_compression_enabled = parse_env_bool("TRACKER__RTC_COMPRESSION_ENABLED", &value, true);
         }
         if let Ok(value) = env::var("TRACKER__RTC_COMPRESSION_ALGORITHM") {
             config.tracker_config.rtc_compression_algorithm = match value.to_lowercase().as_str() {
@@ -303,46 +302,46 @@ impl Configuration {
             };
         }
         if let Ok(value) = env::var("TRACKER__RTC_COMPRESSION_LEVEL") {
-            config.tracker_config.rtc_compression_level = value.parse::<u32>().unwrap_or(1u32);
+            config.tracker_config.rtc_compression_level = parse_env_num::<u32>("TRACKER__RTC_COMPRESSION_LEVEL", &value, 1);
         }
         if let Ok(value) = env::var("SENTRY__ENABLED") {
-            config.sentry_config.enabled = match value.as_str() { "true" => { true } "false" => { false } _ => { false } };
+            config.sentry_config.enabled = parse_env_bool("SENTRY__ENABLED", &value, false);
         }
         if let Ok(value) = env::var("SENTRY__DEBUG") {
-            config.sentry_config.debug = match value.as_str() { "true" => { true } "false" => { false } _ => { false } };
+            config.sentry_config.debug = parse_env_bool("SENTRY__DEBUG", &value, false);
         }
         if let Ok(value) = env::var("SENTRY__ATTACH_STACKTRACE") {
-            config.sentry_config.attach_stacktrace = match value.as_str() { "true" => { true } "false" => { false } _ => { true } };
+            config.sentry_config.attach_stacktrace = parse_env_bool("SENTRY__ATTACH_STACKTRACE", &value, true);
         }
         if let Ok(value) = env::var("SENTRY__SEND_DEFAULT_PII") {
-            config.sentry_config.send_default_pii = match value.as_str() { "true" => { true } "false" => { false } _ => { false } };
+            config.sentry_config.send_default_pii = parse_env_bool("SENTRY__SEND_DEFAULT_PII", &value, false);
         }
         if let Ok(value) = env::var("SENTRY__DSN") {
             config.sentry_config.dsn = value;
         }
         if let Ok(value) = env::var("SENTRY__MAX_BREADCRUMBS") {
-            config.sentry_config.max_breadcrumbs = value.parse::<usize>().unwrap_or(100);
+            config.sentry_config.max_breadcrumbs = parse_env_num::<usize>("SENTRY__MAX_BREADCRUMBS", &value, 100);
         }
         if let Ok(value) = env::var("SENTRY__SAMPLE_RATE") {
-            config.sentry_config.sample_rate = value.parse::<f32>().unwrap_or(1.0);
+            config.sentry_config.sample_rate = parse_env_num::<f32>("SENTRY__SAMPLE_RATE", &value, 1.0);
         }
         if let Ok(value) = env::var("SENTRY__TRACES_SAMPLE_RATE") {
-            config.sentry_config.traces_sample_rate = value.parse::<f32>().unwrap_or(1.0);
+            config.sentry_config.traces_sample_rate = parse_env_num::<f32>("SENTRY__TRACES_SAMPLE_RATE", &value, 1.0);
         }
         if let Ok(value) = env::var("DATABASE__PERSISTENT") {
-            config.database.persistent = match value.as_str() { "true" => { true } "false" => { false } _ => { false } };
+            config.database.persistent = parse_env_bool("DATABASE__PERSISTENT", &value, false);
         }
         if let Ok(value) = env::var("DATABASE__INSERT_VACANT") {
-            config.database.insert_vacant = match value.as_str() { "true" => { true } "false" => { false } _ => { false } };
+            config.database.insert_vacant = parse_env_bool("DATABASE__INSERT_VACANT", &value, false);
         }
         if let Ok(value) = env::var("DATABASE__REMOVE_ACTION") {
-            config.database.remove_action = match value.as_str() { "true" => { true } "false" => { false } _ => { false } };
+            config.database.remove_action = parse_env_bool("DATABASE__REMOVE_ACTION", &value, false);
         }
         if let Ok(value) = env::var("DATABASE__UPDATE_COMPLETED") {
-            config.database.update_completed = match value.as_str() { "true" => { true } "false" => { false } _ => { true } };
+            config.database.update_completed = parse_env_bool("DATABASE__UPDATE_COMPLETED", &value, true);
         }
         if let Ok(value) = env::var("DATABASE__UPDATE_PEERS") {
-            config.database.update_peers = match value.as_str() { "true" => { true } "false" => { false } _ => { false } };
+            config.database.update_peers = parse_env_bool("DATABASE__UPDATE_PEERS", &value, false);
         }
         if let Ok(value) = env::var("DATABASE__PATH") {
             config.database.path = value;
@@ -356,10 +355,10 @@ impl Configuration {
             };
         }
         if let Ok(value) = env::var("DATABASE__PERSISTENT_INTERVAL") {
-            config.database.persistent_interval = value.parse::<u64>().unwrap_or(60u64);
+            config.database.persistent_interval = parse_env_num::<u64>("DATABASE__PERSISTENT_INTERVAL", &value, 60);
         }
         if let Ok(value) = env::var("CACHE__ENABLED") {
-            let enabled = match value.as_str() { "true" => true, "false" => false, _ => false };
+            let enabled = parse_env_bool("CACHE__ENABLED", &value, false);
             if let Some(ref mut cache) = config.cache {
                 cache.enabled = enabled;
             } else if enabled {
@@ -403,7 +402,7 @@ impl Configuration {
             }
         }
         if let Ok(value) = env::var("CACHE__TTL") {
-            let ttl = value.parse::<u64>().unwrap_or(300u64);
+            let ttl = parse_env_num::<u64>("CACHE__TTL", &value, 300);
             if let Some(ref mut cache) = config.cache {
                 cache.ttl = ttl;
             } else {
@@ -414,7 +413,7 @@ impl Configuration {
             }
         }
         if let Ok(value) = env::var("CACHE__SPLIT_PEERS") {
-            let split_peers = matches!(value.as_str(), "true");
+            let split_peers = parse_env_bool("CACHE__SPLIT_PEERS", &value, false);
             if let Some(ref mut cache) = config.cache {
                 cache.split_peers = split_peers;
             } else {
@@ -425,7 +424,7 @@ impl Configuration {
             }
         }
         if let Ok(value) = env::var("DATABASE_STRUCTURE__TORRENTS__BIN_TYPE_INFOHASH") {
-            config.database_structure.torrents.bin_type_infohash = match value.as_str() { "true" => { true } "false" => { false } _ => { true } };
+            config.database_structure.torrents.bin_type_infohash = parse_env_bool("DATABASE_STRUCTURE__TORRENTS__BIN_TYPE_INFOHASH", &value, true);
         }
         if let Ok(value) = env::var("DATABASE_STRUCTURE__TORRENTS__TABLE_NAME") {
             config.database_structure.torrents.table_name = value;
@@ -443,10 +442,10 @@ impl Configuration {
             config.database_structure.torrents.column_completed = value;
         }
         if let Ok(value) = env::var("DATABASE_STRUCTURE__TORRENTS__PERSISTENT") {
-            config.database_structure.torrents.persistent = match value.as_str() { "true" => Some(true), "false" => Some(false), _ => None };
+            config.database_structure.torrents.persistent = parse_env_optional_bool("DATABASE_STRUCTURE__TORRENTS__PERSISTENT", &value);
         }
         if let Ok(value) = env::var("DATABASE_STRUCTURE__WHITELIST__BIN_TYPE_INFOHASH") {
-            config.database_structure.whitelist.bin_type_infohash = match value.as_str() { "true" => { true } "false" => { false } _ => { true } };
+            config.database_structure.whitelist.bin_type_infohash = parse_env_bool("DATABASE_STRUCTURE__WHITELIST__BIN_TYPE_INFOHASH", &value, true);
         }
         if let Ok(value) = env::var("DATABASE_STRUCTURE__WHITELIST__TABLE_NAME") {
             config.database_structure.whitelist.table_name = value;
@@ -455,10 +454,10 @@ impl Configuration {
             config.database_structure.whitelist.column_infohash = value;
         }
         if let Ok(value) = env::var("DATABASE_STRUCTURE__WHITELIST__PERSISTENT") {
-            config.database_structure.whitelist.persistent = match value.as_str() { "true" => Some(true), "false" => Some(false), _ => None };
+            config.database_structure.whitelist.persistent = parse_env_optional_bool("DATABASE_STRUCTURE__WHITELIST__PERSISTENT", &value);
         }
         if let Ok(value) = env::var("DATABASE_STRUCTURE__BLACKLIST__BIN_TYPE_INFOHASH") {
-            config.database_structure.blacklist.bin_type_infohash = match value.as_str() { "true" => { true } "false" => { false } _ => { true } };
+            config.database_structure.blacklist.bin_type_infohash = parse_env_bool("DATABASE_STRUCTURE__BLACKLIST__BIN_TYPE_INFOHASH", &value, true);
         }
         if let Ok(value) = env::var("DATABASE_STRUCTURE__BLACKLIST__TABLE_NAME") {
             config.database_structure.blacklist.table_name = value;
@@ -467,10 +466,10 @@ impl Configuration {
             config.database_structure.blacklist.column_infohash = value;
         }
         if let Ok(value) = env::var("DATABASE_STRUCTURE__BLACKLIST__PERSISTENT") {
-            config.database_structure.blacklist.persistent = match value.as_str() { "true" => Some(true), "false" => Some(false), _ => None };
+            config.database_structure.blacklist.persistent = parse_env_optional_bool("DATABASE_STRUCTURE__BLACKLIST__PERSISTENT", &value);
         }
         if let Ok(value) = env::var("DATABASE_STRUCTURE__KEYS__BIN_TYPE_HASH") {
-            config.database_structure.keys.bin_type_hash = match value.as_str() { "true" => { true } "false" => { false } _ => { true } };
+            config.database_structure.keys.bin_type_hash = parse_env_bool("DATABASE_STRUCTURE__KEYS__BIN_TYPE_HASH", &value, true);
         }
         if let Ok(value) = env::var("DATABASE_STRUCTURE__KEYS__TABLE_NAME") {
             config.database_structure.keys.table_name = value;
@@ -482,13 +481,13 @@ impl Configuration {
             config.database_structure.keys.column_timeout = value;
         }
         if let Ok(value) = env::var("DATABASE_STRUCTURE__KEYS__PERSISTENT") {
-            config.database_structure.keys.persistent = match value.as_str() { "true" => Some(true), "false" => Some(false), _ => None };
+            config.database_structure.keys.persistent = parse_env_optional_bool("DATABASE_STRUCTURE__KEYS__PERSISTENT", &value);
         }
         if let Ok(value) = env::var("DATABASE_STRUCTURE__USERS__ID_UUID") {
-            config.database_structure.users.id_uuid = match value.as_str() { "true" => { true } "false" => { false } _ => { true } };
+            config.database_structure.users.id_uuid = parse_env_bool("DATABASE_STRUCTURE__USERS__ID_UUID", &value, true);
         }
         if let Ok(value) = env::var("DATABASE_STRUCTURE__USERS__BIN_TYPE_KEY") {
-            config.database_structure.users.bin_type_key = match value.as_str() { "true" => { true } "false" => { false } _ => { true } };
+            config.database_structure.users.bin_type_key = parse_env_bool("DATABASE_STRUCTURE__USERS__BIN_TYPE_KEY", &value, true);
         }
         if let Ok(value) = env::var("DATABASE_STRUCTURE__USERS__TABLE_NAME") {
             config.database_structure.users.table_name = value;
@@ -518,7 +517,7 @@ impl Configuration {
             config.database_structure.users.column_updated = value;
         }
         if let Ok(value) = env::var("DATABASE_STRUCTURE__USERS__PERSISTENT") {
-            config.database_structure.users.persistent = match value.as_str() { "true" => Some(true), "false" => Some(false), _ => None };
+            config.database_structure.users.persistent = parse_env_optional_bool("DATABASE_STRUCTURE__USERS__PERSISTENT", &value);
         }
         let mut api_iteration = 0;
         loop {
@@ -528,10 +527,10 @@ impl Configuration {
                 }
                 Some(block) => {
                     if let Ok(value) = env::var(format!("API_{api_iteration}_ENABLED")) {
-                        block.enabled = match value.as_str() { "true" => { true } "false" => { false } _ => { true } };
+                        block.enabled = parse_env_bool(format!("API_{api_iteration}_ENABLED"), &value, true);
                     }
                     if let Ok(value) = env::var(format!("API_{api_iteration}_SSL")) {
-                        block.ssl = match value.as_str() { "true" => { true } "false" => { false } _ => { false } };
+                        block.ssl = parse_env_bool(format!("API_{api_iteration}_SSL"), &value, false);
                     }
                     if let Ok(value) = env::var(format!("API_{api_iteration}_BIND_ADDRESS")) {
                         block.bind_address = value;
@@ -546,22 +545,22 @@ impl Configuration {
                         block.ssl_cert = value;
                     }
                     if let Ok(value) = env::var(format!("API_{api_iteration}_KEEP_ALIVE")) {
-                        block.keep_alive = value.parse::<u64>().unwrap_or(60);
+                        block.keep_alive = parse_env_num::<u64>(format!("API_{api_iteration}_KEEP_ALIVE"), &value, 60);
                     }
                     if let Ok(value) = env::var(format!("API_{api_iteration}_REQUEST_TIMEOUT")) {
-                        block.request_timeout = value.parse::<u64>().unwrap_or(30);
+                        block.request_timeout = parse_env_num::<u64>(format!("API_{api_iteration}_REQUEST_TIMEOUT"), &value, 30);
                     }
                     if let Ok(value) = env::var(format!("API_{api_iteration}_DISCONNECT_TIMEOUT")) {
-                        block.disconnect_timeout = value.parse::<u64>().unwrap_or(30);
+                        block.disconnect_timeout = parse_env_num::<u64>(format!("API_{api_iteration}_DISCONNECT_TIMEOUT"), &value, 30);
                     }
                     if let Ok(value) = env::var(format!("API_{api_iteration}_MAX_CONNECTIONS")) {
-                        block.max_connections = value.parse::<u64>().unwrap_or(25000);
+                        block.max_connections = parse_env_num::<u64>(format!("API_{api_iteration}_MAX_CONNECTIONS"), &value, 25000);
                     }
                     if let Ok(value) = env::var(format!("API_{api_iteration}_THREADS")) {
-                        block.threads = value.parse::<u64>().unwrap_or(available_parallelism().unwrap().get() as u64);
+                        block.threads = parse_env_num::<u64>(format!("API_{api_iteration}_THREADS"), &value, available_parallelism().unwrap().get() as u64);
                     }
                     if let Ok(value) = env::var(format!("API_{api_iteration}_TLS_CONNECTION_RATE")) {
-                        block.tls_connection_rate = value.parse::<u64>().unwrap_or(256);
+                        block.tls_connection_rate = parse_env_num::<u64>(format!("API_{api_iteration}_TLS_CONNECTION_RATE"), &value, 256);
                     }
                 }
             }
@@ -575,10 +574,10 @@ impl Configuration {
                 }
                 Some(block) => {
                     if let Ok(value) = env::var(format!("HTTP_{http_iteration}_ENABLED")) {
-                        block.enabled = match value.as_str() { "true" => { true } "false" => { false } _ => { true } };
+                        block.enabled = parse_env_bool(format!("HTTP_{http_iteration}_ENABLED"), &value, true);
                     }
                     if let Ok(value) = env::var(format!("HTTP_{http_iteration}_SSL")) {
-                        block.ssl = match value.as_str() { "true" => { true } "false" => { false } _ => { false } };
+                        block.ssl = parse_env_bool(format!("HTTP_{http_iteration}_SSL"), &value, false);
                     }
                     if let Ok(value) = env::var(format!("HTTP_{http_iteration}_BIND_ADDRESS")) {
                         block.bind_address = value;
@@ -593,25 +592,25 @@ impl Configuration {
                         block.ssl_cert = value;
                     }
                     if let Ok(value) = env::var(format!("HTTP_{http_iteration}_KEEP_ALIVE")) {
-                        block.keep_alive = value.parse::<u64>().unwrap_or(60);
+                        block.keep_alive = parse_env_num::<u64>(format!("HTTP_{http_iteration}_KEEP_ALIVE"), &value, 60);
                     }
                     if let Ok(value) = env::var(format!("HTTP_{http_iteration}_REQUEST_TIMEOUT")) {
-                        block.request_timeout = value.parse::<u64>().unwrap_or(30);
+                        block.request_timeout = parse_env_num::<u64>(format!("HTTP_{http_iteration}_REQUEST_TIMEOUT"), &value, 30);
                     }
                     if let Ok(value) = env::var(format!("HTTP_{http_iteration}_DISCONNECT_TIMEOUT")) {
-                        block.disconnect_timeout = value.parse::<u64>().unwrap_or(30);
+                        block.disconnect_timeout = parse_env_num::<u64>(format!("HTTP_{http_iteration}_DISCONNECT_TIMEOUT"), &value, 30);
                     }
                     if let Ok(value) = env::var(format!("HTTP_{http_iteration}_MAX_CONNECTIONS")) {
-                        block.max_connections = value.parse::<u64>().unwrap_or(25000);
+                        block.max_connections = parse_env_num::<u64>(format!("HTTP_{http_iteration}_MAX_CONNECTIONS"), &value, 25000);
                     }
                     if let Ok(value) = env::var(format!("HTTP_{http_iteration}_THREADS")) {
-                        block.threads = value.parse::<u64>().unwrap_or(available_parallelism().unwrap().get() as u64);
+                        block.threads = parse_env_num::<u64>(format!("HTTP_{http_iteration}_THREADS"), &value, available_parallelism().unwrap().get() as u64);
                     }
                     if let Ok(value) = env::var(format!("HTTP_{http_iteration}_TLS_CONNECTION_RATE")) {
-                        block.tls_connection_rate = value.parse::<u64>().unwrap_or(256);
+                        block.tls_connection_rate = parse_env_num::<u64>(format!("HTTP_{http_iteration}_TLS_CONNECTION_RATE"), &value, 256);
                     }
                     if let Ok(value) = env::var(format!("HTTP_{http_iteration}_RTCTORRENT")) {
-                        block.rtctorrent = match value.as_str() { "true" => true, "false" => false, _ => false };
+                        block.rtctorrent = parse_env_bool(format!("HTTP_{http_iteration}_RTCTORRENT"), &value, false);
                     }
                 }
             }
@@ -625,31 +624,31 @@ impl Configuration {
                 }
                 Some(block) => {
                     if let Ok(value) = env::var(format!("UDP_{udp_iteration}_ENABLED")) {
-                        block.enabled = match value.as_str() { "true" => { true } "false" => { false } _ => { true } };
+                        block.enabled = parse_env_bool(format!("UDP_{udp_iteration}_ENABLED"), &value, true);
                     }
                     if let Ok(value) = env::var(format!("UDP_{udp_iteration}_BIND_ADDRESS")) {
                         block.bind_address = value;
                     }
                     if let Ok(value) = env::var(format!("UDP_{udp_iteration}_UDP_THREADS")) {
-                        block.udp_threads = value.parse::<usize>().unwrap_or(2);
+                        block.udp_threads = parse_env_num::<usize>(format!("UDP_{udp_iteration}_UDP_THREADS"), &value, 2);
                     }
                     if let Ok(value) = env::var(format!("UDP_{udp_iteration}_WORKER_THREADS")) {
-                        block.worker_threads = value.parse::<usize>().unwrap_or(available_parallelism().unwrap().get());
+                        block.worker_threads = parse_env_num::<usize>(format!("UDP_{udp_iteration}_WORKER_THREADS"), &value, available_parallelism().unwrap().get());
                     }
                     if let Ok(value) = env::var(format!("UDP_{udp_iteration}_RECEIVE_BUFFER_SIZE")) {
-                        block.receive_buffer_size = value.parse::<usize>().unwrap_or(134_217_728);
+                        block.receive_buffer_size = parse_env_num::<usize>(format!("UDP_{udp_iteration}_RECEIVE_BUFFER_SIZE"), &value, 134_217_728);
                     }
                     if let Ok(value) = env::var(format!("UDP_{udp_iteration}_SEND_BUFFER_SIZE")) {
-                        block.send_buffer_size = value.parse::<usize>().unwrap_or(67_108_864);
+                        block.send_buffer_size = parse_env_num::<usize>(format!("UDP_{udp_iteration}_SEND_BUFFER_SIZE"), &value, 67_108_864);
                     }
                     if let Ok(value) = env::var(format!("UDP_{udp_iteration}_REUSE_ADDRESS")) {
-                        block.reuse_address = match value.as_str() { "true" => { true } "false" => { false } _ => { true } };
+                        block.reuse_address = parse_env_bool(format!("UDP_{udp_iteration}_REUSE_ADDRESS"), &value, true);
                     }
                     if let Ok(value) = env::var(format!("UDP_{udp_iteration}_USE_PAYLOAD_IP")) {
-                        block.use_payload_ip = match value.as_str() { "true" => true, "false" => false, _ => false };
+                        block.use_payload_ip = parse_env_bool(format!("UDP_{udp_iteration}_USE_PAYLOAD_IP"), &value, false);
                     }
                     if let Ok(value) = env::var(format!("UDP_{udp_iteration}_SIMPLE_PROXY_PROTOCOL")) {
-                        block.simple_proxy_protocol = match value.as_str() { "true" => true, "false" => false, _ => false };
+                        block.simple_proxy_protocol = parse_env_bool(format!("UDP_{udp_iteration}_SIMPLE_PROXY_PROTOCOL"), &value, false);
                     }
                 }
             }
@@ -900,7 +899,7 @@ impl Configuration {
             }
         }
     }
-    
+
     pub fn validate_socket_address(field_name: &str, address: &str) {
         use std::net::SocketAddr;
         match address.parse::<SocketAddr>() {
@@ -1031,4 +1030,45 @@ impl Configuration {
         }
         result
     }
-}
\ No newline at end of file
+}
+// --- env-var parse helpers ---------------------------------------------
+//
+// Wrap the `match value.as_str() { ... _ => default }` pattern with a
+// `log::warn!` so an operator who sets `FOO=yes` sees *why* their value
+// didn't take effect, instead of getting the default silently.  `name`
+// is the env-var name, used only in the warning.
+
+fn parse_env_bool(name: impl std::fmt::Display, value: &str, default: bool) -> bool {
+    match value.to_ascii_lowercase().as_str() {
+        "true" | "1" | "yes" | "on" => true,
+        "false" | "0" | "no" | "off" => false,
+        _ => {
+            log::warn!("[CONFIG] Invalid boolean for {name}={value:?}, using {default}");
+            default
+        }
+    }
+}
+
+fn parse_env_optional_bool(name: impl std::fmt::Display, value: &str) -> Option<bool> {
+    match value.to_ascii_lowercase().as_str() {
+        "true" | "1" | "yes" | "on" => Some(true),
+        "false" | "0" | "no" | "off" => Some(false),
+        _ => {
+            log::warn!("[CONFIG] Invalid boolean for {name}={value:?}, leaving unset");
+            None
+        }
+    }
+}
+
+fn parse_env_num<T>(name: impl std::fmt::Display, value: &str, default: T) -> T
+where
+    T: std::str::FromStr + std::fmt::Display + Copy,
+{
+    match value.parse::<T>() {
+        Ok(v) => v,
+        Err(_) => {
+            log::warn!("[CONFIG] Invalid numeric value for {name}={value:?}, using {default}");
+            default
+        }
+    }
+}
diff --git a/src/database/impls/database_connector_mysql.rs b/src/database/impls/database_connector_mysql.rs
index fe9c29a..8e1b4e5 100644
--- a/src/database/impls/database_connector_mysql.rs
+++ b/src/database/impls/database_connector_mysql.rs
@@ -74,11 +74,7 @@ impl DatabaseConnectorMySQL {
                 LOG_PREFIX,
                 config.database.clone().path
             );
-            error!(
-                "{} Message: {:#?}",
-                LOG_PREFIX,
-                mysql_connect.into_database_error().unwrap().message()
-            );
+            error!("{LOG_PREFIX} Message: {mysql_connect}");
             exit(1);
         }
         let mut structure = DatabaseConnector {
@@ -98,58 +94,63 @@ impl DatabaseConnectorMySQL {
             let hash_type = if ts.bin_type_infohash { "BINARY(20)" } else { "VARCHAR(40)" };
             info!("[BOOT MySQL] Creating table {}", ts.table_name);
             let query = format!(
-                "CREATE TABLE `{}` (`{}` {} NOT NULL, `{}` INT NOT NULL DEFAULT 0, `{}` INT NOT NULL DEFAULT 0, `{}` BIGINT UNSIGNED NOT NULL DEFAULT 0, PRIMARY KEY (`{}`)) COLLATE='utf8mb4_general_ci'",
+                "CREATE TABLE IF NOT EXISTS `{}` (`{}` {} NOT NULL, `{}` INT NOT NULL DEFAULT 0, `{}` INT NOT NULL DEFAULT 0, `{}` BIGINT UNSIGNED NOT NULL DEFAULT 0, PRIMARY KEY (`{}`)) COLLATE='utf8mb4_general_ci'",
                 ts.table_name, ts.column_infohash, hash_type, ts.column_seeds, ts.column_peers, ts.column_completed, ts.column_infohash
             );
             if let Err(e) = sqlx::query(&query).execute(pool).await {
-                panic!("{LOG_PREFIX} Error: {e}");
+                error!("{LOG_PREFIX} Failed to create table {}: {e}", ts.table_name);
+                exit(1);
             }
             let ws = &config.database_structure.whitelist;
             let hash_type = if ws.bin_type_infohash { "BINARY(20)" } else { "VARCHAR(40)" };
             info!("[BOOT MySQL] Creating table {}", ws.table_name);
             let query = format!(
-                "CREATE TABLE `{}` (`{}` {} NOT NULL, PRIMARY KEY (`{}`)) COLLATE='utf8mb4_general_ci'",
+                "CREATE TABLE IF NOT EXISTS `{}` (`{}` {} NOT NULL, PRIMARY KEY (`{}`)) COLLATE='utf8mb4_general_ci'",
                 ws.table_name, ws.column_infohash, hash_type, ws.column_infohash
             );
             if let Err(e) = sqlx::query(&query).execute(pool).await {
-                panic!("{LOG_PREFIX} Error: {e}");
+                error!("{LOG_PREFIX} Failed to create table {}: {e}", ws.table_name);
+                exit(1);
             }
             let bs = &config.database_structure.blacklist;
             let hash_type = if bs.bin_type_infohash { "BINARY(20)" } else { "VARCHAR(40)" };
             info!("[BOOT MySQL] Creating table {}", bs.table_name);
             let query = format!(
-                "CREATE TABLE `{}` (`{}` {} NOT NULL, PRIMARY KEY (`{}`)) COLLATE='utf8mb4_general_ci'",
+                "CREATE TABLE IF NOT EXISTS `{}` (`{}` {} NOT NULL, PRIMARY KEY (`{}`)) COLLATE='utf8mb4_general_ci'",
                 bs.table_name, bs.column_infohash, hash_type, bs.column_infohash
             );
             if let Err(e) = sqlx::query(&query).execute(pool).await {
-                panic!("{LOG_PREFIX} Error: {e}");
+                error!("{LOG_PREFIX} Failed to create table {}: {e}", bs.table_name);
+                exit(1);
             }
             let ks = &config.database_structure.keys;
             let hash_type = if ks.bin_type_hash { "BINARY(20)" } else { "VARCHAR(40)" };
             info!("[BOOT MySQL] Creating table {}", ks.table_name);
             let query = format!(
-                "CREATE TABLE `{}` (`{}` {} NOT NULL, `{}` INT NOT NULL DEFAULT 0, PRIMARY KEY (`{}`)) COLLATE='utf8mb4_general_ci'",
+                "CREATE TABLE IF NOT EXISTS `{}` (`{}` {} NOT NULL, `{}` INT NOT NULL DEFAULT 0, PRIMARY KEY (`{}`)) COLLATE='utf8mb4_general_ci'",
                 ks.table_name, ks.column_hash, hash_type, ks.column_timeout, ks.column_hash
             );
             if let Err(e) = sqlx::query(&query).execute(pool).await {
-                panic!("{LOG_PREFIX} Error: {e}");
+                error!("{LOG_PREFIX} Failed to create table {}: {e}", ks.table_name);
+                exit(1);
             }
             let us = &config.database_structure.users;
             let key_type = if us.bin_type_key { "BINARY(20)" } else { "VARCHAR(40)" };
             info!("[BOOT MySQL] Creating table {}", us.table_name);
             let query = if us.id_uuid {
                 format!(
-                    "CREATE TABLE `{}` (`{}` VARCHAR(36) NOT NULL, `{}` {} NOT NULL, `{}` BIGINT UNSIGNED NOT NULL DEFAULT 0, `{}` BIGINT UNSIGNED NOT NULL DEFAULT 0, `{}` BIGINT UNSIGNED NOT NULL DEFAULT 0, `{}` TINYINT NOT NULL DEFAULT 0, `{}` INT NOT NULL DEFAULT 0, PRIMARY KEY (`{}`)) COLLATE='utf8mb4_general_ci'",
+                    "CREATE TABLE IF NOT EXISTS `{}` (`{}` VARCHAR(36) NOT NULL, `{}` {} NOT NULL, `{}` BIGINT UNSIGNED NOT NULL DEFAULT 0, `{}` BIGINT UNSIGNED NOT NULL DEFAULT 0, `{}` BIGINT UNSIGNED NOT NULL DEFAULT 0, `{}` TINYINT NOT NULL DEFAULT 0, `{}` INT NOT NULL DEFAULT 0, PRIMARY KEY (`{}`)) COLLATE='utf8mb4_general_ci'",
                     us.table_name, us.column_uuid, us.column_key, key_type, us.column_uploaded, us.column_downloaded, us.column_completed, us.column_active, us.column_updated, us.column_uuid
                 )
             } else {
                 format!(
-                    "CREATE TABLE `{}` (`{}` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT, `{}` {} NOT NULL, `{}` BIGINT UNSIGNED NOT NULL DEFAULT 0, `{}` BIGINT UNSIGNED NOT NULL DEFAULT 0, `{}` BIGINT UNSIGNED NOT NULL DEFAULT 0, `{}` TINYINT NOT NULL DEFAULT 0, `{}` INT NOT NULL DEFAULT 0, PRIMARY KEY (`{}`)) COLLATE='utf8mb4_general_ci'",
+                    "CREATE TABLE IF NOT EXISTS `{}` (`{}` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT, `{}` {} NOT NULL, `{}` BIGINT UNSIGNED NOT NULL DEFAULT 0, `{}` BIGINT UNSIGNED NOT NULL DEFAULT 0, `{}` BIGINT UNSIGNED NOT NULL DEFAULT 0, `{}` TINYINT NOT NULL DEFAULT 0, `{}` INT NOT NULL DEFAULT 0, PRIMARY KEY (`{}`)) COLLATE='utf8mb4_general_ci'",
                     us.table_name, us.column_id, us.column_key, key_type, us.column_uploaded, us.column_downloaded, us.column_completed, us.column_active, us.column_updated, us.column_id
                 )
             };
             if let Err(e) = sqlx::query(&query).execute(pool).await {
-                panic!("{LOG_PREFIX} Error: {e}");
+                error!("{LOG_PREFIX} Failed to create table {}: {e}", us.table_name);
+                exit(1);
             }
             info!("[BOOT] Created the database and tables, restart without the parameter to start the app.");
         }
diff --git a/src/database/impls/database_connector_pgsql.rs b/src/database/impls/database_connector_pgsql.rs
index cbf6a70..6828460 100644
--- a/src/database/impls/database_connector_pgsql.rs
+++ b/src/database/impls/database_connector_pgsql.rs
@@ -71,11 +71,7 @@ impl DatabaseConnectorPgSQL {
                 LOG_PREFIX,
                 config.database.clone().path
             );
-            error!(
-                "{} Message: {:#?}",
-                LOG_PREFIX,
-                pgsql_connect.into_database_error().unwrap().message()
-            );
+            error!("{LOG_PREFIX} Message: {pgsql_connect}");
             exit(1);
         }
         let mut structure = DatabaseConnector {
@@ -99,7 +95,8 @@ impl DatabaseConnectorPgSQL {
                 ts.table_name, ts.column_infohash, hash_type, ts.column_seeds, ts.column_peers, ts.column_completed, ts.column_infohash
             );
             if let Err(e) = sqlx::query(&query).execute(pool).await {
-                panic!("{LOG_PREFIX} Error: {e}");
+                error!("{LOG_PREFIX} Failed to create table {}: {e}", ts.table_name);
+                exit(1);
             }
             let ws = &config.database_structure.whitelist;
             let hash_type = if ws.bin_type_infohash { "bytea" } else { "character(40)" };
@@ -109,7 +106,8 @@ impl DatabaseConnectorPgSQL {
                 ws.table_name, ws.column_infohash, hash_type, ws.column_infohash
             );
             if let Err(e) = sqlx::query(&query).execute(pool).await {
-                panic!("{LOG_PREFIX} Error: {e}");
+                error!("{LOG_PREFIX} Failed to create table {}: {e}", ws.table_name);
+                exit(1);
             }
             let bs = &config.database_structure.blacklist;
             let hash_type = if bs.bin_type_infohash { "bytea" } else { "character(40)" };
@@ -119,7 +117,8 @@ impl DatabaseConnectorPgSQL {
                 bs.table_name, bs.column_infohash, hash_type, bs.column_infohash
             );
             if let Err(e) = sqlx::query(&query).execute(pool).await {
-                panic!("{LOG_PREFIX} Error: {e}");
+                error!("{LOG_PREFIX} Failed to create table {}: {e}", bs.table_name);
+                exit(1);
             }
             let ks = &config.database_structure.keys;
             let hash_type = if ks.bin_type_hash { "bytea" } else { "character(40)" };
@@ -129,7 +128,8 @@ impl DatabaseConnectorPgSQL {
                 ks.table_name, ks.column_hash, hash_type, ks.column_timeout, ks.column_hash
             );
             if let Err(e) = sqlx::query(&query).execute(pool).await {
-                panic!("{LOG_PREFIX} Error: {e}");
+                error!("{LOG_PREFIX} Failed to create table {}: {e}", ks.table_name);
+                exit(1);
             }
             let us = &config.database_structure.users;
             let key_type = if us.bin_type_key { "bytea" } else { "character(40)" };
@@ -144,7 +144,8 @@ impl DatabaseConnectorPgSQL {
                 us.table_name, id_col, id_type, us.column_key, key_type, us.column_uploaded, us.column_downloaded, us.column_completed, us.column_active, us.column_updated, pk_col, id_col
             );
             if let Err(e) = sqlx::query(&query).execute(pool).await {
-                panic!("{LOG_PREFIX} Error: {e}");
+                error!("{LOG_PREFIX} Failed to create table {}: {e}", us.table_name);
+                exit(1);
             }
             info!("[BOOT] Created the database and tables, restart without the parameter to start the app.");
         }
diff --git a/src/database/impls/database_connector_sqlite.rs b/src/database/impls/database_connector_sqlite.rs
index e6fa857..7da4ae1 100644
--- a/src/database/impls/database_connector_sqlite.rs
+++ b/src/database/impls/database_connector_sqlite.rs
@@ -73,11 +73,7 @@ impl DatabaseConnectorSQLite {
                 LOG_PREFIX,
                 config.database.clone().path
             );
-            error!(
-                "{} Message: {:#?}",
-                LOG_PREFIX,
-                sqlite_connect.into_database_error().unwrap().message()
-            );
+            error!("{LOG_PREFIX} Message: {sqlite_connect}");
             exit(1);
         }
         let mut structure = DatabaseConnector {
@@ -114,7 +110,8 @@ impl DatabaseConnectorSQLite {
                 ts.table_name, ts.column_infohash, hash_type, ts.column_seeds, ts.column_peers, ts.column_completed
             );
             if let Err(e) = sqlx::query(&query).execute(pool).await {
-                panic!("{LOG_PREFIX} Error: {e}");
+                error!("{LOG_PREFIX} Failed to create table {}: {e}", ts.table_name);
+                exit(1);
             }
             let ws = &config.database_structure.whitelist;
             let hash_type = if ws.bin_type_infohash { "BLOB" } else { "TEXT" };
@@ -124,7 +121,8 @@ impl DatabaseConnectorSQLite {
                 ws.table_name, ws.column_infohash, hash_type
             );
             if let Err(e) = sqlx::query(&query).execute(pool).await {
-                panic!("{LOG_PREFIX} Error: {e}");
+                error!("{LOG_PREFIX} Failed to create table {}: {e}", ws.table_name);
+                exit(1);
             }
             let bs = &config.database_structure.blacklist;
             let hash_type = if bs.bin_type_infohash { "BLOB" } else { "TEXT" };
@@ -134,7 +132,8 @@ impl DatabaseConnectorSQLite {
                 bs.table_name, bs.column_infohash, hash_type
             );
             if let Err(e) = sqlx::query(&query).execute(pool).await {
-                panic!("{LOG_PREFIX} Error: {e}");
+                error!("{LOG_PREFIX} Failed to create table {}: {e}", bs.table_name);
+                exit(1);
             }
             let ks = &config.database_structure.keys;
             let hash_type = if ks.bin_type_hash { "BLOB" } else { "TEXT" };
@@ -144,7 +143,8 @@ impl DatabaseConnectorSQLite {
                 ks.table_name, ks.column_hash, hash_type, ks.column_timeout
             );
             if let Err(e) = sqlx::query(&query).execute(pool).await {
-                panic!("{LOG_PREFIX} Error: {e}");
+                error!("{LOG_PREFIX} Failed to create table {}: {e}", ks.table_name);
+                exit(1);
             }
             let us = &config.database_structure.users;
             let key_type = if us.bin_type_key { "BLOB" } else { "TEXT" };
@@ -161,7 +161,8 @@ impl DatabaseConnectorSQLite {
                 )
             };
             if let Err(e) = sqlx::query(&query).execute(pool).await {
-                panic!("{LOG_PREFIX} Error: {e}");
+                error!("{LOG_PREFIX} Failed to create table {}: {e}", us.table_name);
+                exit(1);
             }
             info!("[BOOT] Created the database and tables, restart without the parameter to start the app.");
         }
diff --git a/src/http/http.rs b/src/http/http.rs
index 46a6fb8..01c61ca 100644
--- a/src/http/http.rs
+++ b/src/http/http.rs
@@ -159,7 +159,10 @@ pub async fn http_service(
                 .client_disconnect_timeout(Duration::from_secs(disconnect_timeout))
                 .workers(worker_threads)
                 .bind_rustls_0_23((addr.ip(), addr.port()), tls_config)
-                .unwrap()
+                .unwrap_or_else(|e| {
+                    error!("[HTTPS] Unable to bind to {addr}: {e}");
+                    exit(1);
+                })
                 .disable_signals()
                 .run()
         } else {
@@ -174,7 +177,10 @@ pub async fn http_service(
                 .client_disconnect_timeout(Duration::from_secs(disconnect_timeout))
                 .workers(worker_threads)
                 .bind_rustls_0_23((addr.ip(), addr.port()), tls_config)
-                .unwrap()
+                .unwrap_or_else(|e| {
+                    error!("[HTTPS] Unable to bind to {addr}: {e}");
+                    exit(1);
+                })
                 .disable_signals()
                 .run()
         };
@@ -199,7 +205,10 @@ pub async fn http_service(
             .client_disconnect_timeout(Duration::from_secs(disconnect_timeout))
             .workers(worker_threads)
             .bind((addr.ip(), addr.port()))
-            .unwrap()
+            .unwrap_or_else(|e| {
+                error!("[HTTP] Unable to bind to {addr}: {e}");
+                exit(1);
+            })
             .disable_signals()
             .run()
     } else {
@@ -214,7 +223,10 @@ pub async fn http_service(
             .client_disconnect_timeout(Duration::from_secs(disconnect_timeout))
             .workers(worker_threads)
             .bind((addr.ip(), addr.port()))
-            .unwrap()
+            .unwrap_or_else(|e| {
+                error!("[HTTP] Unable to bind to {addr}: {e}");
+                exit(1);
+            })
             .disable_signals()
             .run()
     };
@@ -687,11 +699,11 @@ pub async fn http_service_scrape_handler(request: HttpRequest, ip: IpAddr, data:
             let data_scrape = data.handle_scrape(data.clone(), e.clone()).await;
             let mut scrape_list = ben_map!();
             let scrape_list_mut = scrape_list.dict_mut().unwrap();
-            for (info_hash, torrent_entry) in &data_scrape {
+            for (info_hash, counts) in &data_scrape {
                 scrape_list_mut.insert(Cow::from(info_hash.0.to_vec()), ben_map! {
-                    "complete" => ben_int!((torrent_entry.seeds.len() + torrent_entry.seeds_ipv6.len()) as i64),
-                    "downloaded" => ben_int!(torrent_entry.completed as i64),
-                    "incomplete" => ben_int!((torrent_entry.peers.len() + torrent_entry.peers_ipv6.len()) as i64)
+                    "complete" => ben_int!(counts.total_seeds() as i64),
+                    "downloaded" => ben_int!(counts.completed as i64),
+                    "incomplete" => ben_int!(counts.total_peers() as i64)
                 });
             }
             HttpResponse::Ok().content_type(ContentType::plaintext()).body(ben_map! {
@@ -848,13 +860,14 @@ pub async fn http_service_check_user_key_validation(data: Arc<TorrentTracker>, u
     None
 }
 
-pub fn http_check_host_and_port_used(bind_address: String) {
-    if cfg!(target_os = "windows") {
-        match std::net::TcpListener::bind(&bind_address) {
-            Ok(e) => e,
-            Err(_) => { panic!("Unable to bind to {} ! Exiting...", &bind_address); }
-        };
+pub fn http_check_host_and_port_used(bind_address: &str) -> std::io::Result<()> {
+    if cfg!(target_os = "windows")
+        && let Err(e) = std::net::TcpListener::bind(bind_address)
+    {
+        log::error!("Unable to bind TCP listener to {bind_address}: {e}");
+        return Err(e);
     }
+    Ok(())
 }
 
 #[inline]
diff --git a/src/main.rs b/src/main.rs
index 8964fcb..ef8b2cb 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -153,7 +153,7 @@ fn main() -> std::io::Result<()>
 
             for api_server_object in &config.api_server {
                 if api_server_object.enabled {
-                    http_check_host_and_port_used(api_server_object.bind_address.clone());
+                    http_check_host_and_port_used(&api_server_object.bind_address)?;
                     let address: SocketAddr = api_server_object.bind_address.parse().unwrap();
 
                     let (handle, future) = api_service(
@@ -190,7 +190,7 @@ fn main() -> std::io::Result<()>
 
             for http_server_object in &config.http_server {
                 if http_server_object.enabled {
-                    http_check_host_and_port_used(http_server_object.bind_address.clone());
+                    http_check_host_and_port_used(&http_server_object.bind_address)?;
                     let address: SocketAddr = http_server_object.bind_address.parse().unwrap();
 
                     let (handle, future) = http_service(
@@ -228,7 +228,7 @@ fn main() -> std::io::Result<()>
 
             for udp_server_object in &config.udp_server {
                 if udp_server_object.enabled {
-                    udp_check_host_and_port_used(udp_server_object.bind_address.clone());
+                    udp_check_host_and_port_used(&udp_server_object.bind_address)?;
                     let address: SocketAddr = udp_server_object.bind_address.parse().unwrap();
 
                     let udp_threads: usize = udp_server_object.udp_threads;
@@ -267,7 +267,7 @@ fn main() -> std::io::Result<()>
 
                     let bind_address = &tracker_config.cluster_bind_address;
                     if !bind_address.is_empty() {
-                        http_check_host_and_port_used(bind_address.clone());
+                        http_check_host_and_port_used(bind_address)?;
                         let address: SocketAddr = bind_address.parse().expect("Invalid cluster_bind_address");
 
                         info!("[CLUSTER] Starting WebSocket master server on {}", address);
@@ -312,7 +312,7 @@ fn main() -> std::io::Result<()>
                 }
             }
 
-            
+
             if !ws_futures.is_empty() {
                 let (handles, futures): (Vec<_>, Vec<_>) = ws_futures.into_iter().unzip();
                 tokio_core.spawn(async move {
@@ -328,8 +328,8 @@ fn main() -> std::io::Result<()>
 
             tokio_core.spawn(async move {
                 let mut interval = tokio::time::interval(Duration::from_secs(console_interval));
-                
-                let mut last_udp: Option<(i64,i64,i64,i64,i64,i64,i64)> = None; 
+
+                let mut last_udp: Option<(i64,i64,i64,i64,i64,i64,i64)> = None;
                 loop {
                     tokio::select! {
                         _ = interval.tick() => {
@@ -352,7 +352,7 @@ fn main() -> std::io::Result<()>
                                 stats.tcp6_scrapes_handled, stats.tcp6_failure, stats.tcp6_not_found
                             );
 
-                            
+
                             let now = chrono::Utc::now().timestamp();
                             let (udp_c4_ps, udp_a4_ps, udp_s4_ps, udp_c6_ps, udp_a6_ps, udp_s6_ps) = if let Some((t,c4,a4,s4,c6,a6,s6)) = last_udp {
                                 let dt = (now - t).max(1);
@@ -459,7 +459,7 @@ fn main() -> std::io::Result<()>
 
                                 info!("[DATABASE UPDATES] Starting batch updates...");
 
-                                
+
                                 let mut tasks = vec![
                                     tokio::spawn({
                                         let tracker = tracker_spawn_updates.clone();
@@ -504,7 +504,7 @@ fn main() -> std::io::Result<()>
                                         }
                                     }));
                                 }
-                                
+
                                 for task in tasks {
                                     let _ = task.await;
                                 }
diff --git a/src/stats/impls/torrent_tracker.rs b/src/stats/impls/torrent_tracker.rs
index 7d0a469..ebf192a 100644
--- a/src/stats/impls/torrent_tracker.rs
+++ b/src/stats/impls/torrent_tracker.rs
@@ -193,7 +193,7 @@ impl TorrentTracker {
             StatsEvent::UdpQueueLen => {
                 self.stats.udp_queue_len.store(value, Ordering::Release);
             }
-            
+
             StatsEvent::WsConnectionsActive => {
                 self.update_counter(&self.stats.ws_connections_active, value);
             }
diff --git a/src/structs.rs b/src/structs.rs
index 9e19c57..42c74da 100644
--- a/src/structs.rs
+++ b/src/structs.rs
@@ -5,55 +5,55 @@ use clap::Parser;
 pub struct Cli {
     #[arg(long)]
     pub create_config: bool,
-    
+
     #[arg(long)]
     pub create_database: bool,
-    
+
     #[arg(long)]
     pub create_selfsigned: bool,
-    
+
     #[arg(long, requires("create_selfsigned"), default_value = "localhost")]
     pub selfsigned_domain: String,
-    
+
     #[arg(long, requires("create_selfsigned"), default_value = "key.pem")]
     pub selfsigned_keyfile: String,
-    
+
     #[arg(long, requires("create_selfsigned"), default_value = "cert.pem")]
     pub selfsigned_certfile: String,
 
     #[arg(long)]
     pub export: bool,
-    
+
     #[arg(long, requires("export"), default_value = "torrents.json")]
     pub export_file_torrents: String,
-    
+
     #[arg(long, requires("export"), default_value = "whitelists.json")]
     pub export_file_whitelists: String,
-    
+
     #[arg(long, requires("export"), default_value = "blacklists.json")]
     pub export_file_blacklists: String,
-    
+
     #[arg(long, requires("export"), default_value = "keys.json")]
     pub export_file_keys: String,
-    
+
     #[arg(long, requires("export"), default_value = "users.json")]
     pub export_file_users: String,
 
     #[arg(long)]
     pub import: bool,
-    
+
     #[arg(long, requires("export"), default_value = "torrents.json")]
     pub import_file_torrents: String,
-    
+
     #[arg(long, requires("export"), default_value = "whitelists.json")]
     pub import_file_whitelists: String,
-    
+
     #[arg(long, requires("export"), default_value = "blacklists.json")]
     pub import_file_blacklists: String,
-    
+
     #[arg(long, requires("export"), default_value = "keys.json")]
     pub import_file_keys: String,
-    
+
     #[arg(long, requires("export"), default_value = "users.json")]
     pub import_file_users: String,
 }
\ No newline at end of file
diff --git a/src/tracker/impls/info_hash.rs b/src/tracker/impls/info_hash.rs
index 7fe725a..49e8869 100644
--- a/src/tracker/impls/info_hash.rs
+++ b/src/tracker/impls/info_hash.rs
@@ -48,15 +48,7 @@ impl From<[u8; 20]> for InfoHash {
 
 impl serde::ser::Serialize for InfoHash {
     fn serialize<S: serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        const HEX_CHARS: &[u8; 16] = b"0123456789abcdef";
-        let mut buffer = [0u8; 40];
-        for (i, &byte) in self.0.iter().enumerate() {
-            let idx = i * 2;
-            buffer[idx] = HEX_CHARS[(byte >> 4) as usize];
-            buffer[idx + 1] = HEX_CHARS[(byte & 0xf) as usize];
-        }
-        let str_out = unsafe { std::str::from_utf8_unchecked(&buffer) };
-        serializer.serialize_str(str_out)
+        serializer.serialize_str(crate::common::common::bin20_to_hex(&self.0).as_str())
     }
 }
 
diff --git a/src/tracker/impls/peer_id.rs b/src/tracker/impls/peer_id.rs
index f477a51..f2a175e 100644
--- a/src/tracker/impls/peer_id.rs
+++ b/src/tracker/impls/peer_id.rs
@@ -2,7 +2,7 @@ use std::fmt;
 use std::fmt::Formatter;
 use serde::Serialize;
 use crate::common::common::bin2hex;
-use crate::common::common::hex_char_to_nibble;
+use crate::common::common::hex_to_nibble;
 use crate::tracker::structs::peer_id::PeerId;
 
 impl fmt::Display for PeerId {
@@ -96,20 +96,14 @@ impl Serialize for PeerId {
     where
         S: serde::Serializer,
     {
-        const HEX_CHARS: &[u8; 16] = b"0123456789abcdef";
-        let mut buffer = [0u8; 40];
-        for (i, &byte) in self.0.iter().enumerate() {
-            buffer[i * 2] = HEX_CHARS[(byte >> 4) as usize];
-            buffer[i * 2 + 1] = HEX_CHARS[(byte & 0xf) as usize];
-        }
-        let id = unsafe { std::str::from_utf8_unchecked(&buffer) };
+        let buffer = crate::common::common::bin20_to_hex(&self.0);
         #[derive(Serialize)]
         struct PeerIdInfo<'a> {
             id: &'a str,
             client: Option<&'a str>,
         }
         let obj = PeerIdInfo {
-            id,
+            id: buffer.as_str(),
             client: self.get_client_name(),
         };
         obj.serialize(serializer)
@@ -126,8 +120,8 @@ impl std::str::FromStr for PeerId {
         let mut result = PeerId([0u8; 20]);
         let bytes = s.as_bytes();
         for i in 0..20 {
-            let high = hex_char_to_nibble(bytes[i * 2]);
-            let low = hex_char_to_nibble(bytes[i * 2 + 1]);
+            let high = hex_to_nibble(bytes[i * 2]);
+            let low = hex_to_nibble(bytes[i * 2 + 1]);
             if high == 0xFF || low == 0xFF {
                 return Err(binascii::ConvertError::InvalidInput);
             }
@@ -170,8 +164,8 @@ impl<'de> serde::de::Deserialize<'de> for PeerId {
                 let mut res = PeerId([0u8; 20]);
                 let bytes = v.as_bytes();
                 for i in 0..20 {
-                    let high = hex_char_to_nibble(bytes[i * 2]);
-                    let low = hex_char_to_nibble(bytes[i * 2 + 1]);
+                    let high = hex_to_nibble(bytes[i * 2]);
+                    let low = hex_to_nibble(bytes[i * 2 + 1]);
                     if high == 0xFF || low == 0xFF {
                         return Err(serde::de::Error::invalid_value(
                             serde::de::Unexpected::Str(v),
diff --git a/src/tracker/impls/torrent_tracker_handlers.rs b/src/tracker/impls/torrent_tracker_handlers.rs
index 0bb32fc..5f6a523 100644
--- a/src/tracker/impls/torrent_tracker_handlers.rs
+++ b/src/tracker/impls/torrent_tracker_handlers.rs
@@ -229,16 +229,7 @@ impl TorrentTracker {
                     }
                     let elapsed = now.elapsed();
                     debug!("[PERF] Announce Started handling took: {elapsed:?}");
-                    Ok((torrent_peer, TorrentEntry {
-                        seeds: torrent_entry.1.seeds,
-                        seeds_ipv6: torrent_entry.1.seeds_ipv6,
-                        peers: torrent_entry.1.peers,
-                        peers_ipv6: torrent_entry.1.peers_ipv6,
-                        rtc_seeds: torrent_entry.1.rtc_seeds,
-                        rtc_peers: torrent_entry.1.rtc_peers,
-                        completed: torrent_entry.1.completed,
-                        updated: torrent_entry.1.updated
-                    }))
+                    Ok((torrent_peer, torrent_entry.1))
                 }
             }
             AnnounceEvent::Stopped => {
@@ -366,15 +357,17 @@ impl TorrentTracker {
         }
     }
 
-    pub async fn handle_scrape(&self, data: Arc<TorrentTracker>, scrape_query: ScrapeQueryRequest) -> BTreeMap<InfoHash, TorrentEntry>
+    pub async fn handle_scrape(&self, data: Arc<TorrentTracker>, scrape_query: ScrapeQueryRequest) -> BTreeMap<InfoHash, crate::tracker::structs::torrent_counts::TorrentCounts>
     {
         let transaction = crate::utils::sentry_tracing::start_trace_transaction("handle_scrape", "tracker");
 
         let now = std::time::Instant::now();
         let result = scrape_query.info_hash.iter()
             .map(|&info_hash| {
-                let entry = data.get_torrent(info_hash).unwrap_or_default();
-                (info_hash, entry)
+                let counts = data.get_torrent_counts(info_hash).unwrap_or(crate::tracker::structs::torrent_counts::TorrentCounts {
+                    seeds_ipv4: 0, seeds_ipv6: 0, peers_ipv4: 0, peers_ipv6: 0, completed: 0,
+                });
+                (info_hash, counts)
             })
             .collect();
         let elapsed = now.elapsed();
diff --git a/src/tracker/impls/torrent_tracker_torrents.rs b/src/tracker/impls/torrent_tracker_torrents.rs
index 6c3299f..6adefe3 100644
--- a/src/tracker/impls/torrent_tracker_torrents.rs
+++ b/src/tracker/impls/torrent_tracker_torrents.rs
@@ -97,6 +97,14 @@ impl TorrentTracker {
         lock.get(&info_hash).cloned()
     }
 
+    #[inline]
+    pub fn get_torrent_counts(&self, info_hash: InfoHash) -> Option<crate::tracker::structs::torrent_counts::TorrentCounts>
+    {
+        let shard = self.torrents_sharding.get_shard(info_hash.0[0]).unwrap();
+        let lock = shard.read_recursive();
+        lock.get(&info_hash).map(crate::tracker::structs::torrent_counts::TorrentCounts::from_entry)
+    }
+
     pub fn get_torrents(&self, hashes: Vec<InfoHash>) -> BTreeMap<InfoHash, Option<TorrentEntry>>
     {
         hashes.into_iter()
diff --git a/src/tracker/impls/user_id.rs b/src/tracker/impls/user_id.rs
index 5d0922c..dd6fdd6 100644
--- a/src/tracker/impls/user_id.rs
+++ b/src/tracker/impls/user_id.rs
@@ -49,14 +49,7 @@ impl From<[u8; 20]> for UserId {
 
 impl serde::ser::Serialize for UserId {
     fn serialize<S: serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        const HEX_CHARS: &[u8; 16] = b"0123456789abcdef";
-        let mut buffer = [0u8; 40];
-        for (i, &byte) in self.0.iter().enumerate() {
-            buffer[i * 2] = HEX_CHARS[(byte >> 4) as usize];
-            buffer[i * 2 + 1] = HEX_CHARS[(byte & 0xf) as usize];
-        }
-        let str_out = unsafe { std::str::from_utf8_unchecked(&buffer) };
-        serializer.serialize_str(str_out)
+        serializer.serialize_str(crate::common::common::bin20_to_hex(&self.0).as_str())
     }
 }
 
diff --git a/src/tracker/structs.rs b/src/tracker/structs.rs
index 89dfa0e..46bbfdf 100644
--- a/src/tracker/structs.rs
+++ b/src/tracker/structs.rs
@@ -10,4 +10,5 @@ pub mod user_entry_item;
 pub mod user_id;
 pub mod torrent_peers;
 pub mod torrent_sharding;
-pub mod cleanup_stats;
\ No newline at end of file
+pub mod cleanup_stats;
+pub mod torrent_counts;
\ No newline at end of file
diff --git a/src/tracker/structs/scrape_query_request.rs b/src/tracker/structs/scrape_query_request.rs
index 7432622..9f25869 100644
--- a/src/tracker/structs/scrape_query_request.rs
+++ b/src/tracker/structs/scrape_query_request.rs
@@ -2,7 +2,6 @@ use serde::Deserialize;
 use crate::tracker::structs::info_hash::InfoHash;
 
 #[derive(Deserialize, Clone, Debug)]
-#[allow(dead_code)]
 pub struct ScrapeQueryRequest {
     pub(crate) info_hash: Vec<InfoHash>,
 }
\ No newline at end of file
diff --git a/src/tracker/structs/torrent_counts.rs b/src/tracker/structs/torrent_counts.rs
new file mode 100644
index 0000000..ae5d794
--- /dev/null
+++ b/src/tracker/structs/torrent_counts.rs
@@ -0,0 +1,37 @@
+use crate::tracker::structs::torrent_entry::TorrentEntry;
+
+/// Cheap snapshot of a [`TorrentEntry`] for scrape responses.
+///
+/// Holds just the lengths of each peer map and the `completed` count, so
+/// scrape can answer without cloning the underlying `AHashMap<PeerId,
+/// TorrentPeer>` maps that `TorrentEntry::clone` would copy.
+#[derive(Clone, Copy, Debug)]
+pub struct TorrentCounts {
+    pub seeds_ipv4: usize,
+    pub seeds_ipv6: usize,
+    pub peers_ipv4: usize,
+    pub peers_ipv6: usize,
+    pub completed: u64,
+}
+
+impl TorrentCounts {
+    pub fn from_entry(entry: &TorrentEntry) -> Self {
+        Self {
+            seeds_ipv4: entry.seeds.len(),
+            seeds_ipv6: entry.seeds_ipv6.len(),
+            peers_ipv4: entry.peers.len(),
+            peers_ipv6: entry.peers_ipv6.len(),
+            completed: entry.completed,
+        }
+    }
+
+    #[inline]
+    pub fn total_seeds(&self) -> usize {
+        self.seeds_ipv4 + self.seeds_ipv6
+    }
+
+    #[inline]
+    pub fn total_peers(&self) -> usize {
+        self.peers_ipv4 + self.peers_ipv6
+    }
+}
diff --git a/src/udp/impls/parse_pool.rs b/src/udp/impls/parse_pool.rs
index 1931396..5a4f4c0 100644
--- a/src/udp/impls/parse_pool.rs
+++ b/src/udp/impls/parse_pool.rs
@@ -101,8 +101,6 @@ impl ParsePool {
                 }
             });
         }
-        let runtime = self.udp_runtime.clone();
-        std::mem::forget(runtime);
     }
 
     fn extract_spp_info(packet: &UdpPacket) -> (SocketAddr, &[u8]) {
diff --git a/src/udp/impls/udp_server.rs b/src/udp/impls/udp_server.rs
index 1a9414e..cbb858d 100644
--- a/src/udp/impls/udp_server.rs
+++ b/src/udp/impls/udp_server.rs
@@ -122,7 +122,7 @@ impl UdpServer {
                                             socket: socket_clone.clone(),
                                         };
                                         if parse_pool_clone.payload.push(packet).is_err() {
-                                            
+
                                             debug!("Parse pool queue full, dropping packet");
                                         }
                                     }
@@ -433,11 +433,11 @@ impl UdpServer {
     pub async fn handle_udp_scrape(remote_addr: SocketAddr, request: &ScrapeRequest, tracker: Arc<TorrentTracker>) -> Result<Response, ServerError> {
         let mut torrent_stats = Vec::with_capacity(request.info_hashes.len());
         for info_hash in &request.info_hashes {
-            let scrape_entry = match tracker.get_torrent(InfoHash(info_hash.0)) {
-                Some(torrent_info) => TorrentScrapeStatistics {
-                    seeders: NumberOfPeers(torrent_info.seeds.len() as i32),
-                    completed: NumberOfDownloads(torrent_info.completed as i32),
-                    leechers: NumberOfPeers(torrent_info.peers.len() as i32),
+            let scrape_entry = match tracker.get_torrent_counts(InfoHash(info_hash.0)) {
+                Some(counts) => TorrentScrapeStatistics {
+                    seeders: NumberOfPeers(counts.seeds_ipv4 as i32),
+                    completed: NumberOfDownloads(counts.completed as i32),
+                    leechers: NumberOfPeers(counts.peers_ipv4 as i32),
                 },
                 None => TorrentScrapeStatistics {
                     seeders: NumberOfPeers(0),
diff --git a/src/websocket/websocket.rs b/src/websocket/websocket.rs
index 6088a30..437c358 100644
--- a/src/websocket/websocket.rs
+++ b/src/websocket/websocket.rs
@@ -455,7 +455,7 @@ pub async fn process_scrape(tracker: &Arc<TorrentTracker>, request: &ClusterRequ
     let data_scrape = tracker.handle_scrape(tracker.clone(), scrape.clone()).await;
     let mut files_map = ben_map!();
     let files_map_mut = files_map.dict_mut().unwrap();
-    for (info_hash, torrent_entry) in &data_scrape {
+    for (info_hash, counts) in &data_scrape {
         if tracker_config.whitelist_enabled && !tracker.check_whitelist(*info_hash) {
             continue;
         }
@@ -465,9 +465,9 @@ pub async fn process_scrape(tracker: &Arc<TorrentTracker>, request: &ClusterRequ
         files_map_mut.insert(
             Cow::from(info_hash.0.to_vec()),
             ben_map! {
-                "complete" => ben_int!((torrent_entry.seeds.len() + torrent_entry.seeds_ipv6.len()) as i64),
-                "downloaded" => ben_int!(torrent_entry.completed as i64),
-                "incomplete" => ben_int!((torrent_entry.peers.len() + torrent_entry.peers_ipv6.len()) as i64)
+                "complete" => ben_int!(counts.total_seeds() as i64),
+                "downloaded" => ben_int!(counts.completed as i64),
+                "incomplete" => ben_int!(counts.total_peers() as i64)
             }
         );
     }
@@ -562,9 +562,10 @@ pub async fn websocket_master_service(
             Ok(data) => data,
             Err(e) => panic!("[WEBSOCKET MASTER] SSL cert couldn't be extracted: {e}"),
         };
-        let tls_key = match rustls_pemfile::pkcs8_private_keys(key_file).next().unwrap() {
-            Ok(data) => data,
-            Err(e) => panic!("[WEBSOCKET MASTER] SSL key couldn't be extracted: {e}"),
+        let tls_key = match rustls_pemfile::pkcs8_private_keys(key_file).next() {
+            Some(Ok(data)) => data,
+            Some(Err(e)) => panic!("[WEBSOCKET MASTER] SSL key couldn't be extracted: {e}"),
+            None => panic!("[WEBSOCKET MASTER] No PKCS#8 private key found in {ssl_key}; expected a PEM-encoded PKCS#8 key (RSA / EC keys are not supported here)"),
         };
         let tls_config = match rustls::ServerConfig::builder()
             .with_no_client_auth()
diff --git a/tests/udp_tests.rs b/tests/udp_tests.rs
index e0ebe9d..e6c6cf0 100644
--- a/tests/udp_tests.rs
+++ b/tests/udp_tests.rs
@@ -13,8 +13,8 @@ use torrust_actix::udp::udp::PROTOCOL_IDENTIFIER;
 #[test]
 fn test_udp_connect_request_parsing() {
     let mut packet = vec![];
-    packet.extend_from_slice(&PROTOCOL_IDENTIFIER.to_be_bytes()); 
-    packet.extend_from_slice(&0u32.to_be_bytes()); 
+    packet.extend_from_slice(&PROTOCOL_IDENTIFIER.to_be_bytes());
+    packet.extend_from_slice(&0u32.to_be_bytes());
     packet.extend_from_slice(&12345u32.to_be_bytes());
     let result = Request::from_bytes(&packet, 74);
     assert!(result.is_ok(), "Should parse valid connect request");
@@ -125,7 +125,7 @@ async fn test_udp_packet_size_limits() {
 
     let mut packet = vec![];
     packet.write_u64::<BigEndian>(12345).unwrap();
-    packet.write_u32::<BigEndian>(2).unwrap(); 
+    packet.write_u32::<BigEndian>(2).unwrap();
     packet.write_u32::<BigEndian>(1).unwrap();
     for _ in 0..80 {
         packet.extend_from_slice(&[0u8; 20]);
-- 
2.51.0.windows.1