Skip to main content

git2db/storage/
registry.rs

1//! Driver registry (Docker's graphdriver pattern)
2//!
3//! Manages driver registration and selection, similar to Docker's
4//! daemon/graphdriver/driver_linux.go
5
6use super::driver::{Driver, DriverError, DriverFactory, StorageDriver};
7use inventory;
8use std::collections::HashMap;
9use std::sync::Arc;
10use tracing::info;
11
12/// Registry of available storage drivers
13///
14/// Follows Docker's pattern for driver discovery and selection.
15pub struct DriverRegistry {
16    drivers: HashMap<String, Arc<dyn Driver>>,
17}
18
19impl DriverRegistry {
20    /// Create a new registry with all available drivers
21    pub fn new() -> Self {
22        let mut drivers: HashMap<String, Arc<dyn Driver>> = HashMap::new();
23
24        // Load drivers from inventory registry
25        for factory in inventory::iter::<DriverFactory> {
26            info!("Registering storage driver: {}", factory.name());
27            drivers.insert(factory.name().to_owned(), factory.get_driver());
28        }
29
30        Self { drivers }
31    }
32
33    /// Get a driver by selection
34    pub fn get_driver(&self, selection: StorageDriver) -> Result<Arc<dyn Driver>, DriverError> {
35        let (name, driver_result) = match selection {
36            StorageDriver::Overlay2 => ("overlay2", self.get("overlay2")),
37            StorageDriver::Reflink => ("reflink", self.get("reflink")),
38            StorageDriver::Vfs => ("vfs", self.get("vfs")),
39        };
40
41        match driver_result {
42            Ok(driver) => {
43                info!("Selected storage driver: {}", name);
44                Ok(driver)
45            }
46            Err(e) => Err(e),
47        }
48    }
49
50    /// Get a driver by name
51    fn get(&self, name: &str) -> Result<Arc<dyn Driver>, DriverError> {
52        self.drivers
53            .get(name)
54            .cloned()
55            .ok_or_else(|| DriverError::NotAvailable(format!("Driver '{name}' not registered")))
56    }
57
58    /// List all registered drivers
59    pub fn list_drivers(&self) -> Vec<String> {
60        self.drivers.keys().cloned().collect()
61    }
62
63    /// List available drivers (registered AND available on this system)
64    pub fn list_available_drivers(&self) -> Vec<String> {
65        self.drivers
66            .values()
67            .filter(|d| d.is_available())
68            .map(|d| d.name().to_owned())
69            .collect()
70    }
71}
72
73impl Default for DriverRegistry {
74    fn default() -> Self {
75        Self::new()
76    }
77}
78
79#[cfg(test)]
80mod tests {
81    use super::*;
82
83    #[test]
84    fn test_registry_creation() {
85        let registry = DriverRegistry::new();
86        let drivers = registry.list_drivers();
87
88        // VFS should always be registered
89        assert!(drivers.contains(&"vfs".to_owned()));
90
91        // Overlay2 only on Linux with feature
92        #[cfg(all(target_os = "linux", feature = "overlayfs"))]
93        assert!(drivers.contains(&"overlay2".to_owned()));
94    }
95
96    #[test]
97    fn test_vfs_always_available() {
98        let registry = DriverRegistry::new();
99        let driver = match registry.get_driver(StorageDriver::Vfs) {
100            Ok(d) => d,
101            Err(e) => panic!("Failed to get VFS driver: {e}"),
102        };
103        assert_eq!(driver.name(), "vfs");
104        assert!(driver.is_available());
105    }
106
107    #[test]
108    #[allow(clippy::print_stdout)]
109    fn test_list_available() {
110        let registry = DriverRegistry::new();
111        let available = registry.list_available_drivers();
112
113        println!("Available drivers:");
114        for name in &available {
115            println!("  - {name}");
116        }
117
118        // At least vfs should be available
119        assert!(!available.is_empty());
120    }
121}