init

src/config/mod.rs

@@ -0,0 +1,5 @@
+mod schema;
+mod store;
+
+pub use schema::*;
+pub use store::ConfigStore;

src/config/schema.rs

@@ -0,0 +1,416 @@
+use serde::{Deserialize, Serialize};
+use typeshare::typeshare;
+
+// Re-export ExtensionsConfig from extensions module
+pub use crate::extensions::ExtensionsConfig;
+
+/// Main application configuration
+#[typeshare]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(default)]
+pub struct AppConfig {
+    /// Whether initial setup has been completed
+    pub initialized: bool,
+    /// Authentication settings
+    pub auth: AuthConfig,
+    /// Video capture settings
+    pub video: VideoConfig,
+    /// HID (keyboard/mouse) settings
+    pub hid: HidConfig,
+    /// Mass Storage Device settings
+    pub msd: MsdConfig,
+    /// ATX power control settings
+    pub atx: AtxConfig,
+    /// Audio settings
+    pub audio: AudioConfig,
+    /// Streaming settings
+    pub stream: StreamConfig,
+    /// Web server settings
+    pub web: WebConfig,
+    /// Extensions settings (ttyd, gostc, easytier)
+    pub extensions: ExtensionsConfig,
+}
+
+impl Default for AppConfig {
+    fn default() -> Self {
+        Self {
+            initialized: false,
+            auth: AuthConfig::default(),
+            video: VideoConfig::default(),
+            hid: HidConfig::default(),
+            msd: MsdConfig::default(),
+            atx: AtxConfig::default(),
+            audio: AudioConfig::default(),
+            stream: StreamConfig::default(),
+            web: WebConfig::default(),
+            extensions: ExtensionsConfig::default(),
+        }
+    }
+}
+
+/// Authentication configuration
+#[typeshare]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(default)]
+pub struct AuthConfig {
+    /// Session timeout in seconds
+    pub session_timeout_secs: u32,
+    /// Enable 2FA
+    pub totp_enabled: bool,
+    /// TOTP secret (encrypted)
+    pub totp_secret: Option<String>,
+}
+
+impl Default for AuthConfig {
+    fn default() -> Self {
+        Self {
+            session_timeout_secs: 3600 * 24, // 24 hours
+            totp_enabled: false,
+            totp_secret: None,
+        }
+    }
+}
+
+/// Video capture configuration
+#[typeshare]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub struct VideoConfig {
+    /// Video device path (e.g., /dev/video0)
+    pub device: Option<String>,
+    /// Video pixel format (e.g., "MJPEG", "YUYV", "NV12")
+    pub format: Option<String>,
+    /// Resolution width
+    pub width: u32,
+    /// Resolution height
+    pub height: u32,
+    /// Frame rate
+    pub fps: u32,
+    /// JPEG quality (1-100)
+    pub quality: u32,
+}
+
+impl Default for VideoConfig {
+    fn default() -> Self {
+        Self {
+            device: None,
+            format: None, // Auto-detect or use MJPEG as default
+            width: 1920,
+            height: 1080,
+            fps: 30,
+            quality: 80,
+        }
+    }
+}
+
+/// HID backend type
+#[typeshare]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum HidBackend {
+    /// USB OTG HID gadget
+    Otg,
+    /// CH9329 serial HID controller
+    Ch9329,
+    /// Disabled
+    None,
+}
+
+impl Default for HidBackend {
+    fn default() -> Self {
+        Self::None
+    }
+}
+
+/// HID configuration
+#[typeshare]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(default)]
+pub struct HidConfig {
+    /// HID backend type
+    pub backend: HidBackend,
+    /// OTG keyboard device path
+    pub otg_keyboard: String,
+    /// OTG mouse device path
+    pub otg_mouse: String,
+    /// OTG UDC (USB Device Controller) name
+    pub otg_udc: Option<String>,
+    /// CH9329 serial port
+    pub ch9329_port: String,
+    /// CH9329 baud rate
+    pub ch9329_baudrate: u32,
+    /// Mouse mode: absolute or relative
+    pub mouse_absolute: bool,
+}
+
+impl Default for HidConfig {
+    fn default() -> Self {
+        Self {
+            backend: HidBackend::None,
+            otg_keyboard: "/dev/hidg0".to_string(),
+            otg_mouse: "/dev/hidg1".to_string(),
+            otg_udc: None,
+            ch9329_port: "/dev/ttyUSB0".to_string(),
+            ch9329_baudrate: 9600,
+            mouse_absolute: true,
+        }
+    }
+}
+
+/// MSD configuration
+#[typeshare]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(default)]
+pub struct MsdConfig {
+    /// Enable MSD functionality
+    pub enabled: bool,
+    /// Storage path for ISO/IMG images
+    pub images_path: String,
+    /// Path for Ventoy bootable drive file
+    pub drive_path: String,
+    /// Ventoy drive size in MB (minimum 1024 MB / 1 GB)
+    pub virtual_drive_size_mb: u32,
+}
+
+impl Default for MsdConfig {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            images_path: "./data/msd/images".to_string(),
+            drive_path: "./data/msd/ventoy.img".to_string(),
+            virtual_drive_size_mb: 16 * 1024, // 16GB default
+        }
+    }
+}
+
+// Re-export ATX types from atx module for configuration
+pub use crate::atx::{ActiveLevel, AtxDriverType, AtxKeyConfig, AtxLedConfig};
+
+/// ATX power control configuration
+///
+/// Each ATX action (power, reset) can be independently configured with its own
+/// hardware binding using the four-tuple: (driver, device, pin, active_level).
+#[typeshare]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(default)]
+pub struct AtxConfig {
+    /// Enable ATX functionality
+    pub enabled: bool,
+    /// Power button configuration (used for both short and long press)
+    pub power: AtxKeyConfig,
+    /// Reset button configuration
+    pub reset: AtxKeyConfig,
+    /// LED sensing configuration (optional)
+    pub led: AtxLedConfig,
+    /// Network interface for WOL packets (empty = auto)
+    pub wol_interface: String,
+}
+
+impl Default for AtxConfig {
+    fn default() -> Self {
+        Self {
+            enabled: false,
+            power: AtxKeyConfig::default(),
+            reset: AtxKeyConfig::default(),
+            led: AtxLedConfig::default(),
+            wol_interface: String::new(),
+        }
+    }
+}
+
+impl AtxConfig {
+    /// Convert to AtxControllerConfig for the controller
+    pub fn to_controller_config(&self) -> crate::atx::AtxControllerConfig {
+        crate::atx::AtxControllerConfig {
+            enabled: self.enabled,
+            power: self.power.clone(),
+            reset: self.reset.clone(),
+            led: self.led.clone(),
+        }
+    }
+}
+
+/// Audio configuration
+///
+/// Note: Sample rate is fixed at 48000Hz and channels at 2 (stereo).
+/// These are optimal for Opus encoding and match WebRTC requirements.
+#[typeshare]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(default)]
+pub struct AudioConfig {
+    /// Enable audio capture
+    pub enabled: bool,
+    /// ALSA device name
+    pub device: String,
+    /// Audio quality preset: "voice", "balanced", "high"
+    pub quality: String,
+}
+
+impl Default for AudioConfig {
+    fn default() -> Self {
+        Self {
+            enabled: false,
+            device: "default".to_string(),
+            quality: "balanced".to_string(),
+        }
+    }
+}
+
+/// Stream mode
+#[typeshare]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum StreamMode {
+    /// WebRTC with H264/H265
+    WebRTC,
+    /// MJPEG over HTTP
+    Mjpeg,
+}
+
+impl Default for StreamMode {
+    fn default() -> Self {
+        Self::Mjpeg
+    }
+}
+
+/// Encoder type
+#[typeshare]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum EncoderType {
+    /// Auto-detect best encoder
+    Auto,
+    /// Software encoder (libx264)
+    Software,
+    /// VAAPI hardware encoder
+    Vaapi,
+    /// NVIDIA NVENC hardware encoder
+    Nvenc,
+    /// Intel Quick Sync hardware encoder
+    Qsv,
+    /// AMD AMF hardware encoder
+    Amf,
+    /// Rockchip MPP hardware encoder
+    Rkmpp,
+    /// V4L2 M2M hardware encoder
+    V4l2m2m,
+}
+
+impl Default for EncoderType {
+    fn default() -> Self {
+        Self::Auto
+    }
+}
+
+impl EncoderType {
+    /// Convert to EncoderBackend for registry queries
+    pub fn to_backend(&self) -> Option<crate::video::encoder::registry::EncoderBackend> {
+        use crate::video::encoder::registry::EncoderBackend;
+        match self {
+            EncoderType::Auto => None,
+            EncoderType::Software => Some(EncoderBackend::Software),
+            EncoderType::Vaapi => Some(EncoderBackend::Vaapi),
+            EncoderType::Nvenc => Some(EncoderBackend::Nvenc),
+            EncoderType::Qsv => Some(EncoderBackend::Qsv),
+            EncoderType::Amf => Some(EncoderBackend::Amf),
+            EncoderType::Rkmpp => Some(EncoderBackend::Rkmpp),
+            EncoderType::V4l2m2m => Some(EncoderBackend::V4l2m2m),
+        }
+    }
+
+    /// Get display name for UI
+    pub fn display_name(&self) -> &'static str {
+        match self {
+            EncoderType::Auto => "Auto (Recommended)",
+            EncoderType::Software => "Software (CPU)",
+            EncoderType::Vaapi => "VAAPI",
+            EncoderType::Nvenc => "NVIDIA NVENC",
+            EncoderType::Qsv => "Intel Quick Sync",
+            EncoderType::Amf => "AMD AMF",
+            EncoderType::Rkmpp => "Rockchip MPP",
+            EncoderType::V4l2m2m => "V4L2 M2M",
+        }
+    }
+}
+
+/// Streaming configuration
+#[typeshare]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(default)]
+pub struct StreamConfig {
+    /// Stream mode
+    pub mode: StreamMode,
+    /// Encoder type for H264/H265
+    pub encoder: EncoderType,
+    /// Target bitrate in kbps (for H264/H265)
+    pub bitrate_kbps: u32,
+    /// GOP size
+    pub gop_size: u32,
+    /// Custom STUN server (e.g., "stun:stun.l.google.com:19302")
+    pub stun_server: Option<String>,
+    /// Custom TURN server (e.g., "turn:turn.example.com:3478")
+    pub turn_server: Option<String>,
+    /// TURN username
+    pub turn_username: Option<String>,
+    /// TURN password (stored encrypted in DB, not exposed via API)
+    pub turn_password: Option<String>,
+    /// Auto-pause when no clients connected
+    #[typeshare(skip)]
+    pub auto_pause_enabled: bool,
+    /// Auto-pause delay (seconds)
+    #[typeshare(skip)]
+    pub auto_pause_delay_secs: u64,
+    /// Client timeout for cleanup (seconds)
+    #[typeshare(skip)]
+    pub client_timeout_secs: u64,
+}
+
+impl Default for StreamConfig {
+    fn default() -> Self {
+        Self {
+            mode: StreamMode::Mjpeg,
+            encoder: EncoderType::Auto,
+            bitrate_kbps: 8000,
+            gop_size: 30,
+            stun_server: Some("stun:stun.l.google.com:19302".to_string()),
+            turn_server: None,
+            turn_username: None,
+            turn_password: None,
+            auto_pause_enabled: false,
+            auto_pause_delay_secs: 10,
+            client_timeout_secs: 30,
+        }
+    }
+}
+
+/// Web server configuration
+#[typeshare]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(default)]
+pub struct WebConfig {
+    /// HTTP port
+    pub http_port: u16,
+    /// HTTPS port
+    pub https_port: u16,
+    /// Bind address
+    pub bind_address: String,
+    /// Enable HTTPS
+    pub https_enabled: bool,
+    /// Custom SSL certificate path
+    pub ssl_cert_path: Option<String>,
+    /// Custom SSL key path
+    pub ssl_key_path: Option<String>,
+}
+
+impl Default for WebConfig {
+    fn default() -> Self {
+        Self {
+            http_port: 8080,
+            https_port: 8443,
+            bind_address: "0.0.0.0".to_string(),
+            https_enabled: false,
+            ssl_cert_path: None,
+            ssl_key_path: None,
+        }
+    }
+}

