feat: implement configurable system-wide TTLs and blacklist support via /etc/contextd/config.toml

Author: shanefagan

Cargo.lock

@@ -20,6 +20,8 @@ serde_derive = "1.0"
 rusqlite = { version = "0.39", features = ["bundled"] }
 sysinfo = "0.30"
 libc = "0.2"
+toml = "1.1.2"
+once_cell = "1.21.4"
 
 [build-dependencies]
 varlink_generator = "13.0"

Cargo.toml

@@ -19,5 +19,5 @@
 
 ## Phase 7: Refinement & Security Hardening
 - [ ] **Systemd Peer Validation**: Use `SO_PEERCRED` to identify calling services and apply granular access control based on systemd units.
-- [ ] **Configuration Overrides**: Support `/etc/contextd/config.toml` for manual TTL tuning and process blacklisting.
+- [x] **Configuration Overrides**: Implemented `src/config.rs` with `/etc/contextd/config.toml` support for TTLs and blacklisting.
 - [ ] **Arch Linux PKGBUILD**: Finalize the AUR package for the 1.0 release.

docs/todo.md

@@ -0,0 +1,16 @@
+# contextd configuration file
+# Place this at /etc/contextd/config.toml
+
+[ttls]
+# TTL for active game detection in seconds (default 5)
+games = 5
+# TTL for hardware inventory in seconds (default 10)
+hardware = 10
+# TTL for system diagnostics in seconds (default 300)
+diagnostics = 300
+
+[blacklist]
+# Process names to ignore in game detection
+# processes = ["Calculator"]
+# Hardware paths (udev paths) to ignore
+# devices = ["/sys/devices/virtual/input/input231"]

examples/config.sample.toml

@@ -0,0 +1,71 @@
+//! Configuration management for contextd
+//!
+//! Handles loading and parsing the /etc/contextd/config.toml file.
+
+use once_cell::sync::Lazy;
+use serde::Deserialize;
+use std::fs;
+
+/// Global configuration instance
+pub static CONFIG: Lazy<Config> = Lazy::new(Config::load);
+
+/// Main configuration structure
+#[derive(Debug, Deserialize, Clone, Default)]
+pub struct Config {
+    #[serde(default)]
+    pub ttls: TtlConfig,
+    #[serde(default)]
+    pub blacklist: BlacklistConfig,
+}
+
+/// TTL settings for various detectors (in seconds)
+#[derive(Debug, Deserialize, Clone)]
+pub struct TtlConfig {
+    /// TTL for active game detection (default 5s)
+    pub games: u64,
+    /// TTL for hardware inventory (default 10s)
+    pub hardware: u64,
+    /// TTL for system diagnostics (default 300s / 5m)
+    pub diagnostics: u64,
+}
+
+impl Default for TtlConfig {
+    fn default() -> Self {
+        Self {
+            games: 5,
+            hardware: 10,
+            diagnostics: 300,
+        }
+    }
+}
+
+/// Blacklist settings for ignoring specific items
+#[derive(Debug, Deserialize, Clone, Default)]
+pub struct BlacklistConfig {
+    /// Process names to ignore in game detection
+    pub processes: Vec<String>,
+    /// Hardware paths (udev paths) to ignore
+    pub devices: Vec<String>,
+}
+
+impl Config {
+    /// Loads the configuration from /etc/contextd/config.toml,
+    /// falling back to defaults if the file is missing or invalid.
+    fn load() -> Self {
+        let paths = ["/etc/contextd/config.toml", "config.toml"];
+
+        for path in paths {
+            if let Ok(content) = fs::read_to_string(path) {
+                if let Ok(config) = toml::from_str(&content) {
+                    log::info!("Loaded configuration from {}", path);
+                    return config;
+                } else {
+                    log::warn!("Failed to parse configuration at {}, using defaults", path);
+                }
+            }
+        }
+
+        log::debug!("No configuration file found, using defaults");
+        Self::default()
+    }
+}

src/config.rs

