Process module:System -package:unix -package:process-extras -package:haskell-awk -package:Win32 -package:cmdargs -is:module

A running process. The three type parameters provide the type of the standard input, standard output, and standard error streams. To interact with a Process use the functions from the section Interact with a process.

A handle to a process, which can be used to wait for termination of the process using waitForProcess. None of the process-creation functions in this library wait for termination: they all return a ProcessHandle which may be used to wait for the process later. On Windows a second wait method can be used to block for event completion. This requires two handles. A process job handle and a events handle to monitor.

CPU options impacting cryptography implementation and library performance.

The identifier of the CPU-time clock associated with the calling process. For this clock, the value returned by getTime represents the amount of execution time of the current process.

An abstract configuration for a process, which can then be launched into an actual running Process. Takes three type parameters, providing the types of standard input, standard output, and standard error, respectively. There are three ways to construct a value of this type:

• With the proc smart constructor, which takes a command name and a list of arguments.
• With the shell smart constructor, which takes a shell string
• With the IsString instance via OverloadedStrings. If you provide it a string with no spaces (e.g., "date"), it will treat it as a raw command with no arguments (e.g., proc "date" []). If it has spaces, it will use shell.

In all cases, the default for all three streams is to inherit the streams from the parent process. For other settings, see the setters below for default values. Once you have a ProcessConfig you can launch a process from it using the functions in the section Launch a process.

An exception that is raised when a process fails.

The exit code of the process.

Options which have been enabled at compile time and are supported by the current CPU.

Deprecated: Please use pipeBytes instead.

Deprecated: Please use pipeChunks instead.

Logical Processor Index

Creates a new process to run the specified command with the given arguments, and wait for it to finish. If the command returns a non-zero exit code, an exception is raised. If an asynchronous exception is thrown to the thread executing callProcess, the forked process will be terminated and callProcess will wait (block) until the process has been terminated.

Cleans up the process. This function is meant to be invoked from any application level cleanup handler. It terminates the process, and closes any CreatePipe handles.

This is the most general way to spawn an external process. The process can be a command line to be executed by a shell or a raw command with a list of arguments. The stdin, stdout, and stderr streams of the new process may individually be attached to new pipes, to existing Handles, or just inherited from the parent (the default.) The details of how to create the process are passed in the CreateProcess record. To make it easier to construct a CreateProcess, the functions proc and shell are supplied that fill in the fields with default values which can be overriden as needed. createProcess returns (mb_stdin_hdl, mb_stdout_hdl, mb_stderr_hdl, ph), where

• if std_in == CreatePipe, then mb_stdin_hdl will be Just h, where h is the write end of the pipe connected to the child process's stdin.
• otherwise, mb_stdin_hdl == Nothing

Similarly for mb_stdout_hdl and mb_stderr_hdl. For example, to execute a simple ls command:

r <- createProcess (proc "ls" [])

To create a pipe from which to read the output of ls:

(_, Just hout, _, _) <-
createProcess (proc "ls" []){ std_out = CreatePipe }

To also set the directory in which to run ls:

(_, Just hout, _, _) <-
createProcess (proc "ls" []){ cwd = Just "/home/bob",
std_out = CreatePipe }

Note that Handles provided for std_in, std_out, or std_err via the UseHandle constructor will be closed by calling this function. This is not always the desired behavior. In cases where you would like to leave the Handle open after spawning the child process, please use createProcess_ instead. All created Handles are initially in text mode; if you need them to be in binary mode then use hSetBinaryMode. ph contains a handle to the running process. On Windows use_process_jobs can be set in CreateProcess in order to create a Win32 Job object to monitor a process tree's progress. If it is set then that job is also returned inside ph. ph can be used to kill all running sub-processes. This feature has been available since 1.5.0.0.