Struct TaskConfig

Source

pub struct TaskConfig {
    pub task_id: Option<String>,
    pub command: String,
    pub args: Option<Vec<String>>,
    pub working_dir: Option<String>,
    pub env: Option<HashMap<String, String>>,
    pub timeout_ms: Option<u64>,
    pub enable_stdin: Option<bool>,
    pub ready_indicator: Option<String>,
    pub ready_indicator_source: Option<StreamSource>,
    pub use_process_group: Option<bool>,
}

Expand description

Configuration for a task to be executed.

TaskConfig defines all parameters needed to execute a process.

§Examples

§Basic Command

use tcrm_task::tasks::config::TaskConfig;

let config = TaskConfig::new("cmd")
    .args(["/C", "dir", "C:\\"]);

§Complex Configuration

use tcrm_task::tasks::config::{TaskConfig, StreamSource};
use std::collections::HashMap;

let mut env = HashMap::new();
env.insert("PATH".to_string(), "C:\\Windows\\System32".to_string());

let config = TaskConfig::new("cmd")
    .args(["/C", "echo", "Server started"])
    .working_dir("C:\\")
    .env(env)
    .timeout_ms(30000)
    .enable_stdin(true)
    .ready_indicator("Server started")
    .ready_indicator_source(StreamSource::Stdout);

Fields§

§task_id: Option<String>

The unique identifier for the task

§command: String

The command or executable to run

§args: Option<Vec<String>>

Arguments to pass to the command

§working_dir: Option<String>

Working directory for the command

§env: Option<HashMap<String, String>>

Environment variables for the command

§timeout_ms: Option<u64>

Maximum allowed runtime in milliseconds

§enable_stdin: Option<bool>

Allow providing input to the task via stdin

§ready_indicator: Option<String>

Optional string to indicate the task is ready (for long-running processes like servers)

§ready_indicator_source: Option<StreamSource>

Source of the ready indicator string (stdout/stderr)

§use_process_group: Option<bool>

Enable process group management for child process termination (default: true)

When enabled, creates process groups (Unix) or Job Objects (Windows) to ensure all child processes and their descendants are terminated when the main process is killed.

Implementations§

Source §

impl TaskConfig

Source

pub fn new(command: impl Into<String>) -> Self

Create a new task configuration with the given command

§Arguments

command - The executable command to run (e.g., “ls”, “node”, “python”)

§Examples

use tcrm_task::tasks::config::TaskConfig;

let config1 = TaskConfig::new("echo");
let config2 = TaskConfig::new("Powershell").args(["-Command", "echo"]);

Source

pub fn task_id(self, id: impl Into<String>) -> Self

Set the unique identifier for the task

§Arguments

id - The unique identifier for the task

Source

pub fn args<I, S>(self, args: I) -> Self
where I: IntoIterator<Item = S>, S: Into<String>,

Set the arguments for the command

§Arguments

args - Iterator of arguments to pass to the command

§Examples

use tcrm_task::tasks::config::TaskConfig;

let config = TaskConfig::new("ls")
    .args(["-la", "/tmp"]);
     
let config2 = TaskConfig::new("cargo")
    .args(vec!["build", "--release"]);

Source

pub fn working_dir(self, dir: impl Into<String>) -> Self

Set the working directory for the command

The working directory must exist when the task is executed.

§Arguments

dir - Path to the working directory

§Examples

use tcrm_task::tasks::config::TaskConfig;

let config = TaskConfig::new("ls")
    .working_dir("/tmp");
     
let config2 = TaskConfig::new("cargo")
    .working_dir("/path/to/project");

Source

pub fn env<K, V, I>(self, env: I) -> Self
where K: Into<String>, V: Into<String>, I: IntoIterator<Item = (K, V)>,

Set environment variables for the command

§Arguments

env - Iterator of (key, value) pairs for environment variables

§Examples

use tcrm_task::tasks::config::TaskConfig;
use std::collections::HashMap;