src/config/store.rs

@@ -0,0 +1,264 @@
+use arc_swap::ArcSwap;
+use sqlx::{sqlite::SqlitePoolOptions, Pool, Sqlite};
+use std::path::Path;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::broadcast;
+
+use super::AppConfig;
+use crate::error::{AppError, Result};
+
+/// Configuration store backed by SQLite
+///
+/// Uses `ArcSwap` for lock-free reads, providing high performance
+/// for frequent configuration access in hot paths.
+#[derive(Clone)]
+pub struct ConfigStore {
+    pool: Pool<Sqlite>,
+    /// Lock-free cache using ArcSwap for zero-cost reads
+    cache: Arc<ArcSwap<AppConfig>>,
+    change_tx: broadcast::Sender<ConfigChange>,
+}
+
+/// Configuration change event
+#[derive(Debug, Clone)]
+pub struct ConfigChange {
+    pub key: String,
+}
+
+impl ConfigStore {
+    /// Create a new configuration store
+    pub async fn new(db_path: &Path) -> Result<Self> {
+        // Ensure parent directory exists
+        if let Some(parent) = db_path.parent() {
+            tokio::fs::create_dir_all(parent).await?;
+        }
+
+        let db_url = format!("sqlite:{}?mode=rwc", db_path.display());
+
+        let pool = SqlitePoolOptions::new()
+            // SQLite uses single-writer mode, 2 connections is sufficient for embedded devices
+            // One for reads, one for writes to avoid blocking
+            .max_connections(2)
+            // Set reasonable timeouts for embedded environments
+            .acquire_timeout(Duration::from_secs(5))
+            .idle_timeout(Duration::from_secs(300))
+            .connect(&db_url)
+            .await?;
+
+        // Initialize database schema
+        Self::init_schema(&pool).await?;
+
+        // Load or create default config
+        let config = Self::load_config(&pool).await?;
+        let cache = Arc::new(ArcSwap::from_pointee(config));
+
+        let (change_tx, _) = broadcast::channel(16);
+
+        Ok(Self {
+            pool,
+            cache,
+            change_tx,
+        })
+    }
+
+    /// Initialize database schema
+    async fn init_schema(pool: &Pool<Sqlite>) -> Result<()> {
+        sqlx::query(
+            r#"
+            CREATE TABLE IF NOT EXISTS config (
+                key TEXT PRIMARY KEY,
+                value TEXT NOT NULL,
+                updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+            )
+            "#,
+        )
+        .execute(pool)
+        .await?;
+
+        sqlx::query(
+            r#"
+            CREATE TABLE IF NOT EXISTS users (
+                id TEXT PRIMARY KEY,
+                username TEXT NOT NULL UNIQUE,
+                password_hash TEXT NOT NULL,
+                is_admin INTEGER NOT NULL DEFAULT 0,
+                created_at TEXT NOT NULL DEFAULT (datetime('now')),
+                updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+            )
+            "#,
+        )
+        .execute(pool)
+        .await?;
+
+        sqlx::query(
+            r#"
+            CREATE TABLE IF NOT EXISTS sessions (
+                id TEXT PRIMARY KEY,
+                user_id TEXT NOT NULL,
+                created_at TEXT NOT NULL DEFAULT (datetime('now')),
+                expires_at TEXT NOT NULL,
+                data TEXT
+            )
+            "#,
+        )
+        .execute(pool)
+        .await?;
+
+        sqlx::query(
+            r#"
+            CREATE TABLE IF NOT EXISTS api_tokens (
+                id TEXT PRIMARY KEY,
+                name TEXT NOT NULL,
+                token_hash TEXT NOT NULL,
+                permissions TEXT NOT NULL,
+                expires_at TEXT,
+                created_at TEXT NOT NULL DEFAULT (datetime('now')),
+                last_used TEXT
+            )
+            "#,
+        )
+        .execute(pool)
+        .await?;
+
+        Ok(())
+    }
+
+    /// Load configuration from database
+    async fn load_config(pool: &Pool<Sqlite>) -> Result<AppConfig> {
+        let row: Option<(String,)> = sqlx::query_as(
+            "SELECT value FROM config WHERE key = 'app_config'"
+        )
+        .fetch_optional(pool)
+        .await?;
+
+        match row {
+            Some((json,)) => {
+                serde_json::from_str(&json).map_err(|e| AppError::Config(e.to_string()))
+            }
+            None => {
+                // Create default config
+                let config = AppConfig::default();
+                Self::save_config_to_db(pool, &config).await?;
+                Ok(config)
+            }
+        }
+    }
+
+    /// Save configuration to database
+    async fn save_config_to_db(pool: &Pool<Sqlite>, config: &AppConfig) -> Result<()> {
+        let json = serde_json::to_string(config)?;
+
+        sqlx::query(
+            r#"
+            INSERT INTO config (key, value, updated_at)
+            VALUES ('app_config', ?1, datetime('now'))
+            ON CONFLICT(key) DO UPDATE SET value = ?1, updated_at = datetime('now')
+            "#,
+        )
+        .bind(&json)
+        .execute(pool)
+        .await?;
+
+        Ok(())
+    }
+
+    /// Get current configuration (lock-free, zero-copy)
+    ///
+    /// Returns an `Arc<AppConfig>` for efficient sharing without cloning.
+    /// This is a lock-free operation with minimal overhead.
+    pub fn get(&self) -> Arc<AppConfig> {
+        self.cache.load_full()
+    }
+
+    /// Set entire configuration
+    pub async fn set(&self, config: AppConfig) -> Result<()> {
+        Self::save_config_to_db(&self.pool, &config).await?;
+        self.cache.store(Arc::new(config));
+
+        // Notify subscribers
+        let _ = self.change_tx.send(ConfigChange {
+            key: "app_config".to_string(),
+        });
+
+        Ok(())
+    }
+
+    /// Update configuration with a closure
+    ///
+    /// Note: This uses a read-modify-write pattern. For concurrent updates,
+    /// the last write wins. This is acceptable for configuration changes
+    /// which are infrequent and typically user-initiated.
+    pub async fn update<F>(&self, f: F) -> Result<()>
+    where
+        F: FnOnce(&mut AppConfig),
+    {
+        // Load current config, clone it for modification
+        let current = self.cache.load();
+        let mut config = (**current).clone();
+        f(&mut config);
+
+        // Persist to database first
+        Self::save_config_to_db(&self.pool, &config).await?;
+
+        // Then update cache atomically
+        self.cache.store(Arc::new(config));
+
+        // Notify subscribers
+        let _ = self.change_tx.send(ConfigChange {
+            key: "app_config".to_string(),
+        });
+
+        Ok(())
+    }
+
+    /// Subscribe to configuration changes
+    pub fn subscribe(&self) -> broadcast::Receiver<ConfigChange> {
+        self.change_tx.subscribe()
+    }
+
+    /// Check if system is initialized (lock-free)
+    pub fn is_initialized(&self) -> bool {
+        self.cache.load().initialized
+    }
+
+    /// Get database pool for session management
+    pub fn pool(&self) -> &Pool<Sqlite> {
+        &self.pool
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[tokio::test]
+    async fn test_config_store() {
+        let dir = tempdir().unwrap();
+        let db_path = dir.path().join("test.db");
+
+        let store = ConfigStore::new(&db_path).await.unwrap();
+
+        // Check default config (now lock-free, no await needed)
+        let config = store.get();
+        assert!(!config.initialized);
+
+        // Update config
+        store.update(|c| {
+            c.initialized = true;
+            c.web.http_port = 9000;
+        }).await.unwrap();
+
+        // Verify update
+        let config = store.get();
+        assert!(config.initialized);
+        assert_eq!(config.web.http_port, 9000);
+
+        // Create new store instance and verify persistence
+        let store2 = ConfigStore::new(&db_path).await.unwrap();
+        let config = store2.get();
+        assert!(config.initialized);
+        assert_eq!(config.web.http_port, 9000);
+    }
+}