distributed-config 0.1.0

A robust configuration management library for Rust applications running in distributed environments
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

//! Configuration sources for loading configuration from various locations

use crate::error::Result;
use crate::value::ConfigValue;
use async_trait::async_trait;
use std::collections::HashMap;

pub mod env;
pub mod file;
pub mod remote;

pub use env::EnvSource;
pub use file::FileSource;
pub use remote::RemoteSource;

/// Trait for configuration sources
#[async_trait]
pub trait ConfigSource: Send + Sync {
    /// Load configuration from this source
    async fn load(&self) -> Result<ConfigValue>;

    /// Get the name of this source (for debugging/logging)
    fn name(&self) -> &str;

    /// Check if this source supports watching for changes
    fn supports_watching(&self) -> bool {
        false
    }

    /// Start watching for changes (if supported)
    async fn start_watching(&self) -> Result<tokio::sync::mpsc::Receiver<ConfigValue>> {
        Err(crate::error::ConfigError::Other(
            "Watching not supported by this source".to_string(),
        ))
    }
}

/// A source that combines multiple configuration sources
pub struct CompositeSource {
    sources: Vec<(Box<dyn ConfigSource>, u32)>, // (source, priority)
    name: String,
}

impl CompositeSource {
    /// Create a new composite source
    pub fn new(name: String) -> Self {
        Self {
            sources: Vec::new(),
            name,
        }
    }

    /// Add a source with priority (higher number = higher priority)
    pub fn add_source(mut self, source: Box<dyn ConfigSource>, priority: u32) -> Self {
        self.sources.push((source, priority));
        self.sources.sort_by(|a, b| a.1.cmp(&b.1)); // Sort by priority
        self
    }
}

#[async_trait]
impl ConfigSource for CompositeSource {
    async fn load(&self) -> Result<ConfigValue> {
        let mut merged_config = ConfigValue::Object(HashMap::new());

        // Load from all sources in priority order (lowest to highest)
        for (source, _priority) in &self.sources {
            let config = source.load().await?;
            merged_config.merge(config);
        }

        Ok(merged_config)
    }

    fn name(&self) -> &str {
        &self.name
    }

    fn supports_watching(&self) -> bool {
        self.sources
            .iter()
            .any(|(source, _)| source.supports_watching())
    }
}

/// Helper function to merge two ConfigValue objects
pub fn merge_config_values(mut base: ConfigValue, overlay: ConfigValue) -> ConfigValue {
    base.merge(overlay);
    base
}