Lines
71.74 %
Functions
75 %
Branches
100 %
use std::io::{
BufRead as _,
BufReader,
};
use std::thread;
use crate::handle_output;
use crate::schema::get_output_handler;
use anyhow::Context;
use schemars::JsonSchema;
use serde::Deserialize;
use super::TaskContext;
mod container_build;
mod container_run;
mod container_runtime;
mod local_run;
mod task_run;
pub use container_runtime::ContainerRuntime;
pub use local_run::LocalRun;
#[derive(Debug, Deserialize, Clone, JsonSchema)]
#[serde(untagged)]
/// A single command entry in a task. Can be a shell string or a structured runner object.
pub enum CommandRunner {
ContainerBuild(container_build::ContainerBuild),
ContainerRun(container_run::ContainerRun),
LocalRun(local_run::LocalRun),
TaskRun(task_run::TaskRun),
CommandRun(String),
}
impl CommandRunner {
pub fn execute(&self, context: &TaskContext) -> anyhow::Result<()> {
self.execute_inner(context, false)
pub fn execute_cancellable(&self, context: &TaskContext) -> anyhow::Result<()> {
self.execute_inner(context, true)
fn execute_inner(&self, context: &TaskContext, allow_cancellation: bool) -> anyhow::Result<()> {
context.emit_event(&serde_json::json!({
"event": "command_started",
"task": context.current_task_name.clone().unwrap_or_else(|| "<task>".to_string()),
"kind": self.kind(),
}))?;
let result = match self {
CommandRunner::ContainerBuild(container_build) => container_build.execute(context),
CommandRunner::ContainerRun(container_run) => container_run.execute(context),
CommandRunner::LocalRun(local_run) if allow_cancellation => local_run.execute_cancellable(context),
CommandRunner::LocalRun(local_run) => local_run.execute(context),
CommandRunner::TaskRun(task_run) => task_run.execute(context),
CommandRunner::CommandRun(command) => self.execute_command(context, command),
"event": "command_finished",
"success": result.is_ok(),
result
fn execute_command(&self, context: &TaskContext, command: &str) -> anyhow::Result<()> {
assert!(!command.is_empty());
let ignore_errors = context.ignore_errors();
let verbose = context.verbose();
let shell = context.shell();
let stdout = get_output_handler(verbose);
let stderr = get_output_handler(verbose);
let mut cmd = shell.proc();
cmd.arg(command).stdout(stdout).stderr(stderr);
// Inject environment variables
for (key, value) in context.env_vars.iter() {
cmd.env(key, value);
let mut cmd = cmd.spawn()?;
if verbose {
handle_output!(cmd.stdout, context);
handle_output!(cmd.stderr, context);
let status = cmd.wait()?;
if !status.success() && !ignore_errors {
anyhow::bail!("Command failed - {}", command);
Ok(())
fn kind(&self) -> &'static str {
match self {
CommandRunner::ContainerBuild(_) => "container_build",
CommandRunner::ContainerRun(_) => "container_run",
CommandRunner::LocalRun(_) => "local_run",
CommandRunner::TaskRun(_) => "task_run",
CommandRunner::CommandRun(_) => "command_run",
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_command_1() -> anyhow::Result<()> {
{
let yaml = "
command: 'echo \"Hello, World!\"'
ignore_errors: false
verbose: false
";
let command = serde_yaml::from_str::<CommandRunner>(yaml)?;
if let CommandRunner::LocalRun(local_run) = command {
assert_eq!(local_run.command, "echo \"Hello, World!\"");
assert_eq!(local_run.work_dir, None);
assert_eq!(local_run.ignore_errors, Some(false));
assert_eq!(local_run.verbose, Some(false));
} else {
panic!("Expected CommandRunner::LocalRun");
fn test_command_2() -> anyhow::Result<()> {
assert_eq!(local_run.ignore_errors, None);
assert_eq!(local_run.verbose, None);
fn test_command_3() -> anyhow::Result<()> {
ignore_errors: true
assert_eq!(local_run.ignore_errors, Some(true));
fn test_command_4() -> anyhow::Result<()> {
fn test_command_5() -> anyhow::Result<()> {
work_dir: /tmp
assert_eq!(local_run.work_dir, Some("/tmp".into()));
fn test_command_6() -> anyhow::Result<()> {
echo 'Hello, World!'
if let CommandRunner::CommandRun(command) = command {
assert_eq!(command, "echo 'Hello, World!'");
panic!("Expected CommandRunner::CommandRun");