confik 0.15.12

Compose configuration from multiple sources without giving up type safety
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use std::{fs, path::PathBuf, sync::OnceLock};

use confik::{Configuration, FileSource, ReloadableConfig};

#[derive(Configuration, Debug)]
struct ServerConfig {
    host: String,
    port: u16,
    max_connections: usize,
}

static CONFIG_PATH: OnceLock<PathBuf> = OnceLock::new();

impl ReloadableConfig for ServerConfig {
    type Error = anyhow::Error;

    fn build() -> Result<Self, Self::Error> {
        let config = Self::builder()
            .override_with(FileSource::new(
                CONFIG_PATH
                    .get()
                    .expect("CONFIG_PATH not initialized")
                    .as_path(),
            ))
            .try_build()?;

        if config.max_connections > 1_000 {
            anyhow::bail!("max_connections must be <= 1000");
        }

        Ok(config)
    }
}

fn main() {
    println!("=== Hot-Reloadable Configuration Example ===\n");

    // Initialize the OnceLock statics
    let config_file = tempfile::Builder::new()
        .suffix(".toml")
        .tempfile()
        .expect("Failed to create temp file");
    let config_path = CONFIG_PATH.get_or_init(|| config_file.path().to_path_buf());

    // Initialize with the first configuration
    fs::write(
        config_path,
        r#"
        host = "localhost"
        port = 8080
        max_connections = 100
        "#,
    )
    .expect("Failed to write initial config");
    println!("Created config file at: {:?}\n", config_path);

    // Create a reloading config using the convenient method
    let config = ServerConfig::reloading().expect("Failed to load initial config");

    // Load and use the current configuration
    let current = config.load();
    println!("Initial configuration:");
    println!("  Host: {}", current.host);
    println!("  Port: {}", current.port);
    println!("  Max Connections: {}", current.max_connections);

    // Add a callback to be notified when config reloads
    let config_with_callback = config.with_on_update(|| {
        println!("✓ Configuration reloaded successfully!");
    });

    // Modify the config file
    println!("\n--- Modifying the config file ---");
    fs::write(
        config_path,
        r#"
        host = "0.0.0.0"
        port = 80
        max_connections = 10
        "#,
    )
    .expect("Failed to write updated config");
    println!("Updated config file with new values");

    println!("\n--- Reloading configuration ---");
    config_with_callback
        .reload()
        .expect("Failed to reload config");

    // The configuration is atomically updated with new values!
    let updated = config_with_callback.load();
    println!("After reload:");
    println!("  Host: {}", updated.host);
    println!("  Port: {}", updated.port);
    println!("  Max Connections: {}", updated.max_connections);

    // Verify the values actually changed
    assert_eq!(updated.host, "0.0.0.0");
    assert_eq!(updated.port, 80);
    assert_eq!(updated.max_connections, 10);
    println!("\n✓ Configuration values changed successfully!");

    // Write invalid config
    fs::write(
        config_path,
        r#"
        host = "localhost"
        port = 8080
        max_connections = 99999999
        "#,
    )
    .expect("Failed to write updated config");
    println!("Updated config file with new values");

    println!("\n--- Reloading configuration ---");
    config_with_callback
        .reload()
        .expect_err("Invalid config rejected");

    // Verify the values actually changed
    assert_eq!(updated.host, "0.0.0.0");
    assert_eq!(updated.port, 80);
    assert_eq!(updated.max_connections, 10);

    println!("\n=== Example complete ===");
}