rip_settings/
repository.rs1use crate::backend::SettingsBackend;
2use crate::error::SettingsError;
3use crate::schema::SettingsSchema;
4use crate::validation;
5use crate::validation::ValidationResult;
6use std::sync::{Arc, Mutex, RwLock};
7use tokio::sync::watch;
8
9pub type ChangeListener<T> = Box<dyn Fn(&str, &T, &T) + Send + Sync>;
10
11pub struct SettingsRepository<T: SettingsSchema> {
13 backend: Box<dyn SettingsBackend>,
14 current: Mutex<T>,
15 sender: watch::Sender<T>,
16 receiver: watch::Receiver<T>,
17 change_listeners: Arc<RwLock<Vec<ChangeListener<T>>>>,
18}
19
20impl<T: SettingsSchema + PartialEq> SettingsRepository<T> {
21 pub fn new(backend: Box<dyn SettingsBackend>) -> Self {
22 let initial = Self::load_from_backend(&*backend);
23 let (sender, receiver) = watch::channel(initial.clone());
24 Self {
25 backend,
26 current: Mutex::new(initial),
27 sender,
28 receiver,
29 change_listeners: Arc::new(RwLock::new(Vec::new())),
30 }
31 }
32
33 pub fn get(&self) -> T {
35 self.current
36 .lock()
37 .unwrap_or_else(|e| e.into_inner())
38 .clone()
39 }
40
41 pub fn update(&self, f: impl FnOnce(&mut T)) -> Result<(), SettingsError> {
44 let mut guard = self
45 .current
46 .lock()
47 .map_err(|e| SettingsError::LockPoisoned(e.to_string()))?;
48 let old = guard.clone();
49 let mut candidate = old.clone();
50 f(&mut candidate);
51
52 if old == candidate {
53 return Ok(());
54 }
55
56 for field in candidate.fields() {
58 if let Some(ref rules) = field.validation {
59 if let Ok(val) = candidate.get_field_value(field.name) {
60 if let ValidationResult::Invalid(msg) = validation::validate_value(&val, rules)
61 {
62 return Err(SettingsError::ValidationFailed(msg));
63 }
64 }
65 }
66 }
67
68 *guard = candidate;
69 self.persist(&guard)?;
70 let _ = self.sender.send(guard.clone());
71
72 let fields = guard.fields();
73 for field in &fields {
74 if old.get_field_value(field.name).ok() != guard.get_field_value(field.name).ok() {
75 self.notify_change(field.name, &old, &guard);
76 }
77 }
78
79 Ok(())
80 }
81
82 pub fn set_field(&self, name: &str, value: serde_json::Value) -> Result<(), SettingsError> {
84 let mut guard = self
85 .current
86 .lock()
87 .map_err(|e| SettingsError::LockPoisoned(e.to_string()))?;
88
89 if let Some(field_meta) = guard.field_by_name(name) {
90 if let Some(ref rules) = field_meta.validation {
91 let result = validation::validate_value(&value, rules);
92 if let ValidationResult::Invalid(msg) = result {
93 return Err(SettingsError::ValidationFailed(msg));
94 }
95 }
96 }
97
98 let old = guard.clone();
99 guard.set_field_value(name, value)?;
100
101 if old == *guard {
102 return Ok(());
103 }
104
105 self.persist(&guard)?;
106 let _ = self.sender.send(guard.clone());
107 self.notify_change(name, &old, &guard);
108
109 Ok(())
110 }
111
112 pub fn get_field(&self, name: &str) -> Result<serde_json::Value, SettingsError> {
114 self.get().get_field_value(name)
115 }
116
117 pub fn subscribe(&self) -> watch::Receiver<T> {
119 self.receiver.clone()
120 }
121
122 pub fn add_change_listener(&self, listener: ChangeListener<T>) {
124 self.change_listeners
125 .write()
126 .unwrap_or_else(|e| e.into_inner())
127 .push(listener);
128 }
129
130 pub fn reload(&self) -> Result<(), SettingsError> {
132 let loaded = Self::load_from_backend(&*self.backend);
133 let mut guard = self
134 .current
135 .lock()
136 .map_err(|e| SettingsError::LockPoisoned(e.to_string()))?;
137 *guard = loaded.clone();
138 let _ = self.sender.send(loaded);
139 Ok(())
140 }
141
142 pub fn reset_all(&self) -> Result<(), SettingsError> {
144 let defaults = T::default();
145 let mut guard = self
146 .current
147 .lock()
148 .map_err(|e| SettingsError::LockPoisoned(e.to_string()))?;
149 *guard = defaults;
150 self.persist(&guard)?;
151 let _ = self.sender.send(guard.clone());
152 Ok(())
153 }
154
155 pub fn reset_field(&self, name: &str) -> Result<(), SettingsError> {
157 let defaults = T::default();
158 let default_value = defaults.get_field_value(name)?;
159 self.set_field(name, default_value)
160 }
161
162 pub fn backend(&self) -> &dyn SettingsBackend {
164 &*self.backend
165 }
166
167 fn persist(&self, value: &T) -> Result<(), SettingsError> {
168 let data = serde_json::to_vec_pretty(value)?;
169 self.backend.save(&data)
170 }
171
172 fn load_from_backend(backend: &dyn SettingsBackend) -> T {
173 match backend.load() {
174 Ok(data) if !data.is_empty() => serde_json::from_slice(&data).unwrap_or_default(),
175 _ => T::default(),
176 }
177 }
178
179 fn notify_change(&self, field_name: &str, old: &T, new: &T) {
180 if let Ok(listeners) = self.change_listeners.read() {
181 for listener in listeners.iter() {
182 listener(field_name, old, new);
183 }
184 }
185 }
186}