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
|
use crate::*;
use std::fs;
use std::path::PathBuf;
use tedge_utils::fs::atomically_write_file_sync;
/// TEdgeConfigRepository is responsible for loading and storing TEdgeConfig entities.
///
#[derive(Debug)]
pub struct TEdgeConfigRepository {
config_location: TEdgeConfigLocation,
config_defaults: TEdgeConfigDefaults,
}
pub trait ConfigRepository<T> {
type Error;
fn load(&self) -> Result<T, Self::Error>;
fn store(&self, config: &T) -> Result<(), Self::Error>;
}
impl ConfigRepository<TEdgeConfig> for TEdgeConfigRepository {
type Error = TEdgeConfigError;
fn load(&self) -> Result<TEdgeConfig, TEdgeConfigError> {
let config =
self.read_file_or_default(self.config_location.tedge_config_file_path().into())?;
Ok(config)
}
// TODO: Explicitly set the file permissions in this function and file ownership!
fn store(&self, config: &TEdgeConfig) -> Result<(), TEdgeConfigError> {
let toml = toml::to_string_pretty(&config.data)?;
// Create `$HOME/.tedge` or `/etc/tedge` directory in case it does not exist yet
if !self.config_location.tedge_config_root_path.exists() {
fs::create_dir(self.config_location.tedge_config_root_path())?;
}
atomically_write_file_sync(
self.config_location.temporary_tedge_config_file_path(),
self.config_location.tedge_config_file_path(),
toml.as_bytes(),
)?;
Ok(())
}
}
impl TEdgeConfigRepository {
pub fn new(config_location: TEdgeConfigLocation) -> Self {
let config_defaults = TEdgeConfigDefaults::from(&config_location);
Self::new_with_defaults(config_location, config_defaults)
}
pub fn new_with_defaults(
config_location: TEdgeConfigLocation,
config_defaults: TEdgeConfigDefaults,
) -> Self {
Self {
config_location,
config_defaults,
}
}
pub fn get_config_location(&self) -> &TEdgeConfigLocation {
&self.config_location
}
/// Parse the configuration file at the provided `path` and create a `TEdgeConfig` out of it
///
/// #Arguments
///
/// * `path` - Path to a thin edge configuration TOML file
///
fn read_file(&self, path: PathBuf) -> Result<TEdgeConfig, TEdgeConfigError> {
match std::fs::read(&path) {
Ok(bytes) => {
let data = toml::from_slice::<TEdgeConfigDto>(bytes.as_slice())?;
self.make_tedge_config(data)
}
Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
Err(TEdgeConfigError::ConfigFileNotFound(path))
}
Err(err) => Err(TEdgeConfigError::FromIo(err)),
}
}
fn read_file_or_default(&self, path: PathBuf) -> Result<TEdgeConfig, TEdgeConfigError> {
match self.read_file(path) {
Ok(file) => Ok(file),
Err(TEdgeConfigError::ConfigFileNotFound(..)) => {
self.make_tedge_config(TEdgeConfigDto::default())
}
Err(err) => Err(err),
}
}
fn make_tedge_config(&self, data: TEdgeConfigDto) -> Result<TEdgeConfig, TEdgeConfigError> {
Ok(TEdgeConfig {
data,
config_defaults: self.config_defaults.clone(),
})
}
}
|
