live 0.4.4

A modular configuration framework with live reloading and atomic, format-agnostic updates.
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

/* examples/live_dir.rs */

//! Example: Directory-based configuration with LiveDir
//!
//! This example demonstrates:
//! - Scanning a directory for configuration files
//! - Pattern-based key extraction (bracketed ports like [443])
//! - Live reloading when files change
//!
//! Run with: cargo run --example live_dir --features full

use live::controller::{KeyPattern, LiveDir, ScanMode};
use live::holder::Store;
use live::loader::{DynLoader, FileSource, PreProcess, format::AnyFormat};
use live::signal::Config as WatcherConfig;
use serde::Deserialize;
use std::fs;
use std::sync::Arc;
use std::time::Duration;
use validator::Validate;

#[derive(Debug, Clone, Deserialize, Validate)]
struct ListenerConfig {
	#[validate(length(min = 1))]
	protocol: String,
	bind: String,
	#[serde(default)]
	tls: bool,
}

impl PreProcess for ListenerConfig {}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
	// 0. Prepare test directory structure
	let listener_dir = "example_listeners";

	// Cleanup from previous runs
	if std::path::Path::new(listener_dir).exists() {
		fs::remove_dir_all(listener_dir)?;
	}

	// Create listener directories with bracketed port names
	fs::create_dir_all(format!("{}/[443]", listener_dir))?;
	fs::create_dir_all(format!("{}/[80]", listener_dir))?;
	fs::create_dir_all(format!("{}/[8080]", listener_dir))?;

	// Write config files
	fs::write(
		format!("{}/[443]/config.json", listener_dir),
		r#"{"protocol": "https", "bind": "0.0.0.0:443", "tls": true}"#,
	)?;
	fs::write(
		format!("{}/[80]/config.json", listener_dir),
		r#"{"protocol": "http", "bind": "0.0.0.0:80", "tls": false}"#,
	)?;
	fs::write(
		format!("{}/[8080]/config.json", listener_dir),
		r#"{"protocol": "http", "bind": "127.0.0.1:8080", "tls": false}"#,
	)?;

	println!("Created listener configs in {}/", listener_dir);

	// 1. Setup Store
	let store = Arc::new(Store::<ListenerConfig>::new());

	// 2. Setup Loader with FileSource rooted at listener_dir
	let source = FileSource::new(listener_dir);
	let loader = DynLoader::builder()
		.source(source)
		.format(AnyFormat::Json)
		.build()
		.unwrap();

	// 3. Create LiveDir Controller
	let live_dir = LiveDir::builder()
		.store(store)
		.loader(loader)
		.path(listener_dir)
		.pattern(KeyPattern::Bracketed) // Extract port from [443] -> "443"
		.scan_mode(ScanMode::Subdirs {
			config_file: "config.json".to_string(),
		})
		.build()?;

	// 4. Initial load
	let result = live_dir.load().await?;
	println!("\nLoaded {} listeners:", result.loaded().count());

	for key in live_dir.keys().await {
		if let Some(config) = live_dir.get(&key) {
			println!(
				"  Port {}: {} @ {} (TLS: {})",
				key, config.protocol, config.bind, config.tls
			);
		}
	}

	// 5. Start watching
	let mut live_dir = live_dir.watch(WatcherConfig::default()).await?;

	println!(
		"\nWatching for changes... (Edit files in {}/ to see updates)",
		listener_dir
	);
	println!("Waiting 20 seconds...\n");

	// Loop to display config changes
	for i in 0..10 {
		tokio::time::sleep(Duration::from_secs(2)).await;
		println!("--- Check {} ---", i + 1);
		for key in live_dir.keys().await {
			if let Some(config) = live_dir.get(&key) {
				println!("  Port {}: {} @ {}", key, config.protocol, config.bind);
			}
		}
	}

	// Cleanup
	live_dir.stop_watching();
	fs::remove_dir_all(listener_dir)?;
	println!("\nDone. Cleaned up {}.", listener_dir);

	Ok(())
}