Struct gio::SubprocessLauncher

pub struct SubprocessLauncher(_, _);

This class contains a set of options for launching child processes, such as where its standard input and output will be directed, the argument list, the environment, and more.

While the Subprocess class has high level functions covering popular cases, use of this class allows access to more advanced options. It can also be used to launch multiple subprocesses with a similar configuration.

Implements

glib::object::ObjectExt

Methods

impl SubprocessLauncher

pub fn take_fd<F: IntoRawFd, G: IntoRawFd>(&self, source_fd: F, target_fd: G)

Transfer an arbitrary file descriptor from parent process to the child. This function takes "ownership" of the fd; it will be closed in the parent when self is freed.

By default, all file descriptors from the parent will be closed. This function allows you to create (for example) a custom pipe or socketpair before launching the process, and choose the target descriptor in the child.

An example use case is GNUPG, which has a command line argument --passphrase-fd providing a file descriptor number where it expects the passphrase to be written.

source_fd

File descriptor in parent process

target_fd

Target descriptor for child process

pub fn take_stderr_fd<F: IntoRawFd>(&self, fd: F)

Sets the file descriptor to use as the stderr for spawned processes.

If fd is -1 then any previously given fd is unset.

Note that the default behaviour is to pass stderr through to the stderr of the parent process.

The passed fd belongs to the SubprocessLauncher. It will be automatically closed when the launcher is finalized. The file descriptor will also be closed on the child side when executing the spawned process.

You may not set a stderr fd if a stderr file path is already set or if the launcher flags contain any flags directing stderr elsewhere.

This feature is only available on UNIX.

fd

a file descriptor, or -1

pub fn take_stdin_fd<F: IntoRawFd>(&self, fd: F)

Sets the file descriptor to use as the stdin for spawned processes.

If fd is -1 then any previously given fd is unset.

Note that if your intention is to have the stdin of the calling process inherited by the child then SubprocessFlags::StdinInherit is a better way to go about doing that.

The passed fd is noted but will not be touched in the current process. It is therefore necessary that it be kept open by the caller until the subprocess is spawned. The file descriptor will also not be explicitly closed on the child side, so it must be marked O_CLOEXEC if that's what you want.

You may not set a stdin fd if a stdin file path is already set or if the launcher flags contain any flags directing stdin elsewhere.

This feature is only available on UNIX.

fd

a file descriptor, or -1

pub fn take_stdout_fd<F: IntoRawFd>(&self, fd: F)

Sets the file descriptor to use as the stdout for spawned processes.

If fd is -1 then any previously given fd is unset.

Note that the default behaviour is to pass stdout through to the stdout of the parent process.

The passed fd is noted but will not be touched in the current process. It is therefore necessary that it be kept open by the caller until the subprocess is spawned. The file descriptor will also not be explicitly closed on the child side, so it must be marked O_CLOEXEC if that's what you want.

You may not set a stdout fd if a stdout file path is already set or if the launcher flags contain any flags directing stdout elsewhere.

This feature is only available on UNIX.

fd

a file descriptor, or -1

impl SubprocessLauncher

pub fn new(flags: SubprocessFlags) -> SubprocessLauncher

Creates a new SubprocessLauncher.

The launcher is created with the default options. A copy of the environment of the calling process is made at the time of this call and will be used as the environment that the process is launched in.

flags

SubprocessFlags

pub fn getenv<P: AsRef<Path>>(&self, variable: P) -> Option<PathBuf>

Returns the value of the environment variable variable in the environment of processes launched from this launcher.

On UNIX, the returned string can be an arbitrary byte string. On Windows, it will be UTF-8.

variable

the environment variable to get

Returns

the value of the environment variable, None if unset

pub fn set_child_setup<P: Fn() + 'static>(&self, child_setup: P)

Sets up a child setup function.

The child setup function will be called after fork but before exec on the child's side.

destroy_notify will not be automatically called on the child's side of the fork. It will only be called when the last reference on the SubprocessLauncher is dropped or when a new child setup function is given.

None can be given as child_setup to disable the functionality.

Child setup functions are only available on UNIX.

child_setup

a GSpawnChildSetupFunc to use as the child setup function

user_data

user data for child_setup

destroy_notify

a GDestroyNotify for user_data

pub fn set_cwd<P: AsRef<Path>>(&self, cwd: P)

Sets the current working directory that processes will be launched with.

By default processes are launched with the current working directory of the launching process at the time of launch.

