format codebase

Author: brambora69123

migration/src/m20260406_000008_optimize_database_types.rs

@@ -55,10 +55,8 @@ impl MigrationTrait for Migration {
         // ── Step 1: Convert IP columns from TEXT to INET ─────────────────────
         println!("Converting IP columns from TEXT to INET...");
 
-        db.execute_unprepared(
-            "ALTER TABLE servers ALTER COLUMN ip TYPE INET USING ip::INET",
-        )
-        .await?;
+        db.execute_unprepared("ALTER TABLE servers ALTER COLUMN ip TYPE INET USING ip::INET")
+            .await?;
         db.execute_unprepared(
             "ALTER TABLE server_players ALTER COLUMN ip TYPE INET USING ip::INET",
         )
@@ -257,10 +255,8 @@ impl MigrationTrait for Migration {
             "ALTER TABLE server_players ALTER COLUMN ip TYPE TEXT USING ip::TEXT",
         )
         .await?;
-        db.execute_unprepared(
-            "ALTER TABLE servers ALTER COLUMN ip TYPE TEXT USING ip::TEXT",
-        )
-        .await?;
+        db.execute_unprepared("ALTER TABLE servers ALTER COLUMN ip TYPE TEXT USING ip::TEXT")
+            .await?;
 
         // Recreate FKs
         db.execute_unprepared(

migration/src/m20260408_000009_add_scaling_indexes.rs

@@ -28,7 +28,7 @@ impl MigrationTrait for Migration {
 
         // Index for discovery range queries: get_ranges_to_scan joins
         // asn_ranges → asns and filters by category, then orders by last_scanned_at.
-        // The category filter comes from the ASNs table, but indexing asn, 
+        // The category filter comes from the ASNs table, but indexing asn,
         // last_scanned_at helps the join and sort.
         db.execute_unprepared(
             "CREATE INDEX IF NOT EXISTS idx_asn_ranges_asn_lastscanned \

packages/api/src/handlers/mod.rs

@@ -16,12 +16,12 @@
 //! - GET / - Static dashboard (fallback to assets)
 
 use axum::{
+    Router,
     extract::{Path, Query, Request, State},
     http::{HeaderMap, StatusCode},
     middleware::{self, Next},
     response::{Json, Response},
     routing::{get, post},
-    Router,
 };
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;

packages/api/src/main.rs

@@ -3,14 +3,16 @@
 //! Web API and database management service for Minecraft server scanning.
 //! This service can run independently of the scanner service.
 
+use migration::Migrator;
 use nmcscan_shared::models::entities::{asns, servers};
 use nmcscan_shared::repositories::{
     ApiKeyRepository, AsnRepository, ServerRepository, StatsRepository,
 };
 use nmcscan_shared::services::asn_fetcher::AsnFetcher;
 use nmcscan_shared::utils::exclude::{ExcludeList, ExcludeManager};
-use migration::Migrator;
-use sea_orm::{ColumnTrait, ConnectOptions, Database, EntityTrait, PaginatorTrait, QueryFilter, QuerySelect};
+use sea_orm::{
+    ColumnTrait, ConnectOptions, Database, EntityTrait, PaginatorTrait, QueryFilter, QuerySelect,
+};
 use sea_orm_migration::MigratorTrait;
 use std::sync::Arc;
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
@@ -21,7 +23,11 @@ mod handlers;
 
 /// NMCScan API Service arguments
 #[derive(Parser, Debug)]
-#[command(author, version, about = "NMCScan API Service - Web interface and database management")]
+#[command(
+    author,
+    version,
+    about = "NMCScan API Service - Web interface and database management"
+)]
 struct Args {
     /// Log level (debug, info, warn, error)
     #[arg(short, long, env = "RUST_LOG", default_value = "info")]
@@ -104,7 +110,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         tracing::warn!("Failed to parse exclude list: {}", e);
         ExcludeList::from_str("").unwrap()
     });
-    tracing::info!("Loaded {} exclude networks (including honeypots)", exclude_list.len());
+    tracing::info!(
+        "Loaded {} exclude networks (including honeypots)",
+        exclude_list.len()
+    );
 
     // 2. Initialize database and run migrations
     tracing::info!("Initializing database at {}...", args.database);
@@ -126,12 +135,13 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let asn_repo = Arc::new(AsnRepository::new((*db).clone()));
     let stats_repo = Arc::new(StatsRepository::new((*db).clone()));
     let api_key_repo = Arc::new(ApiKeyRepository::new((*db).clone()));
-    let minecraft_account_repo = Arc::new(nmcscan_shared::repositories::MinecraftAccountRepository::new((*db).clone()));
+    let minecraft_account_repo =
+        Arc::new(nmcscan_shared::repositories::MinecraftAccountRepository::new((*db).clone()));
 
     // 4. Initialize ASN fetcher and import/update ASN data
     tracing::info!("Initializing ASN fetcher...");
     let asn_fetcher = Arc::new(AsnFetcher::new(Arc::clone(&db), Arc::clone(&asn_repo)));
-    
+
     // Full import if forced or if data is missing
     let range_count = asn_fetcher.asn_manager().read().await.range_count();
     let asn_count = asn_fetcher.asn_manager().read().await.asn_count();
@@ -162,10 +172,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             .await
             .unwrap_or(0);
 
-        let total_count = asns::Entity::find()
-            .count(&*db)
-            .await
-            .unwrap_or(1);
+        let total_count = asns::Entity::find().count(&*db).await.unwrap_or(1);
 
         let unknown_percentage = if total_count > 0 {
             (unknown_count as f64 / total_count as f64) * 100.0
@@ -183,7 +190,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             let ipverse_map = asn_fetcher.fetch_ipverse_map().await;
             match asn_fetcher.recategorize_all_asns(&ipverse_map).await {
                 Ok(updated) => {
-                    tracing::info!("Startup recategorization complete: {} ASNs reclassified", updated);
+                    tracing::info!(
+                        "Startup recategorization complete: {} ASNs reclassified",
+                        updated
+                    );
                 }
                 Err(e) => {
                     tracing::error!("Startup recategorization failed: {}", e);
@@ -195,19 +205,20 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // 5. Backfill ASN data for existing servers
     {
         let db_clone = Arc::clone(&db);
-        let servers_res: Result<Vec<servers::Model>, sea_orm::DbErr> =
-            servers::Entity::find()
-                .filter(servers::Column::Asn.is_null())
-                .filter(servers::Column::Status.ne("ignored"))
-                .limit(5000)
-                .all(&*db_clone)
-                .await;
+        let servers_res: Result<Vec<servers::Model>, sea_orm::DbErr> = servers::Entity::find()
+            .filter(servers::Column::Asn.is_null())
+            .filter(servers::Column::Status.ne("ignored"))
+            .limit(5000)
+            .all(&*db_clone)
+            .await;
         if let Ok(srvs) = servers_res {
             if !srvs.is_empty() {
                 tracing::info!("Backfilling ASN data for {} servers...", srvs.len());
                 // Note: Full backfill would require the ASN fetcher to look up each IP
                 // This is a lighter version for the API service
-                tracing::info!("Backfill skipped in API-only mode (scanner will handle on startup)");
+                tracing::info!(
+                    "Backfill skipped in API-only mode (scanner will handle on startup)"
+                );
             }
         }
     }
@@ -259,7 +270,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         contact_email: args.contact_email.clone(),
         discord_link: args.discord_link.clone(),
     };
-    
+
     let listen_addr = args.listen_addr.clone();
     let listen_addr_log = listen_addr.clone();
     let api_handle = tokio::spawn(async move {
@@ -268,7 +279,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     tracing::info!("✅ API Service started on {}", listen_addr_log);
     tracing::info!("   Database: connected");
-    tracing::info!("   ASN Manager: initialized ({} ASNs, {} ranges)", asn_count, range_count);
+    tracing::info!(
+        "   ASN Manager: initialized ({} ASNs, {} ranges)",
+        asn_count,
+        range_count
+    );
     tracing::info!("   Scanner: NOT running (separate nmcscan-scanner service)");
     tracing::info!("   Login queue: NOT running (part of scanner service)");
 

packages/scanner/src/login_queue.rs

@@ -8,14 +8,14 @@
 //! This gives the scanner time to do its initial SLP pass and populate version data.
 
 use std::net::SocketAddr;
-use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use tokio::sync::{Mutex, Semaphore};
 use tokio::time::{self, Duration};
 
-use nmcscan_shared::network::login::{self, LoginObstacle, LoginResult, LATEST_PROTOCOL};
-use nmcscan_shared::repositories::ServerRepository;
 use chrono::Utc;
+use nmcscan_shared::network::login::{self, LATEST_PROTOCOL, LoginObstacle, LoginResult};
+use nmcscan_shared::repositories::ServerRepository;
 use sea_orm::prelude::IpNetwork;
 
 /// Login queue statistics.
@@ -212,7 +212,11 @@ impl LoginQueue {
                             // We've cycled through all servers — reset cursor and start over
                             cursor_ip = None;
                             cursor_port = None;
-                            match self.server_repo.get_online_servers_cursor(500, None, None).await {
+                            match self
+                                .server_repo
+                                .get_online_servers_cursor(500, None, None)
+                                .await
+                            {
                                 Ok(b) => current_batch = b,
                                 Err(e) => {
                                     tracing::error!("Failed to fetch online servers: {}", e);

packages/scanner/src/main.rs

@@ -3,20 +3,18 @@
 //! High-performance Minecraft server scanning service.
 //! This service can run independently of the API service.
 
+mod login_queue;
 mod scanner;
 mod scanner_loop;
-mod login_queue;
 
-use nmcscan_shared::models::asn::AsnCategory;
 use crate::scanner::Scanner;
-use nmcscan_shared::repositories::{
-    AsnRepository, ServerRepository, StatsRepository,
-};
+use migration::Migrator;
+use nmcscan_shared::models::asn::AsnCategory;
+use nmcscan_shared::repositories::{AsnRepository, ServerRepository, StatsRepository};
 use nmcscan_shared::services::asn_fetcher::AsnFetcher;
 use nmcscan_shared::services::scheduler::{Scheduler, ServerTarget};
 use nmcscan_shared::utils::exclude::{ExcludeList, ExcludeManager};
 use nmcscan_shared::utils::test_mode;
-use migration::Migrator;
 use sea_orm::{ConnectOptions, Database};
 use sea_orm_migration::MigratorTrait;
 use std::sync::Arc;
@@ -26,7 +24,11 @@ use clap::Parser;
 
 /// NMCScan Scanner Service arguments
 #[derive(Parser, Debug)]
-#[command(author, version, about = "NMCScan Scanner Service - High-performance Minecraft server scanning")]
+#[command(
+    author,
+    version,
+    about = "NMCScan Scanner Service - High-performance Minecraft server scanning"
+)]
 struct Args {
     /// Enable test mode (scan only known servers)
     #[arg(short, long, env = "TEST_MODE", default_value = "false")]
@@ -82,7 +84,6 @@ struct Args {
     force_asn_import: bool,
 }
 
-
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let _ = dotenvy::dotenv();
@@ -191,22 +192,34 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
         tracing::info!("Loading {} test servers...", test_servers.len());
         for (ip, port, _name, host) in &test_servers {
-            let server_type: String = if *port == 19132 { "bedrock".to_string() } else { "java".to_string() };
+            let server_type: String = if *port == 19132 {
+                "bedrock".to_string()
+            } else {
+                "java".to_string()
+            };
             let mut target = ServerTarget::new(ip.clone(), *port, server_type.clone());
             target.category = AsnCategory::Hosting;
             target.priority = 1;
             target.hostname = Some(host.clone());
 
             let port_i16: i16 = (*port).try_into().unwrap_or(25565);
-            let _ = server_repo.insert_server_if_new(ip, port_i16, &server_type).await;
+            let _ = server_repo
+                .insert_server_if_new(ip, port_i16, &server_type)
+                .await;
             scheduler.add_server(target, false).await;
         }
     }
     // Non-test mode: queues start empty and fill naturally via background tasks
     // (try_refill_queues, fill_warm_queue_if_needed, fill_cold_queue_if_needed)
 
     let (h, w, c, d) = scheduler.get_queue_sizes().await;
-    tracing::info!("Scheduler queues: Hot={}, Warm={}, Cold={}, Discovery={}", h, w, c, d);
+    tracing::info!(
+        "Scheduler queues: Hot={}, Warm={}, Cold={}, Discovery={}",
+        h,
+        w,
+        c,
+        d
+    );
 
     let scheduler = Arc::new(scheduler);
     let scanner = Arc::new(scanner);

packages/scanner/src/scanner_loop.rs

@@ -1,10 +1,10 @@
+use crate::scanner::Scanner;
+use nmcscan_shared::repositories::{ServerRepository, StatsRepository};
+use nmcscan_shared::services::scheduler::Scheduler;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicU32, Ordering};
 use tokio::sync::mpsc;
 use tokio::time::{self, Duration};
-use crate::scanner::Scanner;
-use nmcscan_shared::repositories::{ServerRepository, StatsRepository};
-use nmcscan_shared::services::scheduler::Scheduler;
 
 // Background scanner loop with tiered rate limiting and concurrency.
 pub async fn run_scanner_loop(

packages/shared/src/models/asn.rs

@@ -168,7 +168,6 @@ impl AsnManager {
             "fbi",
             "cia",
             "nsa",
-            
             // Education & Healthcare
             "university",
             "college",
@@ -177,7 +176,6 @@ impl AsnManager {
             "hospital",
             "medical",
             "clinic",
-            
             // Critical Infrastructure
             "nuclear",
             "atomic",
@@ -186,7 +184,6 @@ impl AsnManager {
             "financial",
             "securities",
             "reserve",
-            
             // HONEYPOTS & SECURITY RESEARCH (CRITICAL - Must Never Scan)
             "honeypot",
             "honey pot",
@@ -239,19 +236,16 @@ impl AsnManager {
             "research project",
             "security scanner",
             "network monitor",
-            
             // Additional Scanner Organizations (specific names, NOT generic CDN/hosting)
             "sonar research",
             "opendns",
             "umbrella security",
-            
             // Research & Census Projects
             "isc",
             "internet systems consortium",
             "caida",
             "routeviews",
             "ripe ncc",
-            
             // IP Geolocation/Intelligence Services (often used for scanning)
             "maxmind",
             "ip2location",

packages/shared/src/network/login.rs

@@ -19,7 +19,7 @@ use std::io;
 use std::net::SocketAddr;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpStream;
-use tokio::time::{timeout, Duration};
+use tokio::time::{Duration, timeout};
 
 /// The username used for offline login attempts.
 const OFFLINE_USERNAME: &str = "NMCScan";
@@ -547,7 +547,9 @@ pub async fn attempt_login_smart(addr: SocketAddr, protocol_version: i32) -> Log
                 if extracted_protocol != protocol_version {
                     tracing::debug!(
                         "Protocol mismatch detected for {}: extracted protocol {} from '{}', retrying...",
-                        addr, extracted_protocol, reason
+                        addr,
+                        extracted_protocol,
+                        reason
                     );
                     let retry_result = attempt_login(addr, extracted_protocol).await;
 

packages/shared/src/network/slp.rs

@@ -11,7 +11,7 @@ use std::net::SocketAddr;
 use thiserror::Error;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpStream;
-use tokio::time::{timeout, Duration};
+use tokio::time::{Duration, timeout};
 
 const MAX_PACKET_SIZE: usize = 256 * 1024; // 256KB limit for safety