Deprecate tedge::command::BuildContext

didier-wenzek · didier-wenzek · commit 9b87ef61a0b3 · 2025-03-19T15:44:52.000+01:00
Now the commands are directly given the config instead of a way to build
the config. As some commands have to update the config
(notably `tedge config set`), the command are given not only the config
but also the location of that config.

Signed-off-by: Didier Wenzek &lt;didier.wenzek@free.fr&gt;
diff --git a/crates/core/tedge/src/cli/certificate/cli.rs b/crates/core/tedge/src/cli/certificate/cli.rs
@@ -11,11 +11,11 @@ use clap::ValueHint;
 use tedge_config::tedge_toml::OptionalConfigError;
 use tedge_config::tedge_toml::ProfileName;
 use tedge_config::TEdgeConfig;
+use tedge_config::TEdgeConfigLocation;
 
 use crate::cli::common::Cloud;
 use crate::cli::common::CloudArg;
 use crate::command::BuildCommand;
-use crate::command::BuildContext;
 use crate::command::Command;
 use crate::ConfigError;
 
@@ -69,8 +69,11 @@ pub enum TEdgeCertCli {
 }
 
 impl BuildCommand for TEdgeCertCli {
-    fn build_command(self, context: BuildContext) -> Result<Box<dyn Command>, ConfigError> {
-        let config = context.load_config()?;
+    fn build_command(
+        self,
+        config: TEdgeConfig,
+        _: TEdgeConfigLocation,
+    ) -> Result<Box<dyn Command>, ConfigError> {
         let (user, group) = if config.mqtt.bridge.built_in {
             ("tedge", "tedge")
         } else {
diff --git a/crates/core/tedge/src/cli/completions.rs b/crates/core/tedge/src/cli/completions.rs
@@ -1,10 +1,11 @@
 use super::TEdgeCli;
 use crate::command::BuildCommand;
-use crate::command::BuildContext;
 use crate::command::Command;
 use crate::ConfigError;
 use clap::CommandFactory;
 use std::io;
+use tedge_config::TEdgeConfig;
+use tedge_config::TEdgeConfigLocation;
 
 #[derive(clap::ValueEnum, Clone, Copy, Debug, strum_macros::Display)]
 #[strum(serialize_all = "snake_case")]
@@ -36,7 +37,11 @@ impl From<Shell> for Box<dyn clap_complete::env::EnvCompleter> {
 }
 
 impl BuildCommand for Shell {
-    fn build_command(self, _: BuildContext) -> Result<Box<dyn Command>, ConfigError> {
+    fn build_command(
+        self,
+        _: TEdgeConfig,
+        _: TEdgeConfigLocation,
+    ) -> Result<Box<dyn Command>, ConfigError> {
         Ok(Box::new(CompletionsCmd { shell: self }))
     }
 }
diff --git a/crates/core/tedge/src/cli/config/cli.rs b/crates/core/tedge/src/cli/config/cli.rs
@@ -6,6 +6,8 @@ use clap_complete::ArgValueCandidates;
 use tedge_config::tedge_toml::ProfileName;
 use tedge_config::tedge_toml::ReadableKey;
 use tedge_config::tedge_toml::WritableKey;
+use tedge_config::TEdgeConfig;
+use tedge_config::TEdgeConfigLocation;
 
 #[derive(clap::Subcommand, Debug)]
 pub enum ConfigCmd {
@@ -132,9 +134,11 @@ macro_rules! try_with_profile {
 }
 
 impl BuildCommand for ConfigCmd {
-    fn build_command(self, context: BuildContext) -> Result<Box<dyn Command>, ConfigError> {
-        let config_location = context.config_location;
-
+    fn build_command(
+        self,
+        _: TEdgeConfig,
+        config_location: TEdgeConfigLocation,
+    ) -> Result<Box<dyn Command>, ConfigError> {
         match self {
             ConfigCmd::Get { key, profile } => Ok(GetConfigCommand {
                 key: try_with_profile!(key, profile),
diff --git a/crates/core/tedge/src/cli/connect/cli.rs b/crates/core/tedge/src/cli/connect/cli.rs
@@ -1,9 +1,10 @@
 use crate::cli::common::CloudArg;
 use crate::cli::connect::*;
 use crate::command::BuildCommand;
-use crate::command::BuildContext;
 use crate::command::Command;
 use crate::system_services::service_manager;
+use tedge_config::TEdgeConfig;
+use tedge_config::TEdgeConfigLocation;
 
 #[derive(clap::Args, Debug, Eq, PartialEq)]
 pub struct TEdgeConnectOpt {
@@ -20,19 +21,23 @@ pub struct TEdgeConnectOpt {
 }
 
 impl BuildCommand for TEdgeConnectOpt {
-    fn build_command(self, context: BuildContext) -> Result<Box<dyn Command>, crate::ConfigError> {
+    fn build_command(
+        self,
+        config: TEdgeConfig,
+        config_location: TEdgeConfigLocation,
+    ) -> Result<Box<dyn Command>, crate::ConfigError> {
         let Self {
             is_test_connection,
             offline_mode,
             cloud,
         } = self;
         Ok(Box::new(ConnectCommand {
-            config_location: context.config_location.clone(),
-            config: context.load_config()?,
+            config_location: config_location.clone(),
+            config,
             cloud: cloud.try_into()?,
             is_test_connection,
             offline_mode,
-            service_manager: service_manager(&context.config_location.tedge_config_root_path)?,
+            service_manager: service_manager(&config_location.tedge_config_root_path)?,
             is_reconnect: false,
         }))
     }
diff --git a/crates/core/tedge/src/cli/disconnect/cli.rs b/crates/core/tedge/src/cli/disconnect/cli.rs
@@ -2,6 +2,8 @@ use crate::cli::common::CloudArg;
 use crate::cli::disconnect::disconnect_bridge::*;
 use crate::command::*;
 use crate::system_services::service_manager;
+use tedge_config::TEdgeConfig;
+use tedge_config::TEdgeConfigLocation;
 
 #[derive(clap::Args, Debug)]
 pub struct TEdgeDisconnectBridgeCli {
@@ -10,12 +12,16 @@ pub struct TEdgeDisconnectBridgeCli {
 }
 
 impl BuildCommand for TEdgeDisconnectBridgeCli {
-    fn build_command(self, context: BuildContext) -> Result<Box<dyn Command>, crate::ConfigError> {
+    fn build_command(
+        self,
+        _: TEdgeConfig,
+        config_location: TEdgeConfigLocation,
+    ) -> Result<Box<dyn Command>, crate::ConfigError> {
         let cmd = DisconnectBridgeCommand {
-            config_location: context.config_location.clone(),
+            config_location: config_location.clone(),
             cloud: self.cloud.try_into()?,
             use_mapper: true,
-            service_manager: service_manager(&context.config_location.tedge_config_root_path)?,
+            service_manager: service_manager(&config_location.tedge_config_root_path)?,
         };
         Ok(cmd.into_boxed())
     }
diff --git a/crates/core/tedge/src/cli/http/cli.rs b/crates/core/tedge/src/cli/http/cli.rs
@@ -1,7 +1,6 @@
 use crate::cli::http::command::HttpAction;
 use crate::cli::http::command::HttpCommand;
 use crate::command::BuildCommand;
-use crate::command::BuildContext;
 use crate::command::Command;
 use crate::ConfigError;
 use anyhow::anyhow;
@@ -14,6 +13,8 @@ use reqwest::Client;
 use reqwest::Identity;
 use tedge_config::tedge_toml::ProfileName;
 use tedge_config::OptionalConfig;
+use tedge_config::TEdgeConfig;
+use tedge_config::TEdgeConfigLocation;
 use tokio::fs::File;
 
 #[derive(clap::Subcommand, Debug)]
@@ -194,8 +195,11 @@ impl Content {
 }
 
 impl BuildCommand for TEdgeHttpCli {
-    fn build_command(self, context: BuildContext) -> Result<Box<dyn Command>, ConfigError> {
-        let config = context.load_config()?;
+    fn build_command(
+        self,
+        config: TEdgeConfig,
+        _: TEdgeConfigLocation,
+    ) -> Result<Box<dyn Command>, ConfigError> {
         let uri = self.uri();
 
         let (protocol, host, port) = if uri.starts_with("/c8y") {
diff --git a/crates/core/tedge/src/cli/init.rs b/crates/core/tedge/src/cli/init.rs
@@ -1,4 +1,4 @@
-use crate::command::BuildContext;
+use super::log::MaybeFancy;
 use crate::command::Command;
 use crate::Component;
 use anyhow::bail;
@@ -8,28 +8,35 @@ use std::io::ErrorKind;
 use std::os::unix::fs::MetadataExt;
 use std::path::Path;
 use std::path::PathBuf;
+use tedge_config::TEdgeConfig;
+use tedge_config::TEdgeConfigLocation;
 use tedge_utils::file::change_user_and_group;
 use tedge_utils::file::create_directory;
 use tedge_utils::file::PermissionEntry;
 use tracing::debug;
 
-use super::log::MaybeFancy;
-
-#[derive(Debug)]
 pub struct TEdgeInitCmd {
     user: String,
     group: String,
     relative_links: bool,
-    context: BuildContext,
+    config_location: TEdgeConfigLocation,
+    config: TEdgeConfig,
 }
 
 impl TEdgeInitCmd {
-    pub fn new(user: String, group: String, relative_links: bool, context: BuildContext) -> Self {
+    pub fn new(
+        user: String,
+        group: String,
+        relative_links: bool,
+        config: TEdgeConfig,
+        config_location: TEdgeConfigLocation,
+    ) -> Self {
         Self {
             user,
             group,
             relative_links,
-            context,
+            config_location,
+            config,
         }
     }
 }
@@ -79,7 +86,7 @@ impl TEdgeInitCmd {
             create_symlinks_for(component, target, executable_dir, &RealEnv).await?;
         }
 
-        let config_dir = self.context.config_location.tedge_config_root_path.clone();
+        let config_dir = self.config_location.tedge_config_root_path.clone();
         let permissions = {
             PermissionEntry::new(
                 Some(self.user.clone()),
@@ -96,7 +103,7 @@ impl TEdgeInitCmd {
         create_directory(config_dir.join("device-certs"), &permissions).await?;
         create_directory(config_dir.join(".tedge-mapper-c8y"), &permissions).await?;
 
-        let config = self.context.load_config()?;
+        let config = &self.config;
 
         create_directory(&config.logs.path, &permissions).await?;
         create_directory(&config.data.path, &permissions).await?;
diff --git a/crates/core/tedge/src/cli/mod.rs b/crates/core/tedge/src/cli/mod.rs
@@ -1,7 +1,6 @@
 pub use self::certificate::*;
 use self::refresh_bridges::RefreshBridgesCmd;
 use crate::command::BuildCommand;
-use crate::command::BuildContext;
 use crate::command::Command;
 use c8y_firmware_plugin::FirmwarePluginOpt;
 use c8y_remote_access_plugin::C8yRemoteAccessPluginOpt;
@@ -10,6 +9,8 @@ pub use connect::*;
 use tedge_agent::AgentOpt;
 use tedge_apt_plugin::AptCli;
 use tedge_config::cli::CommonArgs;
+use tedge_config::TEdgeConfig;
+use tedge_config::TEdgeConfigLocation;
 use tedge_mapper::MapperOpt;
 use tedge_watchdog::WatchdogOpt;
 use tedge_write::bin::Args as TedgeWriteOpt;
@@ -182,7 +183,11 @@ fn styles() -> clap::builder::Styles {
 }
 
 impl BuildCommand for TEdgeOpt {
-    fn build_command(self, context: BuildContext) -> Result<Box<dyn Command>, crate::ConfigError> {
+    fn build_command(
+        self,
+        config: TEdgeConfig,
+        config_location: TEdgeConfigLocation,
+    ) -> Result<Box<dyn Command>, crate::ConfigError> {
         match self {
             TEdgeOpt::Init {
                 user,
@@ -192,22 +197,25 @@ impl BuildCommand for TEdgeOpt {
                 user,
                 group,
                 relative_links,
-                context,
+                config,
+                config_location,
             ))),
-            TEdgeOpt::Upload(opt) => opt.build_command(context),
-            TEdgeOpt::Cert(opt) => opt.build_command(context),
-            TEdgeOpt::Config(opt) => opt.build_command(context),
-            TEdgeOpt::Connect(opt) => opt.build_command(context),
-            TEdgeOpt::Disconnect(opt) => opt.build_command(context),
-            TEdgeOpt::RefreshBridges => RefreshBridgesCmd::new(&context).map(Command::into_boxed),
-            TEdgeOpt::Mqtt(opt) => opt.build_command(context),
-            TEdgeOpt::Http(opt) => opt.build_command(context),
-            TEdgeOpt::Reconnect(opt) => opt.build_command(context),
+            TEdgeOpt::Upload(opt) => opt.build_command(config, config_location),
+            TEdgeOpt::Cert(opt) => opt.build_command(config, config_location),
+            TEdgeOpt::Config(opt) => opt.build_command(config, config_location),
+            TEdgeOpt::Connect(opt) => opt.build_command(config, config_location),
+            TEdgeOpt::Disconnect(opt) => opt.build_command(config, config_location),
+            TEdgeOpt::RefreshBridges => {
+                RefreshBridgesCmd::new(config, config_location).map(Command::into_boxed)
+            }
+            TEdgeOpt::Mqtt(opt) => opt.build_command(config, config_location),
+            TEdgeOpt::Http(opt) => opt.build_command(config, config_location),
+            TEdgeOpt::Reconnect(opt) => opt.build_command(config, config_location),
             TEdgeOpt::Run(_) => {
                 // This method has to be kept in sync with tedge::redirect_if_multicall()
                 panic!("tedge mapper|agent|write commands are launched as multicall")
             }
-            TEdgeOpt::Completions { shell } => shell.build_command(context),
+            TEdgeOpt::Completions { shell } => shell.build_command(config, config_location),
         }
     }
 }
diff --git a/crates/core/tedge/src/cli/mqtt/cli.rs b/crates/core/tedge/src/cli/mqtt/cli.rs
@@ -2,13 +2,14 @@ use crate::cli::mqtt::publish::MqttPublishCommand;
 use crate::cli::mqtt::subscribe::MqttSubscribeCommand;
 use crate::cli::mqtt::subscribe::SimpleTopicFilter;
 use crate::command::BuildCommand;
-use crate::command::BuildContext;
 use crate::command::Command;
 use clap_complete::ArgValueCandidates;
 use clap_complete::CompletionCandidate;
 use mqtt_channel::Topic;
 use rumqttc::QoS;
 use tedge_config::models::SecondsOrHumanTime;
+use tedge_config::TEdgeConfig;
+use tedge_config::TEdgeConfigLocation;
 
 const PUB_CLIENT_PREFIX: &str = "tedge-pub";
 const SUB_CLIENT_PREFIX: &str = "tedge-sub";
@@ -55,8 +56,11 @@ pub enum TEdgeMqttCli {
 }
 
 impl BuildCommand for TEdgeMqttCli {
-    fn build_command(self, context: BuildContext) -> Result<Box<dyn Command>, crate::ConfigError> {
-        let config = context.load_config()?;
+    fn build_command(
+        self,
+        config: TEdgeConfig,
+        _: TEdgeConfigLocation,
+    ) -> Result<Box<dyn Command>, crate::ConfigError> {
         let auth_config = config.mqtt_client_auth_config();
 
         let cmd = {
diff --git a/crates/core/tedge/src/cli/reconnect/cli.rs b/crates/core/tedge/src/cli/reconnect/cli.rs
@@ -2,6 +2,8 @@ use super::command::ReconnectBridgeCommand;
 use crate::cli::common::CloudArg;
 use crate::command::*;
 use crate::system_services::service_manager;
+use tedge_config::TEdgeConfig;
+use tedge_config::TEdgeConfigLocation;
 
 #[derive(clap::Args, Debug)]
 pub struct TEdgeReconnectCli {
@@ -10,11 +12,15 @@ pub struct TEdgeReconnectCli {
 }
 
 impl BuildCommand for TEdgeReconnectCli {
-    fn build_command(self, context: BuildContext) -> Result<Box<dyn Command>, crate::ConfigError> {
+    fn build_command(
+        self,
+        config: TEdgeConfig,
+        config_location: TEdgeConfigLocation,
+    ) -> Result<Box<dyn Command>, crate::ConfigError> {
         Ok(ReconnectBridgeCommand {
-            config: context.load_config()?,
-            service_manager: service_manager(&context.config_location.tedge_config_root_path)?,
-            config_location: context.config_location,
+            config,
+            service_manager: service_manager(&config_location.tedge_config_root_path)?,
+            config_location,
             cloud: self.cloud.try_into()?,
             use_mapper: true,
         }
diff --git a/crates/core/tedge/src/cli/refresh_bridges.rs b/crates/core/tedge/src/cli/refresh_bridges.rs
@@ -10,7 +10,6 @@ use crate::bridge::BridgeConfig;
 use crate::bridge::BridgeLocation;
 use crate::bridge::CommonMosquittoConfig;
 use crate::bridge::TEDGE_BRIDGE_CONF_DIR_PATH;
-use crate::command::BuildContext;
 use crate::command::Command;
 use crate::system_services::service_manager;
 use crate::system_services::SystemService;
@@ -34,9 +33,10 @@ impl Command for RefreshBridgesCmd {
 }
 
 impl RefreshBridgesCmd {
-    pub fn new(context: &BuildContext) -> Result<Self, crate::ConfigError> {
-        let config = context.load_config()?;
-        let config_location = context.config_location.clone();
+    pub fn new(
+        config: TEdgeConfig,
+        config_location: TEdgeConfigLocation,
+    ) -> Result<Self, crate::ConfigError> {
         let service_manager = service_manager(&config_location.tedge_config_root_path)?;
 
         let cmd = Self {
diff --git a/crates/core/tedge/src/cli/upload/mod.rs b/crates/core/tedge/src/cli/upload/mod.rs
diff --git a/crates/core/tedge/src/command.rs b/crates/core/tedge/src/command.rs
diff --git a/crates/core/tedge/src/main.rs b/crates/core/tedge/src/main.rs
