add multiOS usecase for platform agnostic system

Author: virjilakrum

.github/workflows/build.yml

@@ -0,0 +1,6 @@
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }} 

Cargo.toml

@@ -25,6 +25,17 @@ uuid = { version = "1.8.0", features = ["v4"] }
 libvirt = "0.1.0"
 governor = { version = "0.8.0", features = ["std", "nohashmap"] }
 
+[target.'cfg(target_os = "linux")'.dependencies]
+libvirt = "0.1.0"
+
+[target.'cfg(target_os = "macos")'.dependencies]
+core-graphics = "0.24.0"
+metal = { version = "0.31.0", features = ["private"] }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+winapi = { version = "0.3", features = ["dxgi", "d3dcommon"] }
+dxgi = "0.1.7"
+
 [lib]
 name = "gpu_share_vm_manager"
 path = "src/lib.rs"

docs/platform_support.md

@@ -0,0 +1,8 @@
+## Platform Feature Matrix
+
+| Feature         | Linux | MacOS | Windows |
+|-----------------|-------|-------|---------|
+| GPU Passthrough | ✅    | ❌    | ⚠️ WSL2 |
+| KVM Acceleration| ✅    | ❌    | ❌      |
+| Metal API       | ❌    | ✅    | ❌      |
+| DirectX 12      | ❌    | ❌    | ✅      | 

src/api/routes.rs

@@ -79,6 +79,7 @@ use crate::core::vm::{VMStatus, VMConfig};
 use crate::gpu::device::{GPUManager, GPUDevice, GPUConfig};
 use crate::monitoring::metrics::{MetricsCollector, ResourceMetrics};
 use crate::api::middleware::rate_limit::{rate_limit_layer, GlobalRateLimit, RateLimitExceeded};
+use crate::utils::os::{current_platform};
 
 fn handle_error(err: impl std::fmt::Display) -> StatusCode {
     error!("Operation failed: {}", err);
@@ -200,6 +201,26 @@ async fn create_vm(
         disk_size_gb: params.disk_size_gb.unwrap_or(20),
     };
 
+    #[cfg(target_os = "linux")]
+    {
+        // Linux-specific VM creation
+    }
+    
+    #[cfg(target_os = "macos")]
+    {
+        // MacOS hypervisor framework usage
+    }
+    
+    #[cfg(target_os = "windows")]
+    {
+        // Hyper-V integration
+    }
+    
+    #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+    {
+        return Err(Error::UnsupportedPlatform(current_platform().to_string()));
+    }
+
     let vm = libvirt.create_vm(&config).await
         .map_err(handle_error)?;
 

src/core/libvirt.rs

@@ -15,8 +15,17 @@ pub struct LibvirtManager {
 impl LibvirtManager {
     // hehe connect me senpai! ^_^
     pub fn new() -> Result<Self> {
+        #[cfg(target_os = "linux")]
+        let uri = "qemu:///system";
+        
+        #[cfg(target_os = "macos")]
+        let uri = "qemu:///session";
+        
+        #[cfg(target_os = "windows")]
+        let uri = "qemu:///system";
+
         info!("Initializing libvirt connection - let the show begin!");
-        let conn = Connect::open(Some("qemu:///system"))?;
+        let conn = Connect::open(Some(uri))?;
         Ok(Self { conn })
     }
 

src/errors/mod.rs

@@ -76,6 +76,17 @@ pub enum GpuError {
         message: String,
         driver_name: String,
     },
+
+    #[cfg(target_os = "macos")]
+    #[error("Metal API error: {0}")]
+    MetalError(String),
+    
+    #[cfg(target_os = "windows")]
+    #[error("DXGI error: {0}")]
+    DxgiError(#[from] dxgi::Error),
+    
+    #[error("Unsupported operation on {0}")]
+    UnsupportedPlatform(String),
 }
 
 #[derive(Debug)]

src/gpu/device.rs

@@ -194,4 +194,40 @@ fn read_gpu_temperature(path: &Path) -> Result<f64> {
 fn read_gpu_utilization(path: &Path) -> Result<f64> {
     let util_str = fs::read_to_string(path.join("gpu_busy_percent"))?.trim().to_string();
     Ok(util_str.parse()?)
+}
+
+#[cfg(target_os = "linux")]
+fn get_gpu_info() -> Result<Vec<GPUDevice>> {
+    // Linux-specific implementation using sysfs
+    Ok(Vec::new())
+}
+
+#[cfg(target_os = "macos")]
+fn get_gpu_info() -> Result<Vec<GPUDevice>> {
+    use core_graphics::display::CGDisplay;
+    let mut gpus = Vec::new();
+    for display in CGDisplay::active_displays()? {
+        gpus.push(GPUDevice {
+            id: format!("display-{}", display),
+            vendor_id: "Apple".into(),
+            // MacOS specific GPU info
+        });
+    }
+    Ok(gpus)
+}
+
+#[cfg(target_os = "windows")]
+fn get_gpu_info() -> Result<Vec<GPUDevice>> {
+    // Windows implementation using DXGI
+    use dxgi::Factory;
+    let factory = Factory::new()?;
+    let mut gpus = Vec::new();
+    for adapter in factory.adapters() {
+        gpus.push(GPUDevice {
+            id: adapter.get_info().name,
+            vendor_id: "NVIDIA/AMD/Intel".into(),
+            // Windows specific data
+        });
+    }
+    Ok(gpus)
 }

src/macros.rs

@@ -0,0 +1,15 @@
+#[macro_export]
+macro_rules! platform_require {
+    (linux) => {
+        #[cfg(not(target_os = "linux"))]
+        compile_error!("This feature is only available on Linux");
+    };
+    (macos) => {
+        #[cfg(not(target_os = "macos"))]
+        compile_error!("This feature is only available on macOS");
+    };
+    (windows) => {
+        #[cfg(not(target_os = "windows"))]
+        compile_error!("This feature is only available on Windows");
+    };
+} 

src/utils/os.rs

@@ -0,0 +1,21 @@
+#[cfg(target_os = "linux")]
+pub fn current_platform() -> Platform {
+    Platform::Linux
+}
+
+#[cfg(target_os = "macos")]
+pub fn current_platform() -> Platform {
+    Platform::MacOS
+}
+
+#[cfg(target_os = "windows")]
+pub fn current_platform() -> Platform {
+    Platform::Windows
+}
+
+pub enum Platform {
+    Linux,
+    MacOS,
+    Windows,
+    Unknown,
+}