From 66a3d02b4585a76615d750c33a37edd5e8fd30e6 Mon Sep 17 00:00:00 2001 From: datdenkikniet Date: Sun, 16 Apr 2023 11:02:49 +0200 Subject: Rename cargo_commands -> run Rename command -> cargo_command --- xtask/src/command.rs | 801 --------------------------------------------------- 1 file changed, 801 deletions(-) delete mode 100644 xtask/src/command.rs (limited to 'xtask/src/command.rs') diff --git a/xtask/src/command.rs b/xtask/src/command.rs deleted file mode 100644 index 33d0703..0000000 --- a/xtask/src/command.rs +++ /dev/null @@ -1,801 +0,0 @@ -use log::{error, info, Level}; - -use crate::{ - argument_parsing::Globals, cargo_commands::FinalRunResult, ExtraArguments, RunResult, Target, - TestRunError, -}; -use core::fmt; -use std::{ - fs::File, - io::Read, - path::PathBuf, - process::{Command, Stdio}, -}; - -#[allow(dead_code)] -#[derive(Debug, Clone, Copy, PartialEq)] -pub enum BuildMode { - Release, - Debug, -} - -#[derive(Debug, Clone, Copy, PartialEq)] -pub enum OutputMode { - PipedAndCollected, - Inherited, -} - -impl From for Stdio { - fn from(value: OutputMode) -> Self { - match value { - OutputMode::PipedAndCollected => Stdio::piped(), - OutputMode::Inherited => Stdio::inherit(), - } - } -} - -#[derive(Debug)] -pub enum CargoCommand<'a> { - // For future embedded-ci - #[allow(dead_code)] - Run { - cargoarg: &'a Option<&'a str>, - example: &'a str, - target: Option>, - features: Option, - mode: BuildMode, - dir: Option, - }, - Qemu { - cargoarg: &'a Option<&'a str>, - example: &'a str, - target: Option>, - features: Option, - mode: BuildMode, - dir: Option, - }, - ExampleBuild { - cargoarg: &'a Option<&'a str>, - example: &'a str, - target: Option>, - features: Option, - mode: BuildMode, - dir: Option, - }, - ExampleCheck { - cargoarg: &'a Option<&'a str>, - example: &'a str, - target: Option>, - features: Option, - mode: BuildMode, - }, - Build { - cargoarg: &'a Option<&'a str>, - package: Option, - target: Option>, - features: Option, - mode: BuildMode, - dir: Option, - }, - Check { - cargoarg: &'a Option<&'a str>, - package: Option, - target: Option>, - features: Option, - mode: BuildMode, - dir: Option, - }, - Clippy { - cargoarg: &'a Option<&'a str>, - package: Option, - target: Option>, - features: Option, - }, - Format { - cargoarg: &'a Option<&'a str>, - package: Option, - check_only: bool, - }, - Doc { - cargoarg: &'a Option<&'a str>, - features: Option, - arguments: Option, - }, - Test { - package: Option, - features: Option, - test: Option, - }, - Book { - arguments: Option, - }, - ExampleSize { - cargoarg: &'a Option<&'a str>, - example: &'a str, - target: Option>, - features: Option, - mode: BuildMode, - arguments: Option, - dir: Option, - }, -} - -impl core::fmt::Display for CargoCommand<'_> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - fn p(p: &Option) -> String { - if let Some(package) = p { - format!("package {package}") - } else { - format!("default package") - } - } - - fn feat(f: &Option) -> String { - if let Some(features) = f { - format!("\"{features}\"") - } else { - format!("no features") - } - } - - fn carg(f: &&Option<&str>) -> String { - if let Some(cargoarg) = f { - format!("{cargoarg}") - } else { - format!("no cargo args") - } - } - - fn details( - target: &Option, - mode: Option<&BuildMode>, - features: &Option, - cargoarg: &&Option<&str>, - path: Option<&PathBuf>, - ) -> String { - let feat = feat(features); - let carg = carg(cargoarg); - let in_dir = if let Some(path) = path { - let path = path.to_str().unwrap_or(""); - format!("in {path}") - } else { - format!("") - }; - - let target = if let Some(target) = target { - format!("{target}") - } else { - format!("") - }; - - let mode = if let Some(mode) = mode { - format!("{mode}") - } else { - format!("debug") - }; - - if cargoarg.is_some() && path.is_some() { - format!("({target}, {mode}, {feat}, {carg}, {in_dir})") - } else if cargoarg.is_some() { - format!("({target}, {mode}, {feat}, {carg})") - } else if path.is_some() { - format!("({target}, {mode}, {feat}, {in_dir})") - } else { - format!("({target}, {mode}, {feat})") - } - } - - match self { - CargoCommand::Run { - cargoarg, - example, - target, - features, - mode, - dir, - } => { - write!( - f, - "Run example {example} {}", - details(target, Some(mode), features, cargoarg, dir.as_ref()) - ) - } - CargoCommand::Qemu { - cargoarg, - example, - target, - features, - mode, - dir, - } => { - let details = details(target, Some(mode), features, cargoarg, dir.as_ref()); - write!(f, "Run example {example} in QEMU {details}",) - } - CargoCommand::ExampleBuild { - cargoarg, - example, - target, - features, - mode, - dir, - } => { - let details = details(target, Some(mode), features, cargoarg, dir.as_ref()); - write!(f, "Build example {example} {details}",) - } - CargoCommand::ExampleCheck { - cargoarg, - example, - target, - features, - mode, - } => write!( - f, - "Check example {example} {}", - details(target, Some(mode), features, cargoarg, None) - ), - CargoCommand::Build { - cargoarg, - package, - target, - features, - mode, - dir, - } => { - let package = p(package); - write!( - f, - "Build {package} {}", - details(target, Some(mode), features, cargoarg, dir.as_ref()) - ) - } - - CargoCommand::Check { - cargoarg, - package, - target, - features, - mode, - dir, - } => { - let package = p(package); - write!( - f, - "Check {package} {}", - details(target, Some(mode), features, cargoarg, dir.as_ref()) - ) - } - CargoCommand::Clippy { - cargoarg, - package, - target, - features, - } => { - let details = details(target, None, features, cargoarg, None); - let package = p(package); - write!(f, "Clippy {package} {details}") - } - CargoCommand::Format { - cargoarg, - package, - check_only, - } => { - let package = p(package); - let carg = carg(cargoarg); - - let carg = if cargoarg.is_some() { - format!("(cargo args: {carg})") - } else { - format!("") - }; - - if *check_only { - write!(f, "Check format for {package} {carg}") - } else { - write!(f, "Format {package} {carg}") - } - } - CargoCommand::Doc { - cargoarg, - features, - arguments, - } => { - let feat = feat(features); - let carg = carg(cargoarg); - let arguments = arguments - .clone() - .map(|a| format!("{a}")) - .unwrap_or_else(|| "no extra arguments".into()); - if cargoarg.is_some() { - write!(f, "Document ({feat}, {carg}, {arguments})") - } else { - write!(f, "Document ({feat}, {arguments})") - } - } - CargoCommand::Test { - package, - features, - test, - } => { - let p = p(package); - let test = test - .clone() - .map(|t| format!("test {t}")) - .unwrap_or("all tests".into()); - let feat = feat(features); - write!(f, "Run {test} in {p} (features: {feat})") - } - CargoCommand::Book { arguments: _ } => write!(f, "Build the book"), - CargoCommand::ExampleSize { - cargoarg, - example, - target, - features, - mode, - arguments: _, - dir, - } => { - let details = details(target, Some(mode), features, cargoarg, dir.as_ref()); - write!(f, "Compute size of example {example} {details}") - } - } - } -} - -impl<'a> CargoCommand<'a> { - pub fn as_cmd_string(&self) -> String { - let cd = if let Some(Some(chdir)) = self.chdir().map(|p| p.to_str()) { - format!("cd {chdir} && ") - } else { - format!("") - }; - - let executable = self.executable(); - let args = self.args().join(" "); - format!("{cd}{executable} {args}") - } - - fn command(&self) -> &'static str { - match self { - CargoCommand::Run { .. } | CargoCommand::Qemu { .. } => "run", - CargoCommand::ExampleCheck { .. } | CargoCommand::Check { .. } => "check", - CargoCommand::ExampleBuild { .. } | CargoCommand::Build { .. } => "build", - CargoCommand::ExampleSize { .. } => "size", - CargoCommand::Clippy { .. } => "clippy", - CargoCommand::Format { .. } => "fmt", - CargoCommand::Doc { .. } => "doc", - CargoCommand::Book { .. } => "build", - CargoCommand::Test { .. } => "test", - } - } - pub fn executable(&self) -> &'static str { - match self { - CargoCommand::Run { .. } - | CargoCommand::Qemu { .. } - | CargoCommand::ExampleCheck { .. } - | CargoCommand::Check { .. } - | CargoCommand::ExampleBuild { .. } - | CargoCommand::Build { .. } - | CargoCommand::ExampleSize { .. } - | CargoCommand::Clippy { .. } - | CargoCommand::Format { .. } - | CargoCommand::Test { .. } - | CargoCommand::Doc { .. } => "cargo", - CargoCommand::Book { .. } => "mdbook", - } - } - - /// Build args using common arguments for all commands, and the - /// specific information provided - fn build_args<'i, T: Iterator>( - &'i self, - nightly: bool, - cargoarg: &'i Option<&'i str>, - features: &'i Option, - mode: Option<&'i BuildMode>, - extra: T, - ) -> Vec<&str> { - let mut args: Vec<&str> = Vec::new(); - - if nightly { - args.push("+nightly"); - } - - if let Some(cargoarg) = cargoarg.as_deref() { - args.push(cargoarg); - } - - args.push(self.command()); - - if let Some(target) = self.target() { - args.extend_from_slice(&["--target", target.triple()]) - } - - if let Some(features) = features.as_ref() { - args.extend_from_slice(&["--features", features]); - } - - if let Some(mode) = mode.map(|m| m.to_flag()).flatten() { - args.push(mode); - } - - args.extend(extra); - - args - } - - /// Turn the ExtraArguments into an interator that contains the separating dashes - /// and the rest of the arguments. - /// - /// NOTE: you _must_ chain this iterator at the _end_ of the extra arguments. - fn extra_args(args: Option<&ExtraArguments>) -> impl Iterator { - #[allow(irrefutable_let_patterns)] - let args = if let Some(ExtraArguments::Other(arguments)) = args { - // Extra arguments must be passed after "--" - ["--"] - .into_iter() - .chain(arguments.iter().map(String::as_str)) - .collect() - } else { - vec![] - }; - args.into_iter() - } - - pub fn args(&self) -> Vec<&str> { - fn p(package: &Option) -> impl Iterator { - if let Some(package) = package { - vec!["--package", &package].into_iter() - } else { - vec![].into_iter() - } - } - - match self { - // For future embedded-ci, for now the same as Qemu - CargoCommand::Run { - cargoarg, - example, - features, - mode, - // dir is exposed through `chdir` - dir: _, - // Target is added by build_args - target: _, - } => self.build_args( - true, - cargoarg, - features, - Some(mode), - ["--example", example].into_iter(), - ), - CargoCommand::Qemu { - cargoarg, - example, - features, - mode, - // dir is exposed through `chdir` - dir: _, - // Target is added by build_args - target: _, - } => self.build_args( - true, - cargoarg, - features, - Some(mode), - ["--example", example].into_iter(), - ), - CargoCommand::Build { - cargoarg, - package, - features, - mode, - // Dir is exposed through `chdir` - dir: _, - // Target is added by build_args - target: _, - } => self.build_args(true, cargoarg, features, Some(mode), p(package)), - CargoCommand::Check { - cargoarg, - package, - features, - mode, - // Dir is exposed through `chdir` - dir: _, - // Target is added by build_args - target: _, - } => self.build_args(true, cargoarg, features, Some(mode), p(package)), - CargoCommand::Clippy { - cargoarg, - package, - features, - // Target is added by build_args - target: _, - } => self.build_args(true, cargoarg, features, None, p(package)), - CargoCommand::Doc { - cargoarg, - features, - arguments, - } => { - let extra = Self::extra_args(arguments.as_ref()); - self.build_args(true, cargoarg, features, None, extra) - } - CargoCommand::Test { - package, - features, - test, - } => { - let extra = if let Some(test) = test { - vec!["--test", test] - } else { - vec![] - }; - let package = p(package); - let extra = extra.into_iter().chain(package); - self.build_args(true, &None, features, None, extra) - } - CargoCommand::Book { arguments } => { - let mut args = vec![]; - - if let Some(ExtraArguments::Other(arguments)) = arguments { - for arg in arguments { - args.extend_from_slice(&[arg.as_str()]); - } - } else { - // If no argument given, run mdbook build - // with default path to book - args.extend_from_slice(&[self.command()]); - args.extend_from_slice(&["book/en"]); - } - args - } - CargoCommand::Format { - cargoarg, - package, - check_only, - } => { - let extra = if *check_only { Some("--check") } else { None }; - let package = p(package); - self.build_args( - true, - cargoarg, - &None, - None, - extra.into_iter().chain(package), - ) - } - CargoCommand::ExampleBuild { - cargoarg, - example, - features, - mode, - // dir is exposed through `chdir` - dir: _, - // Target is added by build_args - target: _, - } => self.build_args( - true, - cargoarg, - features, - Some(mode), - ["--example", example].into_iter(), - ), - CargoCommand::ExampleCheck { - cargoarg, - example, - features, - mode, - // Target is added by build_args - target: _, - } => self.build_args( - true, - cargoarg, - features, - Some(mode), - ["--example", example].into_iter(), - ), - CargoCommand::ExampleSize { - cargoarg, - example, - features, - mode, - arguments, - // Target is added by build_args - target: _, - // dir is exposed through `chdir` - dir: _, - } => { - let extra = ["--example", example] - .into_iter() - .chain(Self::extra_args(arguments.as_ref())); - - self.build_args(true, cargoarg, features, Some(mode), extra) - } - } - } - - /// TODO: integrate this into `args` once `-C` becomes stable. - fn chdir(&self) -> Option<&PathBuf> { - match self { - CargoCommand::Qemu { dir, .. } - | CargoCommand::ExampleBuild { dir, .. } - | CargoCommand::ExampleSize { dir, .. } - | CargoCommand::Build { dir, .. } - | CargoCommand::Run { dir, .. } - | CargoCommand::Check { dir, .. } => dir.as_ref(), - _ => None, - } - } - - fn target(&self) -> Option<&Target> { - match self { - CargoCommand::Run { target, .. } - | CargoCommand::Qemu { target, .. } - | CargoCommand::ExampleBuild { target, .. } - | CargoCommand::ExampleCheck { target, .. } - | CargoCommand::Build { target, .. } - | CargoCommand::Check { target, .. } - | CargoCommand::Clippy { target, .. } - | CargoCommand::ExampleSize { target, .. } => target.as_ref(), - _ => None, - } - } - - pub fn print_stdout_intermediate(&self) -> bool { - match self { - Self::ExampleSize { .. } => true, - _ => false, - } - } -} - -impl BuildMode { - #[allow(clippy::wrong_self_convention)] - pub fn to_flag(&self) -> Option<&str> { - match self { - BuildMode::Release => Some("--release"), - BuildMode::Debug => None, - } - } -} - -impl fmt::Display for BuildMode { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let cmd = match self { - BuildMode::Release => "release", - BuildMode::Debug => "debug", - }; - - write!(f, "{cmd}") - } -} - -pub fn run_command(command: &CargoCommand, stderr_mode: OutputMode) -> anyhow::Result { - log::info!("👟 {command}"); - - let mut process = Command::new(command.executable()); - - process - .args(command.args()) - .stdout(Stdio::piped()) - .stderr(stderr_mode); - - if let Some(dir) = command.chdir() { - process.current_dir(dir.canonicalize()?); - } - - let result = process.output()?; - - let exit_status = result.status; - let stderr = String::from_utf8(result.stderr).unwrap_or("Not displayable".into()); - let stdout = String::from_utf8(result.stdout).unwrap_or("Not displayable".into()); - - if command.print_stdout_intermediate() && exit_status.success() { - log::info!("\n{}", stdout); - } - - if exit_status.success() { - log::info!("✅ Success.") - } else { - log::error!("❌ Command failed. Run to completion for the summary."); - } - - Ok(RunResult { - exit_status, - stdout, - stderr, - }) -} - -/// Check if `run` was successful. -/// returns Ok in case the run went as expected, -/// Err otherwise -pub fn run_successful(run: &RunResult, expected_output_file: &str) -> Result<(), TestRunError> { - let mut file_handle = - File::open(expected_output_file).map_err(|_| TestRunError::FileError { - file: expected_output_file.to_owned(), - })?; - let mut expected_output = String::new(); - file_handle - .read_to_string(&mut expected_output) - .map_err(|_| TestRunError::FileError { - file: expected_output_file.to_owned(), - })?; - - if expected_output != run.stdout { - Err(TestRunError::FileCmpError { - expected: expected_output.clone(), - got: run.stdout.clone(), - }) - } else if !run.exit_status.success() { - Err(TestRunError::CommandError(run.clone())) - } else { - Ok(()) - } -} - -pub fn handle_results(globals: &Globals, results: Vec) -> Result<(), ()> { - let errors = results.iter().filter_map(|r| { - if let FinalRunResult::Failed(c, r) = r { - Some((c, &r.stdout, &r.stderr)) - } else { - None - } - }); - - let successes = results.iter().filter_map(|r| { - if let FinalRunResult::Success(c, r) = r { - Some((c, &r.stdout, &r.stderr)) - } else { - None - } - }); - - let command_errors = results.iter().filter_map(|r| { - if let FinalRunResult::CommandError(c, e) = r { - Some((c, e)) - } else { - None - } - }); - - let log_stdout_stderr = |level: Level| { - move |(cmd, stdout, stderr): (&CargoCommand, &String, &String)| { - let cmd = cmd.as_cmd_string(); - if !stdout.is_empty() && !stderr.is_empty() { - log::log!(level, "\n{cmd}\nStdout:\n{stdout}\nStderr:\n{stderr}"); - } else if !stdout.is_empty() { - log::log!(level, "\n{cmd}\nStdout:\n{}", stdout.trim_end()); - } else if !stderr.is_empty() { - log::log!(level, "\n{cmd}\nStderr:\n{}", stderr.trim_end()); - } - } - }; - - successes.for_each(|(cmd, stdout, stderr)| { - if globals.verbose > 0 { - info!("✅ Success: {cmd}\n {}", cmd.as_cmd_string()); - } else { - info!("✅ Success: {cmd}"); - } - - log_stdout_stderr(Level::Debug)((cmd, stdout, stderr)); - }); - - errors.clone().for_each(|(cmd, stdout, stderr)| { - error!("❌ Failed: {cmd}\n {}", cmd.as_cmd_string()); - log_stdout_stderr(Level::Error)((cmd, stdout, stderr)); - }); - - command_errors - .clone() - .for_each(|(cmd, error)| error!("❌ Failed: {cmd}\n {}\n{error}", cmd.as_cmd_string())); - - let ecount = errors.count() + command_errors.count(); - if ecount != 0 { - log::error!("{ecount} commands failed."); - Err(()) - } else { - info!("🚀🚀🚀 All tasks succeeded 🚀🚀🚀"); - Ok(()) - } -} -- cgit v1.2.3