Merge pull request #24 from msalinas92/feature/admin-dedicated-port

Feature: Split Admin & Metrics into a Separate Port

Author: msalinas92

README.md

@@ -70,7 +70,7 @@ This lightweight UI is bundled directly into the binary—no additional server o
 
 Once CacheBolt is running, open:
 
-http://localhost:3000/cb-admin
+http://localhost:3001/admin
 
 ### 🧰 Available Features
 
@@ -171,6 +171,12 @@ The config is written in YAML. Example:
 # 🔧 Unique identifier for this CacheBolt instance
 app_id: my-service
 
+# 🌐 Port to bind the main proxy server (default: 3000)
+proxy_port: 3000
+
+# 🛠️ Port to bind the admin interface and /metrics (default: 3001)
+admin_port: 3001
+
 # 🚦 Maximum number of concurrent outbound requests to the downstream service
 max_concurrent_requests: 200
 
@@ -328,7 +334,7 @@ You can clear the entire cache (both in-memory and persistent storage) using the
 ### ✅ Example: Full cache invalidation
 
 ```bash
-curl -X DELETE "http://localhost:3000/admin/cache?backend=true"
+curl -X DELETE "http://localhost:3001/admin/cache?backend=true"
 ```
 ---
 ## 📊 Memory Cache Status Endpoint
@@ -337,7 +343,7 @@ CacheBolt includes an endpoint to inspect the current in-memory cache state in r
 
 ### 🔍 Endpoint
 ```bash
-curl --location 'http://localhost:3000/admin/status-memory'
+curl --location 'http://localhost:3001/admin/status-memory'
 ```
 
 Returns a JSON object where each key is a hashed cache key, and the value includes metadata:

config.yaml

@@ -1,6 +1,12 @@
 # 🔧 Unique identifier for this CacheBolt instance
 app_id: my-service
 
+# 🌐 Port to bind the main proxy server (default: 3000)
+proxy_port: 3000
+
+# 🛠️ Port to bind the admin interface and /metrics (default: 3001)
+admin_port: 3001
+
 # 🚦 Maximum number of concurrent outbound requests to the downstream service
 max_concurrent_requests: 200
 

src/admin/ui.rs

@@ -20,7 +20,7 @@ use mime_guess::from_path;
 use rust_embed::RustEmbed;
 
 #[derive(RustEmbed)]
-#[folder = "ui/dist/cb-admin/"] // Ruta relativa al Cargo.toml
+#[folder = "ui/dist/admin/"] // Ruta relativa al Cargo.toml
 pub struct EmbeddedAssets;
 
 

src/config.rs

@@ -94,6 +94,24 @@ pub struct Config {
 
     /// Headers to ignore when computing cache keys.
     pub ignored_headers: Option<Vec<String>>,
+
+    /// Port for proxy traffic (default: 3000).
+    #[serde(default = "default_proxy_port")]
+    pub proxy_port: u16,
+
+    /// Port for admin UI and Prometheus metrics (default: 3001).
+    #[serde(default = "default_admin_port")]
+    pub admin_port: u16,
+}
+
+/// Default port for proxy service
+fn default_proxy_port() -> u16 {
+    3000
+}
+
+/// Default port for admin + metrics service
+fn default_admin_port() -> u16 {
+    3001
 }
 
 /// Global, lazily-initialized config object shared across the application.

src/main.rs

@@ -200,28 +200,49 @@ async fn main() {
         .allow_methods([Method::GET, Method::POST, Method::DELETE])
         .allow_headers([header::CONTENT_TYPE]);
 
-    let app = Router::new()
-        .route("/cb-admin/api/cache", delete(invalidate_handler))
-        .route("/cb-admin/api/status", get(get_memory_cache_status))
-        .route("/cb-admin", get(embedded_ui_index))
-        .route("/cb-admin/", get(embedded_ui_index))
-        .route("/cb-admin/*path", get(embedded_ui_handler))
-        .route("/metrics", get(move || async move { handle.render() }))
+    // 8. Build Proxy Router (main traffic)
+    let proxy_router = Router::new()
         .route("/", get(proxy::proxy_handler))
         .route("/*path", get(proxy::proxy_handler))
+        .layer(cors.clone());
+
+    // 9. Build Admin Router (admin + metrics)
+    let admin_router = Router::new()
+        .route("/admin/api/cache", delete(invalidate_handler))
+        .route("/admin/api/status", get(get_memory_cache_status))
+        .route("/admin", get(embedded_ui_index))
+        .route("/admin/", get(embedded_ui_index))
+        .route("/admin/*path", get(embedded_ui_handler))
+        .route("/metrics", get(move || async move { handle.render() }))
         .layer(cors);
 
     // ------------------------------------------------------
-    // 8. Bind the server to all interfaces on port 3000
+    // 10. Bind the server to all interfaces on port 3000
     // ------------------------------------------------------
-    let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
-    info!("🚀 Server listening at http://{}", addr);
+    let config = CONFIG.get().expect("CONFIG must be initialized");
+
+    let proxy_addr = SocketAddr::from(([0, 0, 0, 0], config.proxy_port));
+    let admin_addr = SocketAddr::from(([0, 0, 0, 0], config.admin_port));
+
+    info!("🚀 Proxy listening at http://{}", proxy_addr);
+    info!(
+        "🛠 Admin UI listening at http://{}/admin/ | Metrics at http://{}/metrics",
+        admin_addr, admin_addr
+    );
+
+    // 11. Start both servers concurrently
+    let proxy_server = Server::bind(&proxy_addr).serve(proxy_router.into_make_service());
+    let admin_server = Server::bind(&admin_addr).serve(admin_router.into_make_service());
 
     // ------------------------------------------------------
-    // 9. Start serving HTTP requests using Axum and Hyper
+    // 12. Start serving HTTP requests using Axum and Hyper
     // ------------------------------------------------------
-    Server::bind(&addr)
-        .serve(app.into_make_service())
-        .await
-        .unwrap();
+    let (proxy_result, admin_result) = tokio::join!(proxy_server, admin_server);
+
+    if let Err(e) = proxy_result {
+        error!("❌ Proxy server exited with error: {}", e);
+    }
+    if let Err(e) = admin_result {
+        error!("❌ Admin server exited with error: {}", e);
+    }
 }

