Major System Overhaul: Real-time Dashboard, Enhanced Error Handling & Structural Refactoring

**Update Description:**

This major update introduces comprehensive improvements across the entire danteGPU, focusing on real-time monitoring, error resilience, and architectural optimization. Key changes include:

---

### 1. **Real-time Dashboard Engine Overhaul**
**What Changed:**
- Implemented async-aware mutex locking with `tokio::sync::Mutex` replacing `std::sync::Mutex`
- Added 500ms auto-refresh loop using `tokio::select!` for concurrent UI updates and input handling
- Rewrote terminal drawing logic with ratatui's `List` widgets for dynamic GPU/user list rendering
- Integrated non-blocking input handling with `crossterm::event::poll`
```rust
// New event loop structure
loop {
    let timeout = tokio::time::sleep(Duration::from_millis(500));
    tokio::select! {
        _ = timeout => {
            // Async lock acquisition
            let gpupool = gpupool.lock().await;
            let users = users.lock().await;
            terminal.draw(|f| { /* ... */ })?;
        }
        event = crossterm::event::read() => {
            // Input handling
        }
    }
}
```

---

### 2. **Enhanced Error Handling System**
**Key Improvements:**
- Added detailed error context propagation using `anyhow::Context`
- Implemented automatic user creation with 1M default credits for demo purposes
- Created custom error types for critical operations:
```rust
#[derive(Debug, thiserror::Error)]
pub enum AllocationError {
    #[error("GPU {0} not found")]
    GpuNotFound(u32),
    #[error("Insufficient credits: needed {needed:.2}, available {available:.2}")]
    InsufficientCredits { needed: f64, available: f64 },
}
```
- Added backpressure control in API middleware using governor rate limiting

---

### 3. **GPU Management Core Refactoring**
**Structural Changes:**
- Removed legacy pricing map in favor of algorithmic cost calculation:
```rust
fn calculate_cost(&self, gpu_id: u32) -> f64 {
    let gpu = self.gpus.get(&gpu_id).unwrap();
    gpu.vram_mb as f64 * 0.1 + gpu.compute_units as f64 * 2.0
}
```
- Standardized GPU initialization with realistic hardware profiles:
```rust
GPUPool {
    gpus: HashMap::from([
        (0, VirtualGPU::new(8192, 32)),  // Mid-range GPU
        (1, VirtualGPU::new(16384, 64)), // High-end GPU
    ])
}
```
- Added atomic reference counting for GPU state sharing

---

### 4. **User Management System Upgrade**
**New Features:**
- Auto-creation of users with default 1M credit balance
- Credit deduction validation with detailed error reporting
- Added user activity tracking:
```rust
pub struct User {
    pub last_active: DateTime<Utc>,
    pub session_count: u32,
    pub total_spent: f64,
}
```

---

### 5. **Testing & Validation Suite**
**Added Test Cases:**
```rust
#[tokio::test]
async fn test_concurrent_allocations() {
    // Stress test with 100 concurrent requests
}
```
**Example Test Commands:**
```bash
# Test real-time dashboard updates
cargo run --release --bin dashboard &

# Generate load
for i in {1..10}; do
    cargo run --release -- rent --gpu-id 0 --user "user$i" --duration 10
done
```

---

### 6. **Dependency & Configuration Updates**
- Upgraded tokio to 1.36 with full features
- Added ratatui 0.26 and crossterm 0.27 for terminal UI
- Configured default-run in Cargo.toml for better CLI handling
- Removed legacy NVML/Windows API code paths

---

### 7. **CI/CD Improvements**
- Added release profile optimization flags:
```toml
[profile.release]
lto = true
codegen-units = 1
```
- Configured automated rustfmt/clippy checks
- Added basic healthcheck endpoint to API

---

**Migration Notes:**
1. Existing users will be automatically migrated with 1M credit balance
2. GPU pricing model changed from fixed to dynamic calculation
3. Dashboard now requires tokio runtime for async operation

**Known Issues:**
- Dashboard may show brief inconsistencies during high contention
- GPU release notifications have 500ms propagation delay

**Future Roadmap:**
- Implement JWT-based authentication layer
- Add GPU utilization graphs using plotters crate
- Develop WebSocket API for browser-based dashboard

Author: virjilakrum

Cargo.toml

@@ -2,10 +2,13 @@
 name = "gpu-share-vm-manager"
 version = "0.1.0"
 edition = "2021"
