mariadb_cli/config/
mod.rs1pub mod doctor;
16pub mod keys;
17pub mod paths;
18pub mod secret;
19pub mod store;
20pub mod vault;
21
22pub use keys::{Domain, Fallback, KeySpec, Value};
23pub use secret::Secret;
24
25use crate::error::Result;
26use std::collections::BTreeMap;
27use std::path::{Path, PathBuf};
28
29#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
31#[serde(rename_all = "snake_case")]
32pub enum Origin {
33 Flag,
35 Stored,
37 Default,
39}
40
41impl Origin {
42 #[must_use]
44 pub const fn as_str(self) -> &'static str {
45 match self {
46 Self::Flag => "flag",
47 Self::Stored => "stored",
48 Self::Default => "default",
49 }
50 }
51}
52
53#[derive(Debug, Clone, PartialEq, Eq)]
55pub struct Resolved {
56 pub value: Option<Value>,
61 pub origin: Origin,
63}
64
65#[derive(Debug)]
70pub struct Config {
71 file: PathBuf,
72 stored: store::Stored,
73 flags: BTreeMap<&'static str, Value>,
74}
75
76impl Config {
77 pub fn load(override_dir: Option<&Path>) -> Result<Self> {
84 let file = paths::config_file(override_dir)?;
85 let stored = store::load(&file)?;
86 Ok(Self {
87 file,
88 stored,
89 flags: BTreeMap::new(),
90 })
91 }
92
93 pub fn with_nothing_stored(override_dir: Option<&Path>) -> Result<Self> {
113 Ok(Self {
114 file: paths::config_file(override_dir)?,
115 stored: store::Stored::new(),
116 flags: BTreeMap::new(),
117 })
118 }
119
120 pub fn with_flag(mut self, name: &str, raw: &str) -> Result<Self> {
127 let value = keys::validate(name, raw)?;
128 let entry = keys::spec(name).ok_or_else(|| keys::unknown_key(name))?;
129 self.flags.insert(entry.name, value);
130 Ok(self)
131 }
132
133 #[must_use]
135 pub fn file(&self) -> &Path {
136 &self.file
137 }
138
139 #[must_use]
141 pub fn is_stored(&self, name: &str) -> bool {
142 self.stored.contains_key(name)
143 }
144
145 pub fn resolve(&self, name: &str) -> Result<Resolved> {
152 let entry = keys::spec(name).ok_or_else(|| keys::unknown_key(name))?;
153
154 if let Some(value) = self.flags.get(entry.name) {
155 return Ok(Resolved {
156 value: Some(value.clone()),
157 origin: Origin::Flag,
158 });
159 }
160
161 if let Some(raw) = self.stored.get(entry.name) {
162 return Ok(Resolved {
163 value: Some(keys::validate(entry.name, raw)?),
164 origin: Origin::Stored,
165 });
166 }
167
168 Ok(Resolved {
169 value: entry.default_value()?,
170 origin: Origin::Default,
171 })
172 }
173
174 pub fn resolve_all(&self) -> impl Iterator<Item = (&'static KeySpec, Result<Resolved>)> + '_ {
179 keys::all()
180 .iter()
181 .map(|entry| (entry, self.resolve(entry.name)))
182 }
183}
184
185#[cfg(test)]
186mod tests {
187 use super::*;
188
189 fn scratch() -> tempfile::TempDir {
190 tempfile::tempdir().expect("scratch directory")
191 }
192
193 #[test]
194 fn nothing_stored_means_the_builtin_value_is_in_force() {
195 let dir = scratch();
196 let config = Config::load(Some(dir.path())).expect("loads");
197 let resolved = config.resolve("output.format").expect("published");
198 assert_eq!(resolved.origin, Origin::Default);
199 assert_eq!(resolved.value, Some(Value::Enumeration("json")));
200 }
201
202 #[test]
203 fn a_stored_value_beats_the_builtin_one() {
204 let dir = scratch();
205 let file = paths::config_file(Some(dir.path())).expect("location");
206 store::store(&file, "output.format", "tsv").expect("writes");
207
208 let config = Config::load(Some(dir.path())).expect("loads");
209 let resolved = config.resolve("output.format").expect("published");
210 assert_eq!(resolved.origin, Origin::Stored);
211 assert_eq!(resolved.value, Some(Value::Enumeration("tsv")));
212 }
213
214 #[test]
215 fn a_flag_beats_a_stored_value() {
216 let dir = scratch();
217 let file = paths::config_file(Some(dir.path())).expect("location");
218 store::store(&file, "output.format", "tsv").expect("writes");
219
220 let config = Config::load(Some(dir.path()))
221 .expect("loads")
222 .with_flag("output.format", "ndjson")
223 .expect("accepted");
224 let resolved = config.resolve("output.format").expect("published");
225 assert_eq!(resolved.origin, Origin::Flag);
226 assert_eq!(resolved.value, Some(Value::Enumeration("ndjson")));
227 }
228
229 #[test]
230 fn a_flag_outside_the_domain_is_refused_before_anything_is_decided() {
231 let dir = scratch();
232 let failure = Config::load(Some(dir.path()))
233 .expect("loads")
234 .with_flag("limits.retries", "many")
235 .expect_err("must refuse");
236 assert_eq!(failure.code(), "config.value_outside_domain");
237 }
238
239 #[test]
240 fn a_stored_value_outside_its_domain_is_reported_rather_than_ignored() {
241 let dir = scratch();
242 let file = paths::config_file(Some(dir.path())).expect("location");
243 std::fs::create_dir_all(dir.path()).expect("directory");
245 std::fs::write(&file, "\"output.format\" = \"yaml\"\n").expect("writes");
246
247 let config = Config::load(Some(dir.path())).expect("loads");
248 let failure = config.resolve("output.format").expect_err("must report");
249 assert_eq!(failure.code(), "config.value_outside_domain");
250 }
251
252 #[test]
253 fn a_setting_decided_by_the_server_carries_no_value_and_says_so() {
254 let dir = scratch();
255 let config = Config::load(Some(dir.path())).expect("loads");
256 let resolved = config.resolve("conn.timezone").expect("published");
257 assert_eq!(resolved.origin, Origin::Default);
258 assert_eq!(resolved.value, None);
259 }
260
261 #[test]
262 fn an_unknown_name_is_refused_at_every_entry_point() {
263 let dir = scratch();
264 let config = Config::load(Some(dir.path())).expect("loads");
265 assert_eq!(
266 config
267 .resolve("output.nonsense")
268 .expect_err("must refuse")
269 .code(),
270 "config.unknown_key"
271 );
272 }
273
274 #[test]
275 fn every_published_setting_is_listed_once() {
276 let dir = scratch();
277 let config = Config::load(Some(dir.path())).expect("loads");
278 assert_eq!(config.resolve_all().count(), keys::all().len());
279 }
280}