Merge pull request #2272 from multiversx/build-err-fix

sc-meta - build error fixes

Author: andrei-marinica

.github/workflows/actions.yml

@@ -65,7 +65,7 @@ jobs:
   generate-report:
     name: Generate Report
     needs: build-contracts
-    uses: multiversx/mx-sc-actions/.github/workflows/report.yml@v6.0.0
+    uses: multiversx/mx-sc-actions/.github/workflows/report.yml@739363a9614794fef598ab161498563969ea6437 # report fix, TODO: release v6.0.1
     with:
       rust-toolchain: 1.87
       runs-on: ubuntu-latest

framework/meta-lib/src/contract/meta_config.rs

@@ -114,7 +114,7 @@ impl MetaConfig {
         for contract_variant in &self.sc_config.contracts {
             contract_variant
                 .build_contract(&build_args, &self.output_dir)
-                .unwrap();
+                .unwrap_or_else(|err| panic!("{err}"));
         }
     }
 

framework/meta-lib/src/contract/sc_config/execute_command.rs

@@ -3,11 +3,34 @@ use std::fmt::Display;
 use std::fmt::Formatter;
 use std::process::{Command, ExitStatus, Stdio};
 
+use crate::print_util::format_command;
+
+/// Contains a description of the command, for error reporting purposes.
+#[derive(Clone, Debug)]
+pub struct CommandInfo {
+    command_string: String,
+}
+
+impl From<&mut Command> for CommandInfo {
+    fn from(command: &mut Command) -> Self {
+        CommandInfo {
+            command_string: format_command(command),
+        }
+    }
+}
+
+impl Display for CommandInfo {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.command_string)
+    }
+}
+
+/// Represents errors that can occur when executing system commands.
 #[derive(Debug)]
 pub enum ExecuteCommandError {
-    ErrorRunning(String),
-    JobFailed(String),
-    ErrorParsing(String),
+    ErrorRunning(CommandInfo),
+    JobFailed(CommandInfo),
+    ErrorParsing(CommandInfo),
     ErrorRunningBuildProcess,
 }
 
