finish internationalization

Author: SteveL-MSFT

runcommandonset/Cargo.toml

@@ -12,7 +12,7 @@ lto = true
 
 [dependencies]
 clap = { version = "4.4", features = ["derive"] }
-rust-i18n = { version = "3" }
+rust-i18n = { version = "3.1" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0", features = ["preserve_order"] }
 tracing = { version = "0.1" }

runcommandonset/locales/en-us.toml

@@ -9,3 +9,14 @@ readStdin = "Reading input from STDIN"
 
 [runcommand]
 invalidJson = "Failed to serialize to JSON"
+
+[utils]
+executableRequired = "Executable is required when input is not provided via stdin"
+failedToExecute = "Failed to execute"
+failedOpenStderr = "Failed to open stderr for"
+failedOpenStdout = "Failed to open stdout for"
+failedReadStderr = "Failed to read stderr for"
+failedReadStdout = "Failed to read stdout for"
+failedWait = "Failed to wait for"
+invalidInput = "Input is not valid"
+unableToTrace = "Unable to set global default tracing subscriber.  Tracing is diabled."

runcommandonset/src/main.rs

@@ -2,22 +2,20 @@
 // Licensed under the MIT License.
 
 use clap::Parser;
+use rust_i18n::{i18n, t};
 use std::{io::{self, Read, IsTerminal}, process::exit};
-use tracing::{error, warn, debug};
+use tracing::{error, warn, debug, trace};
 
 use args::{Arguments, SubCommand, TraceLevel};
 use runcommand::RunCommand;
-//use rust_i18n::t;
 use utils::{enable_tracing, invoke_command, parse_input, EXIT_INVALID_ARGS};
 
-#[macro_use]
-extern crate rust_i18n;
-i18n!("locales", fallback = "en");
-
 pub mod args;
 pub mod runcommand;
 pub mod utils;
 
+i18n!("locales", fallback = "en");
+
 fn main() {
     let args = Arguments::parse();
     let trace_level = match args.trace_level {
@@ -32,6 +30,7 @@ fn main() {
                     "debug" => TraceLevel::Debug,
                     "trace" => TraceLevel::Trace,
                     _ => {
+                        //warn!("{}: {trace_level}", t!("main.invalidTraceLevel"));
                         warn!("{}: {trace_level}", t!("main.invalidTraceLevel"));
                         TraceLevel::Info
                     }
@@ -43,12 +42,12 @@ fn main() {
         }
     };
     enable_tracing(&trace_level, &args.trace_format);
-    warn!(t!("main.notIdempotent"));
+    warn!("{}", t!("main.notIdempotent"));
 
     let stdin = if std::io::stdin().is_terminal() {
         None
     } else {
-        debug!(t!("main.readStdin"));
+        debug!("{}", t!("main.readStdin"));
         let mut buffer: Vec<u8> = Vec::new();
         io::stdin().read_to_end(&mut buffer).unwrap();
         let stdin = match String::from_utf8(buffer) {
@@ -60,7 +59,7 @@ fn main() {
         };
         // parse_input expects at most 1 input, so wrapping Some(empty input) would throw it off
         if stdin.is_empty() {
-            debug!(t!("main.emptyStdin"));
+            debug!("{}", t!("main.emptyStdin"));
             None
         }
         else {
@@ -77,9 +76,8 @@ fn main() {
         SubCommand::Set { arguments, executable, exit_code } => {
             command = parse_input(arguments, executable, exit_code, stdin);
             let (exit_code, stdout, stderr) = invoke_command(command.executable.as_ref(), command.arguments.clone());
-            // TODO: convert this to tracing json once other PR is merged to handle tracing from resources
-            eprintln!("Stdout: {stdout}");
-            eprintln!("Stderr: {stderr}");
+            trace!("Stdout: {stdout}");
+            trace!("Stderr: {stderr}");
             command.exit_code = exit_code;
         }
     }

runcommandonset/src/utils.rs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+use rust_i18n::t;
 use std::{io::Read, process::{Command, exit, Stdio}};
 use tracing::{Level, error, debug, trace};
 use tracing_subscriber::{filter::EnvFilter, layer::SubscriberExt, Layer};
@@ -33,7 +34,7 @@ pub fn parse_input(arguments: Option<Vec<String>>, executable: Option<String>, e
         command = match serde_json::from_str(&input) {
             Ok(json) => json,
             Err(err) => {
-                error!("Error: Input is not valid: {err}");
+                error!("{}: {err}", t!("utils.invalidInput"));
                 exit(EXIT_INVALID_INPUT);
             }
         }
@@ -45,7 +46,7 @@ pub fn parse_input(arguments: Option<Vec<String>>, executable: Option<String>, e
         };
     }
     else {
-        error!("Error: Executable is required when input is not provided via stdin");
+        error!("{}", t!("utils.executableRequired"));
         exit(EXIT_INVALID_INPUT);
     }
     command
@@ -72,7 +73,7 @@ pub fn enable_tracing(trace_level: &TraceLevel, trace_format: &TraceFormat) {
     };
 
     let filter = EnvFilter::try_from_default_env()
-        .or_else(|_| EnvFilter::try_new("warning"))
+        .or_else(|_| EnvFilter::try_new("warn"))
         .unwrap_or_default()
         .add_directive(tracing_level.into());
     let layer = tracing_subscriber::fmt::Layer::default().with_writer(std::io::stderr);
@@ -104,7 +105,7 @@ pub fn enable_tracing(trace_level: &TraceLevel, trace_format: &TraceFormat) {
     let subscriber = tracing_subscriber::Registry::default().with(fmt).with(filter);
 
     if tracing::subscriber::set_global_default(subscriber).is_err() {
-        eprintln!("Unable to set global default tracing subscriber.  Tracing is diabled.");
+        eprintln!("{}", t!("utils.unableToTrace"));
     }
 }
 
@@ -132,41 +133,41 @@ pub fn invoke_command(executable: &str, args: Option<Vec<String>>) -> (i32, Stri
     let mut child = match command.spawn() {
         Ok(child) => child,
         Err(e) => {
-            error!("Failed to execute {}: {e}", executable);
+            error!("{} '{executable}': {e}", t!("utils.failedToExecute"));
             exit(EXIT_DSC_ERROR);
         }
     };
 
     let Some(mut child_stdout) = child.stdout.take() else {
-        error!("Failed to open stdout for {}", executable);
+        error!("{} {executable}", t!("utils.failedOpenStdout"));
         exit(EXIT_DSC_ERROR);
     };
     let mut stdout_buf = Vec::new();
     match child_stdout.read_to_end(&mut stdout_buf) {
         Ok(_) => (),
         Err(e) => {
-            error!("Failed to read stdout for {}: {e}", executable);
+            error!("{} '{executable}': {e}", t!("utils.failedReadStdout"));
             exit(EXIT_DSC_ERROR);
         }
     }
 
     let Some(mut child_stderr) = child.stderr.take() else {
-        error!("Failed to open stderr for {}", executable);
+        error!("{} {executable}", t!("utils.failedOpenStderr"));
         exit(EXIT_DSC_ERROR);
     };
     let mut stderr_buf = Vec::new();
     match child_stderr.read_to_end(&mut stderr_buf) {
         Ok(_) => (),
         Err(e) => {
-            error!("Failed to read stderr for {}: {e}", executable);
+            error!("{} '{executable}': {e}", t!("utils.failedReadStderr"));
             exit(EXIT_DSC_ERROR);
         }
     }
 
     let exit_status = match child.wait() {
         Ok(exit_status) => exit_status,
         Err(e) => {
-            error!("Failed to wait for {}: {e}", executable);
+            error!("{} '{executable}': {e}", t!("utils.failedWait"));
             exit(EXIT_DSC_ERROR);
         }
     };