tedge using new config (#2077)

Signed-off-by: Pradeep Kumar K J <[email protected]>
Co-authored-by: Pradeep Kumar K J <[email protected]>

crates/common/tedge_config/src/tedge_config_cli/new.rs

@@ -83,6 +83,25 @@ impl TEdgeConfig {
 
         Ok(mqtt_config)
     }
+
+    pub fn mqtt_client_auth_config(&self) -> MqttAuthConfig {
+        let mut client_auth = MqttAuthConfig {
+            ca_dir: self.mqtt.client.auth.ca_dir.or_none().cloned(),
+            ca_file: self.mqtt.client.auth.ca_file.or_none().cloned(),
+            client: None,
+        };
+        // Both these options have to either be set or not set
+        if let Ok(Some((client_cert, client_key))) = all_or_nothing((
+            self.mqtt.client.auth.cert_file.as_ref(),
+            self.mqtt.client.auth.key_file.as_ref(),
+        )) {
+            client_auth.client = Some(MqttAuthClientConfig {
+                cert_file: client_cert.clone(),
+                key_file: client_key.clone(),
+            })
+        }
+        client_auth
+    }
 }
 
 #[derive(serde::Deserialize, serde::Serialize, Clone, Copy, PartialEq, Eq, Debug)]
@@ -693,6 +712,19 @@ where
     }
 }
 