@@ -16,14 +39,15 @@ impl Error for ExecuteCommandError {}
 impl Display for ExecuteCommandError {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         let message = match self {
-            ExecuteCommandError::ErrorRunning(job) => format!(
-                "Error running {}: ensure it is installed and available in your system PATH.",
-                job
+            ExecuteCommandError::ErrorRunning(command_info) => format!(
+                "Error running `{command_info}`: ensure it is installed and available in your system PATH.",
             ),
-            ExecuteCommandError::JobFailed(job) => {
-                format!("Job {} failed.", job)
+            ExecuteCommandError::JobFailed(command_info) => {
+                format!("Job failed, command: `{command_info}`")
+            }
+            ExecuteCommandError::ErrorParsing(command_info) => {
+                format!("Error parsing output of `{command_info}`")
             }
-            ExecuteCommandError::ErrorParsing(job) => format!("Error parsing {} output", job),
             ExecuteCommandError::ErrorRunningBuildProcess => {
                 "contract build process was not running".to_string()
             }
@@ -32,25 +56,21 @@ impl Display for ExecuteCommandError {
     }
 }
 
-pub(crate) fn execute_command(
-    command: &mut Command,
-    job: &str,
-) -> Result<String, ExecuteCommandError> {
+pub(crate) fn execute_command(command: &mut Command) -> Result<String, ExecuteCommandError> {
     let output = command
         .stderr(Stdio::inherit())
         .output()
-        .map_err(|_| ExecuteCommandError::ErrorRunning(job.to_string()))?;
+        .map_err(|_| ExecuteCommandError::ErrorRunning(command.into()))?;
 
     if !output.status.success() {
-        return Err(ExecuteCommandError::JobFailed(job.to_string()));
+        return Err(ExecuteCommandError::JobFailed(command.into()));
     }
 
-    String::from_utf8(output.stdout).map_err(|_| ExecuteCommandError::ErrorParsing(job.to_string()))
+    String::from_utf8(output.stdout).map_err(|_| ExecuteCommandError::ErrorParsing(command.into()))
 }
 
 pub(crate) fn execute_spawn_command(
     command: &mut Command,
-    job: &str,
 ) -> Result<ExitStatus, ExecuteCommandError> {
     let response = command
         .spawn()
@@ -59,7 +79,7 @@ pub(crate) fn execute_spawn_command(
         .map_err(|_| ExecuteCommandError::ErrorRunningBuildProcess)?;
 
     if !response.success() {
-        return Err(ExecuteCommandError::JobFailed(job.to_string()));
+        return Err(ExecuteCommandError::JobFailed(command.into()));
     }
 
     Ok(response)

framework/meta-lib/src/contract/sc_config/wasm_build.rs

@@ -31,20 +31,24 @@ impl ContractVariant {
 
         print_build_command(self.wasm_output_name(build_args), &build_command);
 
-        let output_build_command = execute_spawn_command(&mut build_command, "cargo");
+        let build_command_output = execute_spawn_command(&mut build_command);
 
-        match output_build_command {
+        match build_command_output {
             Ok(_) => {}
-            Err(ExecuteCommandError::JobFailed(_)) => {
+            Err(ExecuteCommandError::JobFailed(err)) => {
                 if !self.is_target_installed() {
+                    // the target not being installed is a common cause of build failure,
+                    // so we try to install it automatically
                     self.install_wasm_target();
 
-                    execute_spawn_command(&mut build_command, "cargo")
-                        .expect("error building contract");
+                    // try again after installing the target
+                    execute_spawn_command(&mut build_command)?;
+                } else {
+                    return Err(ExecuteCommandError::JobFailed(err));
                 }
             }
-            Err(_) => {
-                panic!("error building contract");
+            Err(err) => {
+                return Err(err);
             }
         }
 

framework/meta-lib/src/tools/build_target.rs

@@ -47,7 +47,7 @@ pub fn is_target_installed(rustc_version: &RustcVersion, target_name: &str) -> b
 
     print_util::print_rustup_check_target(rustc_version, target_name, &cmd);
 
-    let output_rustup_command = execute_command(&mut cmd, "rustup");
+    let output_rustup_command = execute_command(&mut cmd);
     let str_output_rustup = match output_rustup_command {
         Ok(output) => output,
         Err(err) => {

framework/meta/src/cmd/check_wasmer_dependencies.rs

@@ -17,7 +17,7 @@ pub fn check_wasmer_dependencies(path: &Path) {
     let mut command = Command::new(cargo);
     command.arg("tree").arg("-e").arg("features");
 
-    match execute_command(&mut command, path, "cargo") {
+    match execute_command(&mut command, path) {
         Ok(output) => {
             if output.contains(WASMER_CRATE_NAME) && output.contains(WASMER_EXPERIMENTAL_CRATE_NAME)
             {
@@ -36,20 +36,16 @@ pub fn check_wasmer_dependencies(path: &Path) {
     };
 }
 
-fn execute_command(
-    command: &mut Command,
-    path: &Path,
-    job: &str,
-) -> Result<String, ExecuteCommandError> {
+fn execute_command(command: &mut Command, path: &Path) -> Result<String, ExecuteCommandError> {
     let output = command
         .current_dir(path)
         .stderr(Stdio::inherit())
         .output()
-        .map_err(|_| ExecuteCommandError::ErrorRunning(job.to_string()))?;
+        .map_err(|_| ExecuteCommandError::ErrorRunning(command.into()))?;
 
     if !output.status.success() {
-        return Err(ExecuteCommandError::JobFailed(job.to_string()));
+        return Err(ExecuteCommandError::JobFailed(command.into()));
     }
 
-    String::from_utf8(output.stdout).map_err(|_| ExecuteCommandError::ErrorParsing(job.to_string()))
+    String::from_utf8(output.stdout).map_err(|_| ExecuteCommandError::ErrorParsing(command.into()))
 }

framework/meta/src/cmd/template/contract_creator.rs

@@ -1,5 +1,3 @@
-use convert_case::{Case, Casing};
-
 use crate::{cli::TemplateArgs, version::FrameworkVersion, version_history::LAST_TEMPLATE_VERSION};
 
 use super::{
@@ -26,17 +24,9 @@ pub async fn create_contract(args: &TemplateArgs) {
 }
 
 fn target_from_args(args: &TemplateArgs) -> ContractCreatorTarget {
-    let new_name = args
-        .name
-        .as_deref()
-        .unwrap_or(&args.template)
-        .to_case(Case::Kebab);
-
     let target_path = args.path.clone().unwrap_or_default();
-    ContractCreatorTarget {
-        target_path,
-        new_name,
-    }
+    let new_name = args.name.as_deref().unwrap_or(&args.template);
+    ContractCreatorTarget::new(target_path, new_name)
 }
 
 pub(crate) fn get_repo_version(args_tag: &Option<String>) -> RepoVersion {

framework/meta/src/cmd/template/contract_creator_target.rs

@@ -1,12 +1,22 @@
 use std::path::PathBuf;
 
+use convert_case::{Case, Casing};
+
 #[derive(Clone)]
 pub struct ContractCreatorTarget {
     pub target_path: PathBuf,
     pub new_name: String,
 }
 
 impl ContractCreatorTarget {
+    /// Will convert new_name to kebab-case.
+    pub fn new(contract_dir: PathBuf, new_name: &str) -> Self {
+        Self {
+            target_path: contract_dir,
+            new_name: new_name.to_case(Case::Kebab),
+        }
+    }
+
     pub fn contract_dir(&self) -> PathBuf {
         self.target_path.join(&self.new_name)
     }