razel 0.5.7

a command executor with caching for data processing pipelines
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use crate::executors::{
    AsyncTaskExecutor, BlockingTaskExecutor, CustomCommandExecutor, ExecutionResult,
    HttpRemoteExecutor, WasiExecutor,
};
use crate::CGroup;
use std::collections::HashMap;
use std::path::{Path, PathBuf};

#[derive(Clone)]
pub enum Executor {
    CustomCommand(CustomCommandExecutor),
    Wasi(WasiExecutor),
    AsyncTask(AsyncTaskExecutor),
    BlockingTask(BlockingTaskExecutor),
    HttpRemote(HttpRemoteExecutor),
}

impl Executor {
    pub async fn exec(
        &self,
        cwd: &Path,
        sandbox_dir: Option<PathBuf>,
        cgroup: Option<CGroup>,
    ) -> ExecutionResult {
        match self {
            Executor::CustomCommand(c) => c.exec(sandbox_dir, cgroup).await,
            Executor::Wasi(x) => x.exec(cwd, sandbox_dir.as_ref().unwrap()).await,
            Executor::AsyncTask(x) => x.exec(sandbox_dir).await,
            Executor::BlockingTask(t) => t.exec().await,
            Executor::HttpRemote(x) => x.exec().await,
        }
    }

    pub fn args_with_executable(&self) -> Vec<String> {
        match self {
            Executor::CustomCommand(c) => c.args_with_executable(),
            Executor::Wasi(x) => x.args_with_executable(),
            Executor::AsyncTask(x) => x.args_with_executable(),
            Executor::BlockingTask(t) => t.args_with_executable(),
            Executor::HttpRemote(x) => x.args_with_executable(),
        }
    }

    pub fn command_line_with_redirects(&self, razel_executable: &str) -> Vec<String> {
        match self {
            Executor::CustomCommand(c) => c.command_line_with_redirects(),
            Executor::Wasi(x) => x.command_line_with_redirects(razel_executable),
            Executor::AsyncTask(x) => x.args_with_executable(),
            Executor::BlockingTask(t) => t.args_with_executable(),
            Executor::HttpRemote(x) => x.args_with_executable(),
        }
    }

    pub fn args(&self) -> &Vec<String> {
        match self {
            Executor::CustomCommand(x) => &x.args,
            Executor::Wasi(x) => &x.args,
            Executor::AsyncTask(x) => &x.args,
            Executor::BlockingTask(x) => &x.args,
            Executor::HttpRemote(x) => &x.args,
        }
    }

    pub fn env(&self) -> Option<&HashMap<String, String>> {
        match self {
            Executor::CustomCommand(x) => Some(&x.env),
            Executor::Wasi(x) => Some(&x.env),
            Executor::AsyncTask(_) => None,
            Executor::BlockingTask(_) => None,
            Executor::HttpRemote(_) => None,
        }
    }

    pub fn stdout_file(&self) -> Option<&PathBuf> {
        match self {
            Executor::CustomCommand(x) => x.stdout_file.as_ref(),
            Executor::Wasi(x) => x.stdout_file.as_ref(),
            _ => unreachable!(),
        }
    }

    pub fn stderr_file(&self) -> Option<&PathBuf> {
        match self {
            Executor::CustomCommand(x) => x.stderr_file.as_ref(),
            Executor::Wasi(x) => x.stderr_file.as_ref(),
            _ => unreachable!(),
        }
    }

    /// Returns if a sandbox should be used.
    ///
    /// Internally implemented tasks have well-defined inputs and outputs. This might not be true
    /// for other commands, therefore the sandbox must be used to make caching reliable.
    pub fn use_sandbox(&self) -> bool {
        match self {
            Executor::CustomCommand(_) => true,
            Executor::Wasi(_) => true,
            Executor::AsyncTask(_) => true,
            Executor::BlockingTask(_) => false,
            Executor::HttpRemote(_) => false,
        }
    }
}