Struct CmdOptions 

pub struct CmdOptions { /* private fields */ }

CmdOptions are used to describe command’s additional settings.

It allows to configure command’s input/outputs, working_directory and environment variables.

Command’s input allows to send messages from parent process, and receive them in spawned (child) process. Whereas the message output of the command is used for communication in the opposite direction. Communication with a process can be done using standard I/O or named pipes.

It is also possible to set logging in order to allow child process to produce logs which, unlike messages, are stored permanently and therefore can be read multiple times by parent process.

Implementations

impl CmdOptions

pub fn with_standard_io_messaging() -> CmdOptions

Create options with configured messaging input/output via standard I/O.

pub fn with_named_pipe_messaging() -> CmdOptions

Create options with configured messaging input/output via named pipes.

pub fn with_message_input(message_input: MessagingType) -> Self

Create options with configured messaging input type.

pub fn with_message_output(message_output: MessagingType) -> Self

Create options with configured messaging output type.

pub fn with_logging(logging_type: LoggingType) -> Self

Create options with configured logging type.

pub fn set_current_dir(&mut self, dir: PathBuf)

Set process’s working directory.

pub fn clear_inherited_envs(&mut self, value: bool)

By default, child process will inherit all environment variables from the parent. To prevent this behavior set this value to true.

pub fn set_envs<K, V, I>(&mut self, envs: I)

where K: Into<String>, V: Into<String>, I: IntoIterator<Item = (K, V)>,

Set environment variables for a process.

Examples

let mut envs = HashMap::new();
envs.insert("TEST_ENV_VAR_1", "value1");
envs.insert("TEST_ENV_VAR_2", "value2");

let mut options = CmdOptions::default();
options.set_envs(envs);

pub fn add_env<K, V>(&mut self, name: K, value: V)

where K: Into<String>, V: Into<String>,

Add or update single environment variable.

pub fn remove_env<S>(&mut self, name: S)

where S: Into<String> + AsRef<str>,

Remove single environment variable (manually set earlier and also inherited from the parent process).

pub fn set_message_input(&mut self, messaging_type: MessagingType)

Set message input type.

pub fn set_message_output( &mut self, messaging_type: MessagingType, ) -> Result<(), CmdOptionsError>

Set message output type.

This method will return CmdOptionsError::StdoutConfigurationConflict when trying to set MessagingType::StandardIo and logging to stdout was previously configured.

pub fn set_logging_type( &mut self, logging_type: LoggingType, ) -> Result<(), CmdOptionsError>

Set logging type.

This method will return CmdOptionsError::StdoutConfigurationConflict when trying to set logging to stdout and message output was previously configured as MessagingType::StandardIo.

pub fn set_message_output_buffer_capacity(&mut self, capacity: BufferCapacity)

Set message output buffer capacity for receiving end (parent process).

When parent process is not reading messages produced by a child process, then the messages are buffered up to the given capacity value. If the buffer limit is reached and a child process sends a new message, the “oldest” buffered message will be removed.

pub fn current_dir(&self) -> Option<&PathBuf>

Get current directory.

pub fn inherited_envs_cleared(&self) -> bool

Check if inherited environment variables will be cleared.

pub fn envs(&self) -> &HashMap<String, String>

Get environment variables.

pub fn inherited_envs_to_remove(&self) -> &[String]

Get inherited environment variables to remove.

pub fn message_input(&self) -> Option<&MessagingType>

Get message input type.

pub fn message_output(&self) -> Option<&MessagingType>

Get message output type.

pub fn logging_type(&self) -> Option<&LoggingType>

Get logging type.

pub fn message_output_buffer_capacity(&self) -> &BufferCapacity

Get message output buffer capacity.

pub fn update(&mut self, other: CmdOptions)

Update this options using values of other CmdOptions.

Examples

let mut options = CmdOptions::default();
let mut other = CmdOptions::with_standard_io_messaging();
other.clear_inherited_envs(true);

options.update(other);

let expected = MessagingType::StandardIo;
assert!(matches!(options.message_input(), expected));
assert!(matches!(options.message_output(), expected));
assert!(options.inherited_envs_cleared());

Trait Implementations

impl Clone for CmdOptions

fn clone(&self) -> CmdOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CmdOptions

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

Formats the value using the given formatter.

impl Default for CmdOptions

fn default() -> CmdOptions

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for CmdOptions

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CmdOptions

fn eq(&self, other: &CmdOptions) -> 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 Serialize for CmdOptions

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 CmdOptions

impl StructuralPartialEq for CmdOptions