cwd

the cwd for launched processes

pub fn set_environ(&self, env: &[&Path])

Replace the entire environment of processes launched from this launcher with the given 'environ' variable.

Typically you will build this variable by using g_listenv to copy the process 'environ' and using the functions g_environ_setenv, g_environ_unsetenv, etc.

As an alternative, you can use SubprocessLauncher::setenv, SubprocessLauncher::unsetenv, etc.

Pass an empty array to set an empty environment. Pass None to inherit the parent process’ environment. As of GLib 2.54, the parent process’ environment will be copied when SubprocessLauncher::set_environ is called. Previously, it was copied when the subprocess was executed. This means the copied environment may now be modified (using SubprocessLauncher::setenv, etc.) before launching the subprocess.

On UNIX, all strings in this array can be arbitrary byte strings. On Windows, they should be in UTF-8.

env

the replacement environment

pub fn set_flags(&self, flags: SubprocessFlags)

Sets the flags on the launcher.

The default flags are SubprocessFlags::None.

You may not set flags that specify conflicting options for how to handle a particular stdio stream (eg: specifying both SubprocessFlags::StdinPipe and SubprocessFlags::StdinInherit).

You may also not set a flag that conflicts with a previous call to a function like SubprocessLauncher::set_stdin_file_path or SubprocessLauncher::take_stdout_fd.

flags

SubprocessFlags

pub fn set_stderr_file_path<P: AsRef<Path>>(&self, path: P)

Sets the file path to use as the stderr for spawned processes.

If path is None then any previously given path is unset.

The file will be created or truncated when the process is spawned, as would be the case if using '2>' at the shell.

If you want to send both stdout and stderr to the same file then use SubprocessFlags::StderrMerge.

You may not set a stderr file path if a stderr fd is already set or if the launcher flags contain any flags directing stderr elsewhere.

This feature is only available on UNIX.

path

a filename or None

pub fn set_stdin_file_path(&self, path: &str)

Sets the file path to use as the stdin for spawned processes.

If path is None then any previously given path is unset.

The file must exist or spawning the process will fail.

You may not set a stdin file path if a stdin fd is already set or if the launcher flags contain any flags directing stdin elsewhere.

This feature is only available on UNIX.

pub fn set_stdout_file_path<P: AsRef<Path>>(&self, path: P)

Sets the file path to use as the stdout for spawned processes.

If path is None then any previously given path is unset.

The file will be created or truncated when the process is spawned, as would be the case if using '>' at the shell.

You may not set a stdout file path if a stdout fd is already set or if the launcher flags contain any flags directing stdout elsewhere.

This feature is only available on UNIX.

path

a filename or None

pub fn setenv<P: AsRef<OsStr>, Q: AsRef<OsStr>>(
    &self,
    variable: P,
    value: Q,
    overwrite: bool
)

Sets the environment variable variable in the environment of processes launched from this launcher.

On UNIX, both the variable's name and value can be arbitrary byte strings, except that the variable's name cannot contain '='. On Windows, they should be in UTF-8.

variable

the environment variable to set, must not contain '='

value

the new value for the variable

overwrite

whether to change the variable if it already exists

pub fn spawnv(&self, argv: &[&OsStr]) -> Result<Subprocess, Error>

Creates a Subprocess given a provided array of arguments.

argv

Command line arguments

Returns

A new Subprocess, or None on error (and error will be set)

pub fn unsetenv<P: AsRef<OsStr>>(&self, variable: P)

Removes the environment variable variable from the environment of processes launched from this launcher.

On UNIX, the variable's name can be an arbitrary byte string not containing '='. On Windows, it should be in UTF-8.

variable

the environment variable to unset, must not contain '='

Trait Implementations

impl Clone for SubprocessLauncher

fn clone(&self) -> SubprocessLauncher

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SubprocessLauncher

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

Formats the value using the given formatter.

impl Display for SubprocessLauncher

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

Formats the value using the given formatter.

impl Eq for SubprocessLauncher

impl Hash for SubprocessLauncher

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl Ord for SubprocessLauncher

fn cmp(&self, other: &SubprocessLauncher) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use] fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use] fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use] fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<T: ObjectType> PartialEq<T> for SubprocessLauncher

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: ObjectType> PartialOrd<T> for SubprocessLauncher

fn partial_cmp(&self, other: &T) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for SubprocessLauncher

fn static_type() -> Type

Returns the type identifier of Self.