feat: log the auth method when running tedge connect c8y

Author: jarhodes314

crates/common/tedge_config/src/tedge_config_cli/models/auth_method.rs

@@ -34,6 +34,7 @@ impl FromStr for AuthMethod {
     }
 }
 
+#[derive(PartialEq, Eq)]
 pub enum AuthType {
     Certificate,
     Basic,

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

@@ -21,6 +21,7 @@ use anyhow::bail;
 use c8y_api::http_proxy::read_c8y_credentials;
 use c8y_api::smartrest::message::get_smartrest_template_id;
 use c8y_api::smartrest::message_ids::JWT_TOKEN;
+use camino::Utf8Path;
 use camino::Utf8PathBuf;
 use mqtt_channel::Topic;
 use rumqttc::Event;
@@ -91,6 +92,7 @@ impl ConnectCommand {
         let config = &self.config;
         let bridge_config = bridge_config(config, &self.cloud)?;
         let updated_mosquitto_config = CommonMosquittoConfig::from_tedge_config(config);
+        let credentials_path = credentials_path_for(config, &self.cloud)?;
 
         validate_config(config, &self.cloud)?;
 
@@ -100,6 +102,7 @@ impl ConnectCommand {
                 &bridge_config,
                 &*self.service_manager,
                 &self.cloud,
+                credentials_path,
             );
             // If the bridge is part of the mapper, the bridge config file won't exist
             // TODO tidy me up once mosquitto is no longer required for bridge
@@ -134,7 +137,13 @@ impl ConnectCommand {
             false => format!("Connecting to {} with config", self.cloud),
             true => "Reconnecting with config".into(),
         };
-        ConfigLogger::log(title, &bridge_config, &*self.service_manager, &self.cloud);
+        ConfigLogger::log(
+            title,
+            &bridge_config,
+            &*self.service_manager,
+            &self.cloud,
+            credentials_path,
+        );
 
         let device_type = &config.device.ty;
 
@@ -202,6 +211,18 @@ impl ConnectCommand {
     }
 }
 
+fn credentials_path_for<'a>(
+    config: &'a TEdgeConfig,
+    cloud: &Cloud,
+) -> Result<Option<&'a Utf8Path>, MultiError> {
+    if let Cloud::C8y(profile) = cloud {
+        let c8y_config = config.c8y.try_get(profile.as_deref())?;
+        Ok(Some(&c8y_config.credentials_path))
+    } else {
+        Ok(None)
+    }
+}
+
 impl ConnectCommand {
     fn tenant_matches_configured_url(
         &self,

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

@@ -7,6 +7,7 @@ use std::time::Instant;
 
 use camino::Utf8Path;
 use tedge_config::auth_method::AuthMethod;
+use tedge_config::auth_method::AuthType;
 use tedge_config::system_services::SystemServiceError;
 use tedge_config::system_services::SystemServiceManager;
 use tedge_config::MultiError;
@@ -251,6 +252,7 @@ pub struct ConfigLogger<'a> {
     service_manager: &'a dyn SystemServiceManager,
     mosquitto_version: Option<&'a str>,
     cloud: &'a MaybeBorrowedCloud<'a>,
+    credentials_path: Option<&'a Utf8Path>,
 }
 
 impl<'a> ConfigLogger<'a> {
@@ -260,6 +262,7 @@ impl<'a> ConfigLogger<'a> {
         config: &'a BridgeConfig,
         service_manager: &'a dyn SystemServiceManager,
         cloud: &'a MaybeBorrowedCloud<'a>,
+        credentials_path: Option<&'a Utf8Path>,
     ) {
         println!(
             "{}",
@@ -269,7 +272,8 @@ impl<'a> ConfigLogger<'a> {
                 cloud_host: config.address.to_string(),
                 cert_path: &config.bridge_certfile,
                 bridge_location: config.bridge_location,
-                auth_method: None,
+                auth_method: config.auth_method,
+                credentials_path,
                 service_manager,
                 mosquitto_version: config.mosquitto_version.as_deref(),
                 cloud,
@@ -302,16 +306,25 @@ impl fmt::Display for ConfigLogger<'_> {
             self.log_single_entry(f, "cloud profile", &"<none>")?;
         }
         self.log_single_entry(f, "cloud host", &self.cloud_host)?;
-        self.log_single_entry(f, "certificate file", &self.cert_path)?;
+        let mut auth_type = AuthType::Certificate;
+        if let Some(auth_method) = self.auth_method {
+            self.log_single_entry(f, "auth method", &auth_method)?;
+            if let Some(path) = self.credentials_path {
+                auth_type = auth_method.to_type(path);
+                if AuthType::Basic == auth_type {
+                    self.log_single_entry(f, "credentials path", &path)?
+                }
+            }
+        }
+        if AuthType::Certificate == auth_type {
+            self.log_single_entry(f, "certificate file", &self.cert_path)?;
+        }
         self.log_single_entry(f, "bridge", &self.bridge_location)?;
         self.log_single_entry(f, "service manager", &self.service_manager.name())?;
         if let Some(mosquitto_version) = self.mosquitto_version {
             self.log_single_entry(f, "mosquitto version", &mosquitto_version)?;
         }
 
-        if let Some(auth_method) = self.auth_method {
-            self.log_single_entry(f, "authentication mode", &auth_method)?;
-        }
         Ok(())
     }
 }