Spawns a new process, optionally assigning it an arbitrary set of standard input, output, and error streams.

The function returns immediately, leaving the child process to execute in parallel with its parent. It is recommended to always call wait on the returned Pid, as detailed in the documentation for wait.

// Run an executable called "prog" located in the current working

// directory:

auto pid = spawnProcess("./prog");
scope(exit) wait(pid);
// We can do something else while the program runs.  The scope guard

// ensures that the process is waited for at the end of the scope.

...

// Run DMD on the file "myprog.d", specifying a few compiler switches:

auto dmdPid = spawnProcess(["dmd", "-O", "-release", "-inline", "myprog.d" ]);
if (wait(dmdPid) != 0)
    writeln("Compilation failed!");

wait(spawnProcess("myapp", ["foo" : "bar"], Config.newEnv));

// Run DMD on the file myprog.d, logging any error messages to a

// file named errors.log.

auto logFile = File("errors.log", "w");
auto pid = spawnProcess(["dmd", "myprog.d"],
                        std.stdio.stdin,
                        std.stdio.stdout,
                        logFile);
if (wait(pid) != 0)
    writeln("Compilation failed. See errors.log for details.");

A variation on spawnProcess that runs the given command through the current user's preferred command interpreter (aka. shell).

The string command is passed verbatim to the shell, and is therefore subject to its rules about command structure, argument/filename quoting and escaping of special characters. The path to the shell executable is determined by the userShell function.

In all other respects this function works just like spawnProcess. Please refer to the spawnProcess documentation for descriptions of the other function parameters, the return value and any exceptions that may be thrown.

// Run the command/program "foo" on the file named "my file.txt", and

// redirect its output into foo.log.

auto pid = spawnShell(`foo "my file.txt" > foo.log`);
wait(pid);

Flags that control the behaviour of spawnProcess and spawnShell.

Use bitwise OR to combine flags.

auto logFile = File("myapp_error.log", "w");

// Start program, suppressing the console window (Windows only),

// redirect its error stream to logFile, and leave logFile open

// in the parent process as well.

auto pid = spawnProcess("myapp", stdin, stdout, logFile,
                        Config.retainStderr | Config.suppressConsole);
scope(exit)
{
    auto exitCode = wait(pid);
    logFile.writeln("myapp exited with code ", exitCode);
    logFile.close();
}

A handle that corresponds to a spawned process.

Waits for the process associated with pid to terminate, and returns its exit status.

In general one should always wait for child processes to terminate before exiting the parent process. Otherwise, they may become "zombies" – processes that are defunct, yet still occupy a slot in the OS process table.

If the process has already terminated, this function returns directly. The exit code is cached, so that if  wait() is called multiple times on the same Pid it will always return the same value.

A non-blocking version of wait.

If the process associated with pid has already terminated,  tryWait has the exact same effect as wait. In this case, it returns a struct where the terminated field is set to true and the status field has the same interpretation as the return value of wait.

If the process has not yet terminated, this function differs from wait in that does not wait for this to happen, but instead returns immediately. The terminated field of the returned tuple will then be set to false, while the status field will always be 0 (zero). wait or  tryWait should then be called again on the same Pid at some later time; not only to get the exit code, but also to avoid the process becoming a "zombie" when it finally terminates. (See wait for details).

auto pid = spawnProcess("dmd myapp.d");
scope(exit) wait(pid);
...
auto dmd = tryWait(pid);
if (dmd.terminated)
{
    if (dmd.status == 0) writeln("Compilation succeeded!");
    else writeln("Compilation failed");
}
else writeln("Still compiling...");
...

Attempts to terminate the process associated with pid.

The effect of this function, as well as the meaning of codeOrSignal, is highly platform dependent. Details are given below. Common to all platforms is that this function only initiates termination of the process, and returns immediately. It does not wait for the process to end, nor does it guarantee that the process does in fact get terminated.

Always call wait to wait for a process to complete, even if  kill has been called on it.

auto pid = spawnProcess("some_app");
kill(pid, 10);
assert (wait(pid) == 10);

import core.sys.posix.signal: SIGKILL;
auto pid = spawnProcess("some_app");
kill(pid, SIGKILL);
assert (wait(pid) == -SIGKILL); // Negative return value on POSIX!

Creates a unidirectional pipe.

Data is written to one end of the pipe and read from the other.

auto p = pipe();
p.writeEnd.writeln("Hello World");
assert (p.readEnd.readln().chomp() == "Hello World");

// Use cURL to download the dlang.org front page, pipe its

// output to grep to extract a list of links to ZIP files,

// and write the list to the file "D downloads.txt":

