live 0.3.1

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
126
127
128

/* src/holder/store/write.rs */

use std::cell::RefCell;
use std::path::PathBuf;
use std::sync::Arc;
use std::sync::atomic::Ordering;
use std::time::Instant;

#[cfg(feature = "events")]
use super::super::HoldEvent;
use super::super::{Entry, HoldError, Meta, UnloadPolicy};
use super::Store;

impl<T> Store<T>
where
	T: Clone + Send + Sync,
{
	/// Inserts or updates a config entry.
	pub fn insert(&self, key: String, value: T, source: PathBuf, policy: UnloadPolicy) -> Arc<T> {
		let value = Arc::new(value);
		let version = self.version.fetch_add(1, Ordering::SeqCst) + 1;
		let meta = Meta {
			source,
			loaded_at: Instant::now(),
			version,
			policy,
		};

		let new_entry = Entry {
			value: Arc::clone(&value),
			meta: meta.clone(),
		};

		// Capture old_entry inside rcu to ensure event consistency.
		let old_entry: RefCell<Option<Entry<T>>> = RefCell::new(None);

		self.inner.rcu(|map| {
			*old_entry.borrow_mut() = map.get(&key).cloned();
			let mut new_map = (**map).clone();
			new_map.insert(key.clone(), new_entry.clone());
			new_map
		});

		let old_entry = old_entry.into_inner();

		#[cfg(feature = "events")]
		{
			let event = if let Some(old) = old_entry {
				HoldEvent::Updated {
					key,
					old: old.value,
					new: Arc::clone(&value),
					meta,
				}
			} else {
				HoldEvent::Loaded {
					key,
					value: Arc::clone(&value),
					meta,
				}
			};
			let _ = self.events.send(event);
		}

		#[cfg(not(feature = "events"))]
		{
			let _ = old_entry;
		}

		value
	}

	/// Removes a config entry by key.
	pub fn remove(&self, key: &str) -> Result<Arc<T>, HoldError> {
		// Pre-check to avoid unnecessary clone in rcu.
		let snapshot = self.inner.load();
		let entry = match snapshot.get(key) {
			None => {
				return Err(HoldError::NotFound {
					key: key.to_string(),
				});
			}
			Some(e) => e,
		};

		if entry.meta.policy == UnloadPolicy::Persistent {
			let error = HoldError::PersistentRemoval {
				key: key.to_string(),
			};
			#[cfg(feature = "events")]
			{
				let _ = self.events.send(HoldEvent::Retained {
					key: key.to_string(),
					error: error.clone(),
				});
			}
			return Err(error);
		}

		// Now perform the actual removal atomically.
		let removed: RefCell<Option<Arc<T>>> = RefCell::new(None);

		self.inner.rcu(|map| {
			let mut new_map = (**map).clone();
			if let Some(entry) = new_map.remove(key) {
				*removed.borrow_mut() = Some(entry.value);
			}
			new_map
		});

		match removed.into_inner() {
			Some(value) => {
				#[cfg(feature = "events")]
				{
					let _ = self.events.send(HoldEvent::Removed {
						key: key.to_string(),
						value: Arc::clone(&value),
					});
				}
				Ok(value)
			}
			// Entry was removed by another thread between pre-check and rcu.
			None => Err(HoldError::ConcurrentlyRemoved {
				key: key.to_string(),
			}),
		}
	}
}