+#[derive(Debug, Clone, Default)]
+pub struct MqttAuthConfig {
+    pub ca_dir: Option<Utf8PathBuf>,
+    pub ca_file: Option<Utf8PathBuf>,
+    pub client: Option<MqttAuthClientConfig>,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct MqttAuthClientConfig {
+    pub cert_file: Utf8PathBuf,
+    pub key_file: Utf8PathBuf,
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/core/tedge/src/cli/certificate/upload.rs

@@ -6,7 +6,9 @@ use reqwest::StatusCode;
 use reqwest::Url;
 use std::io::prelude::*;
 use std::path::Path;
-use tedge_config::*;
+use tedge_config::get_new_tedge_config;
+use tedge_config::HostPort;
+use tedge_config::HTTPS_PORT;
 
 #[derive(Debug, serde::Deserialize)]
 struct CumulocityResponse {
@@ -48,10 +50,10 @@ impl UploadCertCmd {
             Err(_) => rpassword::read_password_from_tty(Some("Enter password: "))?,
         };
 
-        let config = get_tedge_config()?;
-        let root_cert = config.query(C8yRootCertPathSetting)?;
+        let config = get_new_tedge_config()?;
+        let root_cert = &config.c8y.root_cert_path;
         let client_builder = reqwest::blocking::Client::builder();
-        let client = match std::fs::metadata(&root_cert)?.is_file() {
+        let client = match std::fs::metadata(root_cert)?.is_file() {
             true => {
                 let cert = std::fs::read(root_cert)?;
                 let cert_pem = reqwest::Certificate::from_pem(&cert)?;

crates/core/tedge/src/cli/config/commands/set.rs

@@ -1,6 +1,6 @@
 use crate::command::Command;
 use tedge_config::new::WritableKey;
-use tedge_config::*;
+use tedge_config::TEdgeConfigRepository;
 
 pub struct SetConfigCommand {
     pub key: WritableKey,

crates/core/tedge/src/cli/config/commands/unset.rs

@@ -1,6 +1,6 @@
 use crate::command::Command;
 use tedge_config::new::WritableKey;
-use tedge_config::*;
+use tedge_config::TEdgeConfigRepository;
 
 pub struct UnsetConfigCommand {
     pub key: WritableKey,

crates/core/tedge/src/cli/connect/command.rs

@@ -12,6 +12,7 @@ use rumqttc::QoS::AtLeastOnce;
 use std::path::Path;
 use std::sync::Arc;
 use std::time::Duration;
+use tedge_config::new::TEdgeConfig;
 use tedge_config::system_services::*;
 use tedge_config::*;
 use tedge_utils::paths::create_directories;
@@ -53,7 +54,7 @@ impl Command for ConnectCommand {
     }
 
     fn execute(&self) -> anyhow::Result<()> {
-        let config = self.config_repository.load()?;
+        let config = self.config_repository.load_new()?;
         if self.is_test_connection {
             let br_config = self.bridge_config(&config)?;
             if self.check_if_bridge_exists(&br_config) {
@@ -84,29 +85,33 @@ impl Command for ConnectCommand {
             .common_mosquitto_config
             .clone()
             .with_internal_opts(
-                config.query(MqttPortSetting)?.into(),
-                config.query(MqttBindAddressSetting)?.to_string(),
+                config.mqtt.bind.port.into(),
+                config.mqtt.bind.address.to_string(),
             )
             .with_external_opts(
-                config.query(MqttExternalPortSetting).ok().map(|x| x.into()),
+                config.mqtt.external.bind.port.or_none().cloned(),
                 config
-                    .query(MqttExternalBindAddressSetting)
-                    .ok()
-                    .map(|x| x.to_string()),
-                config.query(MqttExternalBindInterfaceSetting).ok(),
-                config.query(MqttExternalCAPathSetting).ok(),
-                config.query(MqttExternalCertfileSetting).ok(),
-                config.query(MqttExternalKeyfileSetting).ok(),
+                    .mqtt
+                    .external
+                    .bind
+                    .address
+                    .or_none()
+                    .cloned()
+                    .map(|a| a.to_string()),
+                config.mqtt.external.bind.interface.or_none().cloned(),
+                config.mqtt.external.ca_path.or_none().cloned(),
+                config.mqtt.external.cert_file.or_none().cloned(),
+                config.mqtt.external.key_file.or_none().cloned(),
             );
 
-        let device_type = config.query(DeviceTypeSetting)?;
+        let device_type = &config.device.ty;
 
         new_bridge(
             &bridge_config,
             &updated_mosquitto_config,
             self.service_manager.as_ref(),
             &self.config_location,
-            &device_type,
+            device_type,
         )?;
 
         match self.check_connection(&config) {
@@ -136,7 +141,13 @@ impl Command for ConnectCommand {
         if let Cloud::C8y = self.cloud {
             check_connected_c8y_tenant_as_configured(
                 &config,
-                &config.query_string(C8yMqttSetting)?,
+                &config
+                    .c8y
+                    .mqtt
+                    .or_none()
+                    .cloned()
+                    .map(|u| u.to_string())
+                    .unwrap_or_default(),
             );
             enable_software_management(&bridge_config, self.service_manager.as_ref());
         }
@@ -150,39 +161,39 @@ impl ConnectCommand {
         match self.cloud {
             Cloud::Azure => {
                 let params = BridgeConfigAzureParams {
-                    connect_url: config.query(AzureUrlSetting)?,
+                    connect_url: config.az.url.or_config_not_set()?.clone(),
                     mqtt_tls_port: MQTT_TLS_PORT,
                     config_file: AZURE_CONFIG_FILENAME.into(),
-                    bridge_root_cert_path: config.query(AzureRootCertPathSetting)?,
-                    remote_clientid: config.query(DeviceIdSetting)?,
-                    bridge_certfile: config.query(DeviceCertPathSetting)?,
-                    bridge_keyfile: config.query(DeviceKeyPathSetting)?,
+                    bridge_root_cert_path: config.az.root_cert_path.clone(),
+                    remote_clientid: config.device.id.try_read(config)?.clone(),
+                    bridge_certfile: config.device.cert_path.clone(),
+                    bridge_keyfile: config.device.key_path.clone(),
                 };
 
                 Ok(BridgeConfig::from(params))
             }
             Cloud::Aws => {
                 let params = BridgeConfigAwsParams {
-                    connect_url: config.query(AwsUrlSetting)?,
+                    connect_url: config.aws.url.or_config_not_set()?.clone(),
                     mqtt_tls_port: MQTT_TLS_PORT,
                     config_file: AWS_CONFIG_FILENAME.into(),
-                    bridge_root_cert_path: config.query(AwsRootCertPathSetting)?,
-                    remote_clientid: config.query(DeviceIdSetting)?,
-                    bridge_certfile: config.query(DeviceCertPathSetting)?,
-                    bridge_keyfile: config.query(DeviceKeyPathSetting)?,
+                    bridge_root_cert_path: config.aws.root_cert_path.clone(),
+                    remote_clientid: config.device.id.try_read(config)?.clone(),
+                    bridge_certfile: config.device.cert_path.clone(),
+                    bridge_keyfile: config.device.key_path.clone(),
                 };
 
                 Ok(BridgeConfig::from(params))
             }
             Cloud::C8y => {
                 let params = BridgeConfigC8yParams {
-                    mqtt_host: config.query(C8yMqttSetting)?,
+                    mqtt_host: config.c8y.mqtt.or_config_not_set()?.clone(),
                     config_file: C8Y_CONFIG_FILENAME.into(),
-                    bridge_root_cert_path: config.query(C8yRootCertPathSetting)?,
-                    remote_clientid: config.query(DeviceIdSetting)?,
-                    bridge_certfile: config.query(DeviceCertPathSetting)?,
-                    bridge_keyfile: config.query(DeviceKeyPathSetting)?,
-                    smartrest_templates: config.query(C8ySmartRestTemplates)?,
+                    bridge_root_cert_path: config.c8y.root_cert_path.clone(),
+                    remote_clientid: config.device.id.try_read(config)?.clone(),
+                    bridge_certfile: config.device.cert_path.clone(),
+                    bridge_keyfile: config.device.key_path.clone(),
+                    smartrest_templates: config.c8y.smartrest.templates.clone(),
                 };
 
                 Ok(BridgeConfig::from(params))

crates/core/tedge/src/cli/connect/jwt_token.rs

@@ -6,7 +6,7 @@ use rumqttc::Incoming;
 use rumqttc::Outgoing;
 use rumqttc::Packet;
 use rumqttc::QoS::AtLeastOnce;
-use tedge_config::TEdgeConfig;
+use tedge_config::new::TEdgeConfig;
 
 pub(crate) fn get_connected_c8y_url(tedge_config: &TEdgeConfig) -> Result<String, ConnectError> {
     const C8Y_TOPIC_BUILTIN_JWT_TOKEN_UPSTREAM: &str = "c8y/s/uat";

crates/core/tedge/src/cli/mqtt/cli.rs

@@ -4,10 +4,8 @@ use crate::cli::mqtt::MqttError;
 use crate::command::BuildCommand;
 use crate::command::BuildContext;
 use crate::command::Command;
-use camino::Utf8PathBuf;
 use rumqttc::QoS;
 use std::time::Duration;
-use tedge_config::*;
 
 const PUB_CLIENT_PREFIX: &str = "tedge-pub";
 const SUB_CLIENT_PREFIX: &str = "tedge-sub";
@@ -44,43 +42,8 @@ pub enum TEdgeMqttCli {
 
 impl BuildCommand for TEdgeMqttCli {
     fn build_command(self, context: BuildContext) -> Result<Box<dyn Command>, crate::ConfigError> {
-        let port = context
-            .config_repository
-            .load()?
-            .query(MqttClientPortSetting)?;
-        let host = context
-            .config_repository
-            .load()?
-            .query(MqttClientHostSetting)?;
-        let ca_file = context
-            .config_repository
-            .load()?
-            .query(MqttClientCafileSetting)
-            .ok();
-        let ca_path = context
-            .config_repository
-            .load()?
-            .query(MqttClientCapathSetting)
-            .ok();
-        let client_cert = context
-            .config_repository
-            .load()?
-            .query(MqttClientAuthCertSetting);
-        let client_private_key = context
-            .config_repository
-            .load()?
-            .query(MqttClientAuthKeySetting);
-
-        let client_auth_config = if client_cert.is_err() && client_private_key.is_err() {
-            None
-        } else {
-            let client_cert = client_cert?;
-            let client_private_key = client_private_key?;
-            Some(ClientAuthConfig {
-                cert_file: client_cert,
-                key_file: client_private_key,
-            })
-        };
+        let config = context.config_repository.load_new()?;
+        let auth_config = config.mqtt_client_auth_config();
 
         let cmd = {
             match self {
@@ -90,33 +53,33 @@ impl BuildCommand for TEdgeMqttCli {
                     qos,
                     retain,
                 } => MqttPublishCommand {
-                    host,
-                    port: port.into(),
+                    host: config.mqtt.client.host.clone(),
+                    port: config.mqtt.client.port.into(),
                     topic,
                     message,
                     qos,
                     client_id: format!("{}-{}", PUB_CLIENT_PREFIX, std::process::id()),
                     disconnect_timeout: DISCONNECT_TIMEOUT,
                     retain,
-                    ca_file,
-                    ca_dir: ca_path,
-                    client_auth_config,
+                    ca_file: auth_config.ca_file.clone(),
+                    ca_dir: auth_config.ca_dir,
+                    client_auth_config: auth_config.client,
                 }
                 .into_boxed(),
                 TEdgeMqttCli::Sub {
                     topic,
                     qos,
                     hide_topic,
                 } => MqttSubscribeCommand {
-                    host,
-                    port: port.into(),
+                    host: config.mqtt.client.host.clone(),
+                    port: config.mqtt.client.port.into(),
                     topic,
                     qos,
                     hide_topic,
                     client_id: format!("{}-{}", SUB_CLIENT_PREFIX, std::process::id()),
-                    ca_file,
-                    ca_dir: ca_path,
-                    client_auth_config,
+                    ca_file: auth_config.ca_file,
+                    ca_dir: auth_config.ca_dir,
+                    client_auth_config: auth_config.client,
                 }
                 .into_boxed(),
             }
@@ -136,11 +99,6 @@ fn parse_qos(src: &str) -> Result<QoS, MqttError> {
     }
 }
 
-pub struct ClientAuthConfig {
-    pub cert_file: Utf8PathBuf,
-    pub key_file: Utf8PathBuf,
-}
-
 #[cfg(test)]
 mod tests {
     use super::parse_qos;

crates/core/tedge/src/cli/mqtt/publish.rs

@@ -1,4 +1,3 @@
-use super::cli::ClientAuthConfig;
 use crate::cli::mqtt::MqttError;
 use crate::command::Command;
 use camino::Utf8PathBuf;
@@ -14,6 +13,7 @@ use rumqttc::QoS::AtLeastOnce;
 use rumqttc::QoS::AtMostOnce;
 use rumqttc::QoS::ExactlyOnce;
 use std::time::Duration;
+use tedge_config::new::MqttAuthClientConfig;
 
 const DEFAULT_QUEUE_CAPACITY: usize = 10;
 
@@ -28,7 +28,7 @@ pub struct MqttPublishCommand {
     pub retain: bool,
     pub ca_file: Option<Utf8PathBuf>,
     pub ca_dir: Option<Utf8PathBuf>,
-    pub client_auth_config: Option<ClientAuthConfig>,
+    pub client_auth_config: Option<MqttAuthClientConfig>,
 }
 
 impl Command for MqttPublishCommand {

crates/core/tedge/src/cli/mqtt/subscribe.rs

@@ -1,4 +1,3 @@
-use super::cli::ClientAuthConfig;
 use crate::cli::mqtt::MqttError;
 use crate::command::Command;
 use camino::Utf8PathBuf;
@@ -11,6 +10,7 @@ use rumqttc::Incoming;
 use rumqttc::MqttOptions;
 use rumqttc::Packet;
 use rumqttc::QoS;
+use tedge_config::new::MqttAuthClientConfig;
 
 const DEFAULT_QUEUE_CAPACITY: usize = 10;
 const MAX_PACKET_SIZE: usize = 1048575;
@@ -24,7 +24,7 @@ pub struct MqttSubscribeCommand {
     pub client_id: String,
     pub ca_file: Option<Utf8PathBuf>,
     pub ca_dir: Option<Utf8PathBuf>,
-    pub client_auth_config: Option<ClientAuthConfig>,
+    pub client_auth_config: Option<MqttAuthClientConfig>,
 }
 
 impl Command for MqttSubscribeCommand {

crates/core/tedge/src/error.rs

@@ -27,4 +27,7 @@ pub enum TEdgeError {
 
     #[error(transparent)]
     FromTEdgeConfigRead(#[from] tedge_config::new::ReadError),
+
+    #[error(transparent)]
+    FromConfigNotSet(#[from] tedge_config::new::ConfigNotSet),
 }