// Using tuples
let config = TaskConfig::new("node")
    .env([("NODE_ENV", "production"), ("PORT", "3000")]);

// Using HashMap
let mut env = HashMap::new();
env.insert("RUST_LOG".to_string(), "debug".to_string());
let config2 = TaskConfig::new("cargo")
    .env(env);

Source

pub fn timeout_ms(self, timeout: u64) -> Self

Set the maximum allowed runtime in milliseconds

If the task runs longer than this timeout, it will be terminated.

§Arguments

timeout - Timeout in milliseconds (must be > 0)

§Examples

use tcrm_task::tasks::config::TaskConfig;

// 30 second timeout
let config = TaskConfig::new("long-running-task")
    .timeout_ms(30000);

// 5 minute timeout
let config2 = TaskConfig::new("build-script")
    .timeout_ms(300000);

Source

pub fn enable_stdin(self, b: bool) -> Self

Enable or disable stdin for the task

When enabled, you can send input to the process via the stdin channel.

§Arguments

b - Whether to enable stdin input

§Examples

use tcrm_task::tasks::config::TaskConfig;

// Interactive command that needs input
let config = TaskConfig::new("python")
    .args(["-i"])
    .enable_stdin(true);

Source

pub fn ready_indicator(self, indicator: impl Into<String>) -> Self

Set the ready indicator for the task

For long-running processes (like servers), this string indicates when the process is ready to accept requests. When this string appears in the process output, a Ready event will be emitted.

§Arguments

indicator - String to look for in process output

§Examples

use tcrm_task::tasks::config::TaskConfig;

let config = TaskConfig::new("my-server")
    .ready_indicator("Server listening on port");

let config2 = TaskConfig::new("database")
    .ready_indicator("Database ready for connections");

Source

pub fn ready_indicator_source(self, source: StreamSource) -> Self

Set the source of the ready indicator

Specifies whether to look for the ready indicator in stdout or stderr.

§Arguments

source - Stream source (Stdout or Stderr)

§Examples

use tcrm_task::tasks::config::{TaskConfig, StreamSource};

let config = TaskConfig::new("my-server")
    .ready_indicator("Ready")
    .ready_indicator_source(StreamSource::Stderr);

Source

pub fn use_process_group(self, enabled: bool) -> Self

Enable or disable process group management

When enabled (default), creates process groups on Unix or Job Objects on Windows to ensure all child processes and their descendants are terminated when the main process is killed. This prevents orphaned processes.

§Arguments

enabled - Whether to use process group management

§Examples

use tcrm_task::tasks::config::TaskConfig;

// Disable process group management
let config = TaskConfig::new("cmd")
    .use_process_group(false);
     
// Explicitly enable (though it's enabled by default)
let config2 = TaskConfig::new("node")
    .use_process_group(true);

Source

pub fn validate(&self) -> Result<(), TaskError>

Validate the configuration

Validates all configuration parameters.

§Validation Checks

all fields length limits
Command: Must not be empty
Arguments: Must not contain null bytes or shell injection patterns
Working Directory: Must exist and be a valid directory
Environment Variables: Keys must not contain spaces, ‘=’, or null bytes
Timeout: Must be greater than 0 if specified
Ready Indicator: Must not be empty if specified

§Returns

Ok(()) if the configuration is valid
Err(TaskError::InvalidConfiguration) with details if validation fails

§Errors

Returns a TaskError if any validation check fails:

TaskError::InvalidConfiguration for configuration errors
TaskError::IO for working directory path not found

§Examples

use tcrm_task::tasks::config::TaskConfig;

// Valid config
let config = TaskConfig::new("echo")
    .args(["hello", "world"]);
assert!(config.validate().is_ok());

// Invalid config (empty command)
let config = TaskConfig::new("");
assert!(config.validate().is_err());

// Invalid config (zero timeout)
let config = TaskConfig::new("sleep")
    .timeout_ms(0);
assert!(config.validate().is_err());