feat: add global configuration support for module initialization

Author: lowhung

process/src/process.rs

@@ -2,7 +2,7 @@
 //! Loads and runs modules built with caryatid-sdk
 
 use anyhow::{anyhow, Result};
-use caryatid_sdk::config::{config_from_value, get_sub_config};
+use caryatid_sdk::config::{build_module_config, config_from_value, get_sub_config};
 use caryatid_sdk::context::GlobalContext;
 use caryatid_sdk::{Context, MessageBounds, MessageBus, Module, ModuleRegistry};
 use config::Config;
@@ -58,7 +58,7 @@ impl<M: MessageBounds> Process<M> {
             }
         };
 
-        return Ok(BusInfo { id, bus });
+        Ok(BusInfo { id, bus })
     }
 
     /// Create a process with the given config
@@ -78,7 +78,6 @@ impl<M: MessageBounds> Process<M> {
                             Ok(bus) => {
                                 buses.push(Arc::new(bus));
                             }
-
                             _ => {}
                         }
                     }
@@ -112,36 +111,36 @@ impl<M: MessageBounds> Process<M> {
         }
 
         // Initialise all the modules from [module.<id>] configuration
-        if let Ok(mod_confs) = self.config.get_table("module") {
-            for (id, mod_conf) in mod_confs {
-                if let Ok(modt) = mod_conf.into_table() {
-                    let modc = config_from_value(modt);
-                    let mut module_name = id.clone(); // Default
-                    if let Ok(class) = modc.get_string("class") {
-                        module_name = class;
-                    }
-
-                    // Look up the module
-                    if let Some(module) = self.modules.get(&module_name) {
-                        info!("Initialising module {id}");
-                        let message_bus = self.context.message_bus.clone();
-                        let message_bus = if let Some(m) = &mut monitor {
-                            m.spy_on_bus(&module_name, message_bus)
-                        } else {
-                            message_bus
-                        };
-                        let context = Arc::new(Context::new(
-                            self.config.clone(),
-                            message_bus,
-                            self.context.startup_watch.subscribe(),
-                        ));
-                        module.init(context, Arc::new(modc)).await.unwrap();
-                    } else {
-                        error!("Unrecognised module class: {module_name} in [module.{id}]");
-                    }
-                } else {
+        if let Ok(module_cfgs) = self.config.get_table("module") {
+            for (id, module_cfg) in module_cfgs {
+                let Ok(module_tbl) = module_cfg.into_table() else {
                     warn!("Bad configuration for module {id} ignored");
-                }
+                    continue;
+                };
+
+                let module_cfg = build_module_config(&self.config, module_tbl);
+                let module_name = module_cfg.get_string("class").unwrap_or_else(|_| id.clone());
+
+                let Some(module) = self.modules.get(&module_name) else {
+                    error!("Unrecognised module class: {module_name} in [module.{id}]");
+                    continue;
+                };
+
+                info!("Initialising module {id}");
+
+                let message_bus = self.context.message_bus.clone();
+                let message_bus = match &mut monitor {
+                    Some(m) => m.spy_on_bus(&module_name, message_bus),
+                    None => message_bus,
+                };
+
+                let context = Arc::new(Context::new(
+                    self.config.clone(),
+                    message_bus,
+                    self.context.startup_watch.subscribe(),
+                ));
+
+                module.init(context, Arc::new(module_cfg)).await?;
             }
         }
 
@@ -151,9 +150,9 @@ impl<M: MessageBounds> Process<M> {
             tokio::spawn(monitor.monitor());
         }
 
-        // Send startup message if required
+        // Send the startup message if required
         let _ = self.context.startup_watch.send(true);
-        if let Ok(topic) = self.config.get_string("startup.topic") {
+        if let Ok(topic) = self.config.get_string("global.startup.topic") {
             self.context
                 .message_bus
                 .publish(&topic, Arc::new(M::default()))

sdk/src/config.rs

@@ -23,3 +23,120 @@ pub fn config_from_value(map: HashMap<String, config::Value>) -> Config {
     }
     builder.build().unwrap_or_default()
 }
+
+/// Build a module config by merging the `[global]` section with module-specific config.
+///
+/// This allows modules to access shared configuration values defined in `[global.*]`
+/// while still having their own module-specific overrides. Module-specific values
+/// take precedence over global values when keys collide.
+///
+/// # Example TOML structure
+///
+/// ```toml
+/// [global.startup]
+/// method = "default"
+/// topic = "app.startup"
+///
+/// [module.my-module]
+/// some-setting = "value"
+/// ```
+///
+/// The resulting module config will contain both `startup.method` and `some-setting`.
+pub fn build_module_config(
+    root_config: &Config,
+    module_table: HashMap<String, config::Value>,
+) -> Config {
+    Config::builder()
+        .add_source(get_sub_config(root_config, "global"))
+        .add_source(config_from_value(module_table))
+        .build()
+        .unwrap_or_default()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use config::FileFormat;
+
+    fn config_from_toml(toml: &str) -> Config {
+        Config::builder()
+            .add_source(config::File::from_str(toml, FileFormat::Toml))
+            .build()
+            .unwrap()
+    }
+
+    #[test]
+    fn test_get_sub_config_extracts_nested_section() {
+        let config = config_from_toml(
+            r#"
+            [global.startup]
+            method = "custom"
+
+            [global.network]
+            name = "production"
+            "#,
+        );
+
+        let global = get_sub_config(&config, "global");
+
+        assert_eq!(global.get_string("startup.method").unwrap(), "custom");
+        assert_eq!(global.get_string("network.name").unwrap(), "production");
+    }
+
+    #[test]
+    fn test_get_sub_config_returns_empty_for_missing_path() {
+        let config = config_from_toml("[other]\nkey = \"value\"");
+        let sub = get_sub_config(&config, "nonexistent");
+        assert!(sub.get_string("anything").is_err());
+    }
+
+    #[test]
+    fn test_config_from_value_creates_config() {
+        let mut map = HashMap::new();
+        map.insert("key1".to_string(), config::Value::new(None, "value1"));
+        map.insert("key2".to_string(), config::Value::new(None, 42_i64));
+
+        let config = config_from_value(map);
+
+        assert_eq!(config.get_string("key1").unwrap(), "value1");
+        assert_eq!(config.get_int("key2").unwrap(), 42);
+    }
+
+    #[test]
+    fn test_build_module_config_merges_global_and_module() {
+        let root_config = config_from_toml(
+            r#"
+            [global.startup]
+            method = "default"
+            "#,
+        );
+
+        let mut module_table = HashMap::new();
+        module_table.insert("name".to_string(), config::Value::new(None, "my-module"));
+
+        let module_cfg = build_module_config(&root_config, module_table);
+
+        assert_eq!(module_cfg.get_string("startup.method").unwrap(), "default");
+        assert_eq!(module_cfg.get_string("name").unwrap(), "my-module");
+    }
+
+    #[test]
+    fn test_build_module_config_module_overrides_global() {
+        let root_config = config_from_toml(
+            r#"
+            [global]
+            name = "global-default"
+            "#,
+        );
+
+        let mut module_table = HashMap::new();
+        module_table.insert(
+            "name".to_string(),
+            config::Value::new(None, "module-override"),
+        );
+
+        let module_cfg = build_module_config(&root_config, module_table);
+
+        assert_eq!(module_cfg.get_string("name").unwrap(), "module-override");
+    }
+}