fix(rust): propagate global options to commands run in the node configuration

Author: adrianbenavides

implementations/rust/ockam/ockam_command/src/global_args.rs

@@ -1,6 +1,7 @@
 use clap::Args;
 use clap::{ArgAction, ValueEnum};
 use ockam_api::output::OutputFormat;
+use std::fmt::Display;
 
 use ockam_core::env::get_env_with_default;
 
@@ -123,3 +124,12 @@ pub enum OutputFormatArg {
     Plain,
     Json,
 }
+
+impl Display for OutputFormatArg {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            OutputFormatArg::Plain => write!(f, "plain"),
+            OutputFormatArg::Json => write!(f, "json"),
+        }
+    }
+}

implementations/rust/ockam/ockam_command/src/node/create/config.rs

@@ -11,7 +11,7 @@ use miette::{miette, IntoDiagnostic};
 use ockam_api::cli_state::journeys::APPLICATION_EVENT_COMMAND_CONFIGURATION_FILE;
 use ockam_api::cli_state::random_name;
 use ockam_api::nodes::BackgroundNodeClient;
-use ockam_core::AsyncTryClone;
+use ockam_core::{AsyncTryClone, OpenTelemetryContext};
 use ockam_node::Context;
 use serde::{Deserialize, Serialize};
 use tracing::{debug, instrument, Span};
@@ -166,6 +166,12 @@ impl NodeConfig {
                 .clone()
                 .map(ArgValue::String);
         }
+        if self.node.opentelemetry_context.is_none() {
+            self.node.opentelemetry_context = Some(ArgValue::String(
+                serde_json::to_string(&OpenTelemetryContext::current()).into_diagnostic()?,
+            ));
+        }
+
         Ok(())
     }
 
@@ -189,7 +195,7 @@ impl NodeConfig {
         if self.project_enroll.ticket.is_some()
             && !self
                 .project_enroll
-                .run_in_subprocess(opts.global_args.quiet)?
+                .run_in_subprocess(&opts.global_args)?
                 .wait()
                 .await
                 .into_diagnostic()?
@@ -199,7 +205,7 @@ impl NodeConfig {
         }
 
         // Next, run the 'node create' command
-        let child = self.node.run_in_subprocess(opts.global_args.quiet)?;
+        let child = self.node.run_in_subprocess(&opts.global_args)?;
 
         // Wait for the node to be up
         let is_up = {

implementations/rust/ockam/ockam_command/src/run/parser/resource/node.rs

@@ -29,6 +29,8 @@ pub struct Node {
     pub http_server_port: Option<ArgValue>,
     pub identity: Option<ArgValue>,
     pub project: Option<ArgValue>,
+    #[serde(alias = "opentelemetry-context")]
+    pub opentelemetry_context: Option<ArgValue>,
 }
 
 impl Resource<CreateCommand> for Node {
@@ -66,6 +68,9 @@ impl Resource<CreateCommand> for Node {
         if let Some(project) = self.project {
             args.insert("project".to_string(), project);
         }
+        if let Some(opentelemetry_context) = self.opentelemetry_context {
+            args.insert("opentelemetry-context".to_string(), opentelemetry_context);
+        }
         if args.is_empty() {
             return vec![];
         }

implementations/rust/ockam/ockam_command/src/run/parser/resource/traits.rs

@@ -2,14 +2,13 @@ use std::process::Stdio;
 
 use async_trait::async_trait;
 use miette::{IntoDiagnostic, Result};
-use tokio::process::Child;
-use tracing::debug;
-
 use ockam_core::AsyncTryClone;
 use ockam_node::Context;
+use tokio::process::{Child, Command as ProcessCommand};
+use tracing::debug;
 
 use crate::run::parser::resource::utils::{binary_path, subprocess_stdio};
-use crate::{Command, CommandGlobalOpts};
+use crate::{Command, CommandGlobalOpts, GlobalArgs};
 
 /// This trait defines the methods that a resource must implement before it's parsed into a Command.
 ///
@@ -21,15 +20,31 @@ pub trait Resource<C: ParsedCommand>: Sized + Send + Sync + 'static {
         vec![]
     }
 
-    fn run_in_subprocess(self, quiet: bool) -> Result<Child> {
-        let args = self.args();
+    fn run_in_subprocess(self, global_args: &GlobalArgs) -> Result<Child> {
+        let mut args = self.args();
+        if global_args.quiet {
+            args.push("--quiet".to_string());
+        }
+        if global_args.no_color {
+            args.push("--no-color".to_string());
+        }
+        if global_args.no_input {
+            args.push("--no-input".to_string());
+        }
+        if global_args.verbose > 0 {
+            args.push(format!("-{}", "v".repeat(global_args.verbose as usize)));
+        }
+        if let Some(o) = &global_args.output_format {
+            args.push("--output".to_string());
+            args.push(o.to_string());
+        }
         let args = Self::COMMAND_NAME
             .split(' ')
             .chain(args.iter().map(|s| s.as_str()));
-        let handle = tokio::process::Command::new(binary_path())
+        let handle = ProcessCommand::new(binary_path())
             .args(args)
-            .stdout(subprocess_stdio(quiet))
-            .stderr(subprocess_stdio(quiet))
+            .stdout(subprocess_stdio(global_args.quiet))
+            .stderr(subprocess_stdio(global_args.quiet))
             .stdin(Stdio::null())
             .spawn()
             .into_diagnostic()?;