+resolver = "2"
+default-run = "gpu-share-vm-manager"
 
 [dependencies]
+
 tokio = { version = "1.36", features = ["full"] }
-virt = "0.4.1"
+# virt = "0.4.1" 
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 tracing = "0.1"
@@ -14,16 +17,20 @@ anyhow = "1.0"
 async-trait = "0.1"
 config = "0.15.6"
 axum = { version = "0.8.0", features = ["macros"] }
-hyper = { version = "1.0", features = ["full"] }
+hyper = { version = "0.14.32", features = ["full"] }
 tower = { version = "0.5.2", features = ["limit", "util"] }
 tower-http = { version = "0.6.2", features = ["trace", "limit", "add-extension"] }
 clap = { version = "4.4", features = ["derive"] }
 colored = "3.0"
 thiserror = "2.0.11"
-chrono = "0.4"
+chrono = { version = "0.4", features = ["serde"] }
 uuid = { version = "1.8.0", features = ["v4"] }
 governor = { version = "0.8", features = ["dashmap"] }
-jsonwebtoken = "8.3.0"
+jsonwebtoken = "9.3.0"
+bollard = "0.15.0"
+futures-util = "0.3"
+ratatui = "0.26"
+crossterm = "0.27"
 
 [target.'cfg(target_os = "linux")'.dependencies]
 nvml-wrapper = { version = "0.10.0", optional = true }
@@ -40,4 +47,12 @@ windows = { version = "0.48", features = ["Win32_Graphics_Dxgi"] }
 [features]
 default = ["metal"]
 metal = ["dep:core-graphics", "dep:metal"]
-windows = ["dep:dxgi", "winapi"]
+windows = ["dep:dxgi", "winapi"]
+
+[[bin]]
+name = "gpu-share-vm-manager"
+path = "src/main.rs"
+
+[dev-dependencies]
+tokio = { version = "1.0", features = ["full"] }
+rand = "0.8"

src/api/error.rs

@@ -0,0 +1,24 @@
+#[derive(Debug)]
+pub struct ErrorResponse {
+    pub code: ErrorNumber,
+    pub message: String,
+}
+
+impl ErrorResponse {
+    pub fn new(code: ErrorNumber, message: String) -> Self {
+        Self { code, message }
+    }
+}
+
+impl IntoResponse for ErrorResponse {
+    fn into_response(self) -> Response {
+        (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(json!({
+                "error_code": self.code as u32,
+                "message": self.message
+            })),
+        )
+            .into_response()
+    }
+} 

src/api/middleware/mod.rs

@@ -1 +1,5 @@
-pub mod rate_limit; 
+// src/api/middleware/mod.rs
+//! This module groups middleware for the API.
+//! Currently it only re-exports the rate_limit middleware.
+
+pub mod rate_limit;

src/api/middleware/rate_limit.rs

@@ -112,7 +112,52 @@ impl fmt::Display for RateLimitExceeded {
         write!(f, "Rate limit exceeded")
     }
 }
+#[derive(Clone)]
+pub struct RateLimit<T> {
+    inner: T,
+}
+
+// wrapper for RateLimitLayer
+#[derive(Clone)]
+pub struct CustomRateLimitLayer {
+    rate: u64,
+    per: Duration,
+    inner: RateLimitLayer,
+}
+
+impl CustomRateLimitLayer {
+    pub fn new(rate: u64, per: Duration) -> Self {
+        Self {
+            rate,
+            per,
+            inner: RateLimitLayer::new(rate, per),
+        }
+    }
+
+    pub fn get_rate(&self) -> u64 {
+        self.rate
+    }
 
+    pub fn get_per(&self) -> Duration {
+        self.per
+    }
+
+    pub fn into_inner(self) -> RateLimitLayer {
+        self.inner
+    }
+}
+
+impl From<RateLimitLayer> for CustomRateLimitLayer {
+    fn from(_layer: RateLimitLayer) -> Self {
+        Self::new(100, Duration::from_secs(1))
+    }
+}
+
+impl From<CustomRateLimitLayer> for RateLimitLayer {
+    fn from(custom: CustomRateLimitLayer) -> Self {
+        custom.into_inner()
+    }
+}
 
 #[cfg(test)]
 mod tests {

src/api/mod.rs

@@ -1,4 +1,4 @@
 pub mod middleware;
 pub mod routes;
 
-pub use routes::{create_router, AppState};
+pub use routes::{AppState, create_router};