# Module OpamProcess

    module OpamProcess: sig .. end

Process handling

    type command

The type of shell commands

    val command : ?env:string array ->
           ?verbose:bool ->
           ?name:string ->
           ?metadata:(string * string) list ->
           ?dir:string ->
           ?allow_stdin:bool ->
           ?text:string -> string -> string list -> command

    val string_of_command : command -> string

    val text_of_command : command -> string option

    val is_verbose_command : command -> bool

    val make_command_text : ?color:OpamGlobals.text_style ->
           string -> ?args:string list -> string -> string

Returns a label suitable for printing the summary of running commands. First string is the topic (e.g. package), second the action (e.g. command name). Optional command arguments may be used for details (e.g. make action).

    type t = {

`` | `p_name : `string`;` | `(*` | Command name | `*)`
`` | `p_args : `string list`;` | `(*` | Command args | `*)`
`` | `p_pid : `int`;` | `(*` | Process PID | `*)`
`` | `p_cwd : `string`;` | `(*` | Process initial working directory | `*)`
`` | `p_time : `float`;` | `(*` | Process start time | `*)`
`` | `p_stdout : `string option`;` | `(*` | stdout dump file | `*)`
`` | `p_stderr : `string option`;` | `(*` | stderr dump file | `*)`
`` | `p_env : `string option`;` | `(*` | dump environment variables | `*)`
`` | `p_info : `string option`;` | `(*` | dump process info | `*)`
`` | `p_metadata : `(string * string) list`;` | `(*` | Metadata associated to the process | `*)`
`` | `p_verbose : `bool`;` | `(*` | whether output of the process should be displayed | `*)`

}
The type for processes

    type result = {

`` | `r_code : `int`;` | `(*` | Process exit code, or 256 on error | `*)`
`` | `r_signal : `int option`;` | `(*` | Signal received if the processed was killed | `*)`
`` | `r_duration : `float`;` | `(*` | Process duration | `*)`
`` | `r_info : `(string * string) list`;` | `(*` | Process info | `*)`
`` | `r_stdout : `string list`;` | `(*` | Content of stdout dump file | `*)`
`` | `r_stderr : `string list`;` | `(*` | Content of stderr dump file | `*)`
`` | `r_cleanup : `string list`;` | `(*` | List of files to clean-up | `*)`

}
Process results

    val run : command -> result

`run command` synchronously call the command `command.cmd` with arguments `command.args`. It waits until the process is finished. The files `name.info`, `name.env`, `name.out` and `name.err`, with `name = command.cmd_name` are created, and contain the process main description, the environment variables, the standard output and the standard error. Don't forget to call `cleanup result` afterwards

    val run_background : command -> t

Same as `run`, but doesn't wait. Use wait_one to wait and collect results; Don't forget to call `cleanup result` afterwards

    val dry_run_background : command -> t

Similar to `run_background`, except that no process is created, and a dummy process (suitable for dry_wait_one) is returned.

    val wait : t -> result

`wait p` waits for the processus `p` to end and returns its results. Be careful to handle Sys.Break

    val dontwait : t -> result option

Like `wait`, but returns None immediately if the process hasn't ended

    val wait_one : t list -> t * result

Wait for the first of the listed processes to terminate, and return its termination status

    val dry_wait_one : t list -> t * result

Similar to `wait_one` for simulations, to be used with `dry_run_background`

    val interrupt : t -> unit

Send SIGINT to a process (or SIGKILL on Windows)

    val is_success : result -> bool

Is the process result a success ?

    val is_failure : result -> bool

Is the process result a failure ?

    val cleanup : ?force:bool -> result -> unit

Should be called after process termination, to cleanup temporary files. Leaves artefacts in case OpamGlobals.debug is on and on failure, unless force has been set.

    val read_lines : string -> string list

## Misc

    val string_of_result : ?color:OpamGlobals.text_style -> result -> string

Pretty printing of process.

    module Job: sig .. end

Higher-level interface to allow parallelism

    type 'a job = 'a Job.Op.job