Struct ShellCommand

pub struct ShellCommand {
    pub command: String,
    pub arguments: Option<Vec<String>>,
    pub cwd: Option<String>,
    pub paths: Option<Vec<String>>,
}

The processor configuration.

Fields

command: String

The main shell command to execute.

arguments: Option<Vec<String>>

The arguments added to the main command.

cwd: Option<String>

The current working directory in which the command is executed.

This allows you to move to a child path within the Context workspace.

If set to None, the root of the workspace is used as the default.

paths: Option<Vec<String>>

Optional paths added to the PATH environment variable.

If you have a single script inside the bin/ directory you want to execute, you can also use the cwd option, but if your scripts call other custom scripts, and expect them to be directly accessible, you can add bin to paths to make that work.

Trait Implementations

impl Clone for ShellCommand

fn clone(&self) -> ShellCommand

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ShellCommand

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ShellCommand

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ShellCommand

fn eq(&self, other: &ShellCommand) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Processor<'a> for ShellCommand

fn validate(&self) -> Result<(), Self::Error>

Validate the ShellCommand configuration.

Errors

This method returns the Error::Path error if either the cwd or the paths fields contain anything other than a simple relative path, such as my/path. Anything such as ../, or /etc is not allowed.

fn run(&self, context: &Context) -> Result<Option<Self::Output>, Self::Error>

Run the shell command as defined by the provided configuration.

The command will be executed in the automaat_core::Context workspace, optionally in a child path using the cwd option.

Output

None is returned if the processor runs successfully but no value was returned by the command on stdout.

Some is returned if the command did return a value and exited with status code 0.

If a value is returned, any ANSI escape codes are stripped, and the return value is transformed lossy transformed into a valid UTF-8 string, with any invalid bytes transformed to the replacement character. Any whitespace to the right of the output (including newlines) is also stripped.

Errors

If the run fails, an Error result value is returned. The variant can differ, depending on if the command itself failed, some IO error happened, or the configuration is invalid.

const NAME: &'static str = "Shell Command"

The human-formatted name of the processor, used to visually identify this processor amongst others.

type Error = Error

If a processor fails its intended purpose, the returned error is turned into a string, and shown in the automaat-web-client application.

type Output = String

The processor can return any (successful) output it wants, as long as that type implements the std::fmt::Display trait.

impl Serialize for ShellCommand

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ShellCommand

impl StructuralPartialEq for ShellCommand