refactor: separate system toml config from service management logic

Signed-off-by: James Rhodes <jarhodes314@gmail.com>

Author: jarhodes314

crates/common/tedge_config/src/lib.rs

@@ -4,7 +4,9 @@ pub mod system_services;
 pub mod tedge_config_cli;
 pub use sudo::SudoCommandBuilder;
 pub mod cli;
+mod system_toml;
 
+pub use self::system_toml::*;
 pub use self::tedge_config_cli::config_setting::*;
 pub use self::tedge_config_cli::error::*;
 pub use self::tedge_config_cli::models::*;

crates/common/tedge_config/src/system_services/error.rs

@@ -21,9 +21,6 @@ pub enum SystemServiceError {
      Service manager '{name}' is not available on the system or elevated permissions have not been granted.")]
     ServiceManagerUnavailable { cmd: String, name: String },
 
-    #[error("Toml syntax error in the system config file '{path}': {reason}")]
-    SystemConfigInvalidToml { path: Utf8PathBuf, reason: String },
-
     #[error(
         "Syntax error in the system config file for '{cmd}': {reason}\n\
     Check '{path}' file."
@@ -33,7 +30,4 @@ pub enum SystemServiceError {
         cmd: String,
         path: Utf8PathBuf,
     },
-
-    #[error("Invalid log level: {name:?}, supported levels are info, warn, error and debug")]
-    InvalidLogLevel { name: String },
 }

crates/common/tedge_config/src/system_services/manager.rs

@@ -1,6 +1,7 @@
 use camino::Utf8Path;
 
-use crate::system_services::*;
+use super::*;
+use crate::SystemTomlError;
 use std::fmt::Debug;
 use std::sync::Arc;
 
