Struct TaskArgs 

pub struct TaskArgs {

    pub commands: Vec<CommandRunner>,
    pub preconditions: Vec<Precondition>,
    pub depends_on: Vec<TaskDependency>,
    pub labels: HashMap<String, String>,
    pub description: String,
    pub environment: HashMap<String, String>,
    pub env_file: Vec<String>,
    pub secrets_path: Vec<String>,
    pub secrets: Option<SecretSettings>,
    pub vault_location: Option<String>,
    pub keys_location: Option<String>,
    pub key_name: Option<String>,
    pub gpg_key_id: Option<String>,
    pub shell: Option<Shell>,
    pub parallel: Option<bool>,
    pub execution: Option<TaskExecution>,
    pub cache: Option<TaskCache>,
    pub inputs: Vec<String>,
    pub outputs: Vec<String>,
    pub ignore_errors: Option<bool>,
    pub verbose: Option<bool>,
    /* private fields */
}

This struct represents a task that can be executed. A task can contain multiple commands that are executed sequentially. A task can also have preconditions that must be met before the task can be executed.

Fields

commands: Vec<CommandRunner>

The commands to run

preconditions: Vec<Precondition>

The preconditions that must be met before the task can be executed

depends_on: Vec<TaskDependency>

The tasks that must be executed before this task can be executed

labels: HashMap<String, String>

The labels for the task

description: String

The description of the task

environment: HashMap<String, String>

The environment variables to set before running the task

env_file: Vec<String>

The environment files to load before running the task

secrets_path: Vec<String>

Secret paths to load as dotenv-style environment entries before running the task

secrets: Option<SecretSettings>

Canonical task secret settings block.

vault_location: Option<String>

The path to the secret vault

keys_location: Option<String>

The path to the private keys used for secret decryption

key_name: Option<String>

The key name to use for secret decryption

gpg_key_id: Option<String>

GPG key ID or fingerprint for hardware/passphrase-protected keys (delegates to system gpg)

shell: Option<Shell>

The shell to use when running the task

parallel: Option<bool>

Run the commands in parallel It should only work if the task are local_run commands

execution: Option<TaskExecution>

Richer execution configuration

cache: Option<TaskCache>

Task caching configuration

inputs: Vec<String>

Files or glob patterns that affect task output

outputs: Vec<String>

Files produced by the task

ignore_errors: Option<bool>

Ignore errors if the task fails

verbose: Option<bool>

Show verbose output

Implementations

impl TaskArgs

pub fn run(&self, context: &mut TaskContext) -> Result<()>

Trait Implementations

impl Debug for TaskArgs

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

Formats the value using the given formatter.

impl Default for TaskArgs

fn default() -> TaskArgs

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TaskArgs

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for TaskArgs

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.