@@ -32,8 +32,9 @@ impl DiagnosticsManager {
             .unwrap()
             .as_secs() as i64;
 
+        let ttl = crate::config::CONFIG.ttls.diagnostics as i64;
         let needs_refresh = if let Some(ref diag) = self.cached_diagnostics {
-            now - diag.last_updated > 300 // 5 minutes cache
+            now - diag.last_updated > ttl
         } else {
             true
         };

src/detectors/diagnostics/manager.rs

@@ -1,8 +1,7 @@
 use super::{Game, GameDetector};
+use crate::config::CONFIG;
 use std::time::{Duration, Instant};
 
-const CACHE_DURATION: Duration = Duration::from_secs(5);
-
 pub struct GameManager {
     detectors: Vec<Box<dyn GameDetector>>,
     installed_cache: Option<(Vec<Game>, Instant)>,
@@ -24,8 +23,9 @@ impl GameManager {
     }
 
     pub fn list_all_installed(&mut self) -> Vec<Game> {
+        let ttl = Duration::from_secs(CONFIG.ttls.games);
         if let Some((cache, ts)) = &self.installed_cache
-            && ts.elapsed() < CACHE_DURATION
+            && ts.elapsed() < ttl
         {
             return cache.clone();
         }
@@ -34,20 +34,26 @@ impl GameManager {
             .detectors
             .iter()
             .flat_map(|d| d.list_installed())
+            .filter(|g| !CONFIG.blacklist.processes.contains(&g.name))
             .collect();
 
         self.installed_cache = Some((games.clone(), Instant::now()));
         games
     }
 
     pub fn get_active_game(&mut self) -> Option<Game> {
+        let ttl = Duration::from_secs(CONFIG.ttls.games);
         if let Some((cache, ts)) = &self.active_cache
-            && ts.elapsed() < CACHE_DURATION
+            && ts.elapsed() < ttl
         {
             return cache.clone();
         }
 
-        let game = self.detectors.iter().flat_map(|d| d.list_running()).next();
+        let game = self
+            .detectors
+            .iter()
+            .flat_map(|d| d.list_running())
+            .find(|g| !CONFIG.blacklist.processes.contains(&g.name));
 
         self.active_cache = Some((game.clone(), Instant::now()));
         game

src/detectors/games/manager.rs

@@ -1,8 +1,7 @@
 use super::{Device, HardwareDetector};
+use crate::config::CONFIG;
 use std::time::{Duration, Instant};
 
-const CACHE_DURATION: Duration = Duration::from_secs(10); // Hardware changes less often
-
 pub struct HardwareManager {
     detectors: Vec<Box<dyn HardwareDetector>>,
     cache: Option<(Vec<Device>, Instant)>,
@@ -32,8 +31,9 @@ impl HardwareManager {
     }
 
     pub fn list_all_devices(&mut self) -> Vec<Device> {
+        let ttl = Duration::from_secs(CONFIG.ttls.hardware);
         if let Some((cache, ts)) = &self.cache
-            && ts.elapsed() < CACHE_DURATION
+            && ts.elapsed() < ttl
         {
             return cache.clone();
         }
@@ -42,6 +42,7 @@ impl HardwareManager {
             .detectors
             .iter()
             .flat_map(|d| d.list_devices())
+            .filter(|d| !CONFIG.blacklist.devices.contains(&d.path))
             .filter(|d| self.is_gaming_device(d))
             .collect();
 
@@ -50,8 +51,9 @@ impl HardwareManager {
     }
 
     pub fn list_rgb_devices(&mut self) -> Vec<Device> {
+        let ttl = Duration::from_secs(CONFIG.ttls.hardware);
         if let Some((cache, ts)) = &self.rgb_cache
-            && ts.elapsed() < CACHE_DURATION
+            && ts.elapsed() < ttl
         {
             return cache.clone();
         }
@@ -60,6 +62,7 @@ impl HardwareManager {
             .detectors
             .iter()
             .flat_map(|d| d.list_devices())
+            .filter(|d| !CONFIG.blacklist.devices.contains(&d.path))
             .filter(|d| self.is_rgb_device(d))
             .collect();
 

src/detectors/hardware/manager.rs

@@ -8,6 +8,7 @@ mod contextd {
     #![allow(clippy::all, non_snake_case, non_camel_case_types, unused_imports)]
     include!(concat!(env!("OUT_DIR"), "/contextd.rs"));
 }
+mod config;
 mod detectors;
 
 mod service;