@@ -34,6 +35,6 @@ pub trait SystemServiceManager: Debug {
 
 pub fn service_manager(
     config_root: &Utf8Path,
-) -> Result<Arc<dyn SystemServiceManager>, SystemServiceError> {
+) -> Result<Arc<dyn SystemServiceManager>, SystemTomlError> {
     Ok(Arc::new(GeneralServiceManager::try_new(config_root)?))
 }

crates/common/tedge_config/src/system_services/managers/general_manager.rs

@@ -2,12 +2,13 @@ use crate::system_services::CommandBuilder;
 use crate::system_services::SystemService;
 use crate::system_services::SystemServiceError;
 use crate::system_services::SystemServiceManager;
+use crate::SystemTomlError;
 use camino::Utf8Path;
 use camino::Utf8PathBuf;
 
-use super::config::InitConfig;
-use super::config::SystemConfig;
-use super::config::SERVICE_CONFIG_FILE;
+use crate::system_toml::InitConfig;
+use crate::system_toml::SystemConfig;
+use crate::system_toml::SYSTEM_CONFIG_FILE;
 use std::fmt;
 use std::process::ExitStatus;
 
@@ -18,10 +19,10 @@ pub struct GeneralServiceManager {
 }
 
 impl GeneralServiceManager {
-    pub fn try_new(config_root: &Utf8Path) -> Result<Self, SystemServiceError> {
+    pub fn try_new(config_root: &Utf8Path) -> Result<Self, SystemTomlError> {
         let init_config = SystemConfig::try_new(config_root)?.init;
 
-        let config_path = config_root.join(SERVICE_CONFIG_FILE);
+        let config_path = config_root.join(SYSTEM_CONFIG_FILE);
 
         Ok(Self {
             init_config,

crates/common/tedge_config/src/system_services/managers/mod.rs

@@ -1,5 +1,3 @@
-mod config;
 mod general_manager;
 
-pub use self::config::*;
 pub use self::general_manager::*;

crates/common/tedge_config/src/system_services/mod.rs

@@ -10,15 +10,13 @@
 
 mod command_builder;
 mod error;
-mod log_config;
 mod manager;
 mod manager_ext;
 mod managers;
 mod services;
 
 pub use self::command_builder::*;
 pub use self::error::*;
-pub use self::log_config::*;
 pub use self::manager::*;
 pub use self::manager_ext::*;
 pub use self::managers::*;

crates/common/tedge_config/src/system_services/log_config.rs renamed to crates/common/tedge_config/src/system_toml/log_level.rs

@@ -1,8 +1,8 @@
 use camino::Utf8Path;
 
+use super::SystemConfig;
+use super::SystemTomlError;
 use crate::cli::LogConfigArgs;
-use crate::system_services::SystemConfig;
-use crate::system_services::SystemServiceError;
 use std::io::IsTerminal;
 use std::str::FromStr;
 
@@ -18,7 +18,7 @@ pub fn log_init(
     sname: &str,
     flags: &LogConfigArgs,
     config_dir: &Utf8Path,
-) -> Result<(), SystemServiceError> {
+) -> Result<(), SystemTomlError> {
     let subscriber = tracing_subscriber::fmt()
         .with_writer(std::io::stderr)
         .with_ansi(std::io::stderr().is_terminal())
@@ -51,11 +51,11 @@ pub fn log_init(
 pub fn get_log_level(
     sname: &str,
     config_dir: &Utf8Path,
-) -> Result<tracing::Level, SystemServiceError> {
+) -> Result<tracing::Level, SystemTomlError> {
     let loglevel = SystemConfig::try_new(config_dir)?.log;
     match loglevel.get(sname) {
         Some(ll) => tracing::Level::from_str(&ll.to_uppercase()).map_err(|_| {
-            SystemServiceError::InvalidLogLevel {
+            SystemTomlError::InvalidLogLevel {
                 name: ll.to_string(),
             }
         }),

crates/common/tedge_config/src/system_services/managers/config.rs renamed to crates/common/tedge_config/src/system_toml/mod.rs

@@ -1,60 +1,51 @@
-use crate::system_services::SystemServiceError;
-use camino::Utf8Path;
-use serde::Deserialize;
 use std::collections::HashMap;
-use std::fs;
 use std::time::Duration;
 
-pub const SERVICE_CONFIG_FILE: &str = "system.toml";
+use serde::Deserialize;
+
+mod log_level;
+mod services;
+
+pub use self::log_level::*;
+pub use self::services::*;
+use camino::Utf8Path;
+use camino::Utf8PathBuf;
+use std::fs;
+
+pub const SYSTEM_CONFIG_FILE: &str = "system.toml";
 const REBOOT_COMMAND: &[&str] = &["init", "6"];
 
+#[derive(thiserror::Error, Debug)]
+pub enum SystemTomlError {
+    #[error("Toml syntax error in the system config file '{path}': {reason}")]
+    InvalidSyntax { path: Utf8PathBuf, reason: String },
+
+    #[error("Invalid log level: {name:?}, supported levels are info, warn, error and debug")]
+    InvalidLogLevel { name: String },
+}
+
 #[derive(Deserialize, Debug, Default, Eq, PartialEq)]
 pub struct SystemConfig {
     #[serde(default)]
-    pub init: InitConfig,
+    pub init: services::InitConfig,
     #[serde(default)]
     pub log: HashMap<String, String>,
     #[serde(default)]
     pub system: SystemSpecificCommands,
 }
 
-#[derive(Deserialize, Debug, Eq, PartialEq)]
-#[serde(from = "InitConfigToml")]
-pub struct InitConfig {
-    pub name: String,
-    pub is_available: Vec<String>,
-    pub restart: Vec<String>,
-    pub stop: Vec<String>,
-    pub start: Vec<String>,
-    pub enable: Vec<String>,
-    pub disable: Vec<String>,
-    pub is_active: Vec<String>,
-}
-
-#[derive(Deserialize, Debug, Eq, PartialEq)]
-#[serde(deny_unknown_fields)]
-struct InitConfigToml {
-    name: String,
-    is_available: Vec<String>,
-    restart: Vec<String>,
-    stop: Vec<String>,
-    start: Option<Vec<String>>,
-    enable: Vec<String>,
-    disable: Vec<String>,
-    is_active: Vec<String>,
-}
+impl SystemConfig {
+    pub fn try_new(config_root: &Utf8Path) -> Result<Self, SystemTomlError> {
+        let config_path = config_root.join(SYSTEM_CONFIG_FILE);
 
-impl From<InitConfigToml> for InitConfig {
-    fn from(value: InitConfigToml) -> Self {
-        Self {
-            name: value.name,
-            is_available: value.is_available,
-            start: value.start.unwrap_or(value.restart.clone()),
-            restart: value.restart,
-            stop: value.stop,
-            enable: value.enable,
-            disable: value.disable,
-            is_active: value.is_active,
+        match fs::read_to_string(config_path.clone()) {
+            Ok(contents) => {
+                toml::from_str(contents.as_str()).map_err(|e| SystemTomlError::InvalidSyntax {
+                    path: config_path,
+                    reason: e.to_string(),
+                })
+            }
+            Err(_) => Ok(Self::default()),
         }
     }
 }
@@ -94,37 +85,6 @@ impl Default for SystemSpecificCommands {
     }
 }
 
-impl Default for InitConfig {
-    fn default() -> Self {
-        Self {
-            name: "systemd".to_string(),
-            is_available: vec!["/bin/systemctl".into(), "--version".into()],
-            restart: vec!["/bin/systemctl".into(), "restart".into(), "{}".into()],
-            stop: vec!["/bin/systemctl".into(), "stop".into(), "{}".into()],
-            start: vec!["/bin/systemctl".into(), "start".into(), "{}".into()],
-            enable: vec!["/bin/systemctl".into(), "enable".into(), "{}".into()],
-            disable: vec!["/bin/systemctl".into(), "disable".into(), "{}".into()],
-            is_active: vec!["/bin/systemctl".into(), "is-active".into(), "{}".into()],
-        }
-    }
-}
-
-impl SystemConfig {
-    pub fn try_new(config_root: &Utf8Path) -> Result<Self, SystemServiceError> {
-        let config_path = config_root.join(SERVICE_CONFIG_FILE);
-
-        match fs::read_to_string(config_path.clone()) {
-            Ok(contents) => toml::from_str(contents.as_str()).map_err(|e| {
-                SystemServiceError::SystemConfigInvalidToml {
-                    path: config_path,
-                    reason: e.to_string(),
-                }
-            }),
-            Err(_) => Ok(Self::default()),
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -235,7 +195,7 @@ mod tests {
     fn create_temp_system_config(content: &str) -> std::io::Result<(TempDir, Utf8PathBuf)> {
         let temp_dir = TempDir::new()?;
         let config_root = Utf8Path::from_path(temp_dir.path()).unwrap().to_owned();
-        let config_file_path = config_root.join(SERVICE_CONFIG_FILE);
+        let config_file_path = config_root.join(SYSTEM_CONFIG_FILE);
         let mut file = std::fs::File::create(config_file_path.as_path())?;
         file.write_all(content.as_bytes())?;
         Ok((temp_dir, config_root))

crates/common/tedge_config/src/system_toml/services.rs

@@ -0,0 +1,57 @@
+use serde::Deserialize;
+
+#[derive(Deserialize, Debug, Eq, PartialEq)]
+#[serde(from = "InitConfigToml")]
+pub struct InitConfig {
+    pub name: String,
+    pub is_available: Vec<String>,
+    pub restart: Vec<String>,
+    pub stop: Vec<String>,
+    pub start: Vec<String>,
+    pub enable: Vec<String>,
+    pub disable: Vec<String>,
+    pub is_active: Vec<String>,
+}
+
+#[derive(Deserialize, Debug, Eq, PartialEq)]
+#[serde(deny_unknown_fields)]
+struct InitConfigToml {
+    name: String,
+    is_available: Vec<String>,
+    restart: Vec<String>,
+    stop: Vec<String>,
+    start: Option<Vec<String>>,
+    enable: Vec<String>,
+    disable: Vec<String>,
+    is_active: Vec<String>,
+}
+
+impl From<InitConfigToml> for InitConfig {
+    fn from(value: InitConfigToml) -> Self {
+        Self {
+            name: value.name,
+            is_available: value.is_available,
+            start: value.start.unwrap_or(value.restart.clone()),
+            restart: value.restart,
+            stop: value.stop,
+            enable: value.enable,
+            disable: value.disable,
+            is_active: value.is_active,
+        }
+    }
+}
+
+impl Default for InitConfig {
+    fn default() -> Self {
+        Self {
+            name: "systemd".to_string(),
+            is_available: vec!["/bin/systemctl".into(), "--version".into()],
+            restart: vec!["/bin/systemctl".into(), "restart".into(), "{}".into()],
+            stop: vec!["/bin/systemctl".into(), "stop".into(), "{}".into()],
+            start: vec!["/bin/systemctl".into(), "start".into(), "{}".into()],
+            enable: vec!["/bin/systemctl".into(), "enable".into(), "{}".into()],
+            disable: vec!["/bin/systemctl".into(), "disable".into(), "{}".into()],
+            is_active: vec!["/bin/systemctl".into(), "is-active".into(), "{}".into()],
+        }
+    }
+}

crates/core/tedge/src/error.rs

@@ -27,6 +27,9 @@ pub enum TEdgeError {
     #[error(transparent)]
     FromSystemServiceError(#[from] tedge_config::system_services::SystemServiceError),
 
+    #[error(transparent)]
+    FromSystemToml(#[from] tedge_config::SystemTomlError),
+
     #[error(transparent)]
     FromTEdgeConfigRead(#[from] tedge_config::ReadError),