auto p = pipe();
auto outFile = File("D downloads.txt", "w");
auto cpid = spawnProcess(["curl", "http://dlang.org/download.html"],
                         std.stdio.stdin, p.writeEnd);
scope(exit) wait(cpid);
auto gpid = spawnProcess(["grep", "-o", `http://\S*\.zip`],
                         p.readEnd, outFile);
scope(exit) wait(gpid);

An interface to a pipe created by the pipe function.

Starts a new process, creating pipes to redirect its standard input, output and/or error streams.

 pipeProcess and pipeShell are convenient wrappers around spawnProcess and spawnShell, respectively, and automate the task of redirecting one or more of the child process' standard streams through pipes. Like the functions they wrap, these functions return immediately, leaving the child process to execute in parallel with the invoking process. It is recommended to always call wait on the returned ProcessPipes.pid, as detailed in the documentation for wait.

The args/program/command, env and config parameters are forwarded straight to the underlying spawn functions, and we refer to their documentation for details.

auto pipes = pipeProcess("my_application", Redirect.stdout | Redirect.stderr);
scope(exit) wait(pipes.pid);

// Store lines of output.

string[] output;
foreach (line; pipes.stdout.byLine) output ~= line.idup;

// Store lines of errors.

string[] errors;
foreach (line; pipes.stderr.byLine) errors ~= line.idup;

Flags that can be passed to pipeProcess and pipeShell to specify which of the child process' standard streams are redirected. Use bitwise OR to combine flags.

Object which contains std.stdio.File handles that allow communication with a child process through its standard streams.

Executes the given program or shell command and returns its exit code and output.

 execute and executeShell start a new process using spawnProcess and spawnShell, respectively, and wait for the process to complete before returning. The functions capture what the child process prints to both its standard output and standard error streams, and return this together with its exit code.

auto dmd = execute("dmd", "myapp.d");
if (dmd.status != 0) writeln("Compilation failed:\n", dmd.output);

auto ls = executeShell("ls -l");
if (ls.status == 0) writeln("Failed to retrieve file listing");
else writeln(ls.output);

An exception that signals a problem with starting or waiting for a process.

Determines the path to the current user's default command interpreter.

On Windows, this function returns the contents of the COMSPEC environment variable, if it exists. Otherwise, it returns the string "cmd.exe".

On POSIX,  userShell returns the contents of the SHELL environment variable, if it exists and is non-empty. Otherwise, it returns "/bin/sh".

Returns the process ID number of the current process.

Escapes an argv-style argument array to be used with spawnShell, pipeShell or executeShell.

string url = "http://dlang.org/";
executeShell(escapeShellCommand("wget", url, "-O", "dlang-index.html"));

Concatenate multiple  escapeShellCommand and escapeShellFileName results to use shell redirection or piping operators.

executeShell(
    escapeShellCommand("curl", "http://dlang.org/download.html") ~
    "|" ~
    escapeShellCommand("grep", "-o", `http://\S*\.zip`) ~
    ">" ~
    escapeShellFileName("D download links.txt"));

Quotes a command-line argument in a manner conforming to the behavior of CommandLineToArgvW.

Escapes a filename to be used for shell redirection with spawnShell, pipeShell or executeShell.

Manipulates environment variables using an associative-array-like interface.

This class contains only static methods, and cannot be instantiated. See below for examples of use.

Execute command in a command shell.

This function is scheduled for deprecation. Please use spawnShell or executeShell instead.

Replace the current process by executing a command, pathname, with the arguments in argv.

These functions are scheduled for deprecation. Please use spawnShell instead (or, alternatively, the homonymous C functions declared in std.c.process.)

Typically, the first element of argv is the command being executed, i.e. argv[0] == pathname. The 'p' versions of exec search the PATH environment variable for pathname. The 'e' versions additionally take the new process' environment variables as an array of strings of the form key=value.

Does not return on success (the current process will have been replaced). Returns -1 on failure with no indication of the underlying error.

Returns the process ID of the calling process, which is guaranteed to be unique on the system. This call is always successful.

This function is scheduled for deprecation. Please use thisProcessID instead.

writefln("Current process id: %s", getpid());

Runs cmd in a  shell and returns its standard output. If the process could not be started or exits with an error code, throws ErrnoException.

This function is scheduled for deprecation. Please use executeShell instead.

auto tempFilename = chomp(shell("mcookie"));
auto f = enforce(fopen(tempFilename), "w");
scope(exit)
{
    fclose(f) == 0 || assert(false);
    system(escapeShellCommand("rm", tempFilename));
}
... use f ...

Gets the value of environment variable name as a string. Calls std.c.stdlib.getenv internally.

This function is scheduled for deprecation. Please use environment.get instead.