tests/test_config.rs

@@ -150,6 +150,8 @@ storage_backend: azure
             },
             storage_backend: StorageBackend::Local,
             ignored_headers: None,
+            proxy_port: 3000,
+            admin_port: 3001,
         };
 
         CONFIG.get_or_init(|| config);

tests/test_memory.rs

@@ -48,7 +48,9 @@ mod tests {
                 }],
             },
             storage_backend: StorageBackend::Local,
-            ignored_headers: None
+            ignored_headers: None,
+            proxy_port: 3000,
+            admin_port: 3001,
         };
 
         // Set config only once

tests/test_proxy.rs

@@ -114,6 +114,8 @@ mod tests {
             },
             storage_backend: StorageBackend::Local,
             ignored_headers: None,
+            proxy_port: 3000,
+            admin_port: 3001
         });
 
         let dummy_request = Request::builder()
@@ -167,6 +169,8 @@ mod tests {
             },
             storage_backend: StorageBackend::Local,
             ignored_headers: None,
+            proxy_port: 3000,
+            admin_port: 3001
         });
 
         let req = Request::builder()
@@ -199,6 +203,8 @@ mod tests {
             },
             storage_backend: StorageBackend::Local,
             ignored_headers: None,
+            proxy_port: 3000,
+            admin_port: 3001
         });
 
         // Saturar manualmente

tests/test_rules.rs

@@ -54,6 +54,8 @@ mod tests {
             },
             storage_backend: StorageBackend::Local,
             ignored_headers: None,
+            proxy_port: 3000,
+            admin_port: 3001
         };
 
         let _ = CONFIG.set(mock_config);
@@ -102,6 +104,8 @@ mod tests {
             },
             storage_backend: StorageBackend::Local,
             ignored_headers: None,
+            proxy_port: 3000,
+            admin_port: 3001
         };
 
         let result = cfg.latency_failover.path_rules.iter().find_map(|rule| {

tests/test_storage.rs

@@ -1,4 +1,3 @@
-
 // Copyright (C) 2025 Matías Salinas ([email protected])
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,20 +15,20 @@
 #[cfg(test)]
 mod tests {
     use super::*;
+    use azure_storage_blobs::blob;
+    use bytes::Bytes;
     use cachebolt::config::{
-        CacheSettings, Config, LatencyFailover, MaxLatencyRule, StorageBackend, CONFIG
+        CONFIG, CacheSettings, Config, LatencyFailover, MaxLatencyRule, StorageBackend,
     };
+    use cachebolt::storage::local::CachedBlob;
     use cachebolt::storage::local::*;
-    use std::fs;
-    use std::path::Path;
-    use azure_storage_blobs::blob;
-    use tokio;
     use flate2::{Compression, read::GzDecoder, write::GzEncoder};
     use serde::Serialize;
-    use bytes::Bytes;
-    use std::io::Write;
     use serde::ser::{Serialize as TraitSerialize, Serializer};
-    use cachebolt::storage::local::CachedBlob;
+    use std::fs;
+    use std::io::Write;
+    use std::path::Path;
+    use tokio;
 
     fn init_config_for_tests() {
         if CONFIG.get().is_none() {
@@ -54,6 +53,8 @@ mod tests {
                 },
                 storage_backend: StorageBackend::Local,
                 ignored_headers: None,
+                proxy_port: 3000,
+                admin_port: 3001,
             };
             let _ = CONFIG.set(config);
         }
@@ -246,7 +247,7 @@ mod tests {
             }
         }
 
-        let blob    = CachedBlob {
+        let blob = CachedBlob {
             body: "SGVsbG8=".to_string(),
             headers: vec![("X-Test".to_string(), "true".to_string())],
         };
@@ -259,7 +260,6 @@ mod tests {
         assert!(result.is_err(), "Expected compression to fail");
     }
 
-
     #[tokio::test]
     async fn test_store_fails_to_write_file_contents() {
         use std::os::unix::fs::PermissionsExt;