Child_processes (child_processes.Child

type t

A managed child process

exception Child_died

val stdout : t -> string Pipe_lib.Strict_pipe.Reader.t

A pipe of the standard out of the process.

val stderr : t -> string Pipe_lib.Strict_pipe.Reader.t

A pipe of the standard error of the process.

val stdin : t -> Async.Writer.t

Writer to process's stdin

val pid : t -> Core_kernel.Pid.t

val termination_status : 
  t ->
  Async.Unix.Exit_or_signal.t Core_kernel.Or_error.t option

None if the process is still running, Some when it's exited

type output_type = [

| `Chunks

| `Lines

]

val start_custom : 
  ?allow_multiple_instances:bool ->
  logger:Logger.t ->
  name:string ->
  git_root_relative_path:string ->
  conf_dir:string ->
  args:string list ->
  stdout:output_type ->
  stderr:output_type ->
  termination:
    [ `Always_raise
    | `Raise_on_failure
    | `Handler of
      killed:bool ->
      Async.Process.t ->
      Async.Unix.Exit_or_signal.t Core_kernel.Or_error.t ->
      unit Async.Deferred.t
    | `Ignore ] ->
  unit ->
  t Async.Deferred.Or_error.t

Start a process, handling a lock file, termination, optional logging, and the standard in, out and error fds. This is for "custom" processes, as opposed to ones that are built using RPC parallel.

The optional allow_multiple_instances argument defaults to `false`. In that case, a lockfile prevents multiple instances of an executable from running. It can be set to `true` to start multiple instances of the same executable.

val kill : t -> Async.Unix.Exit_or_signal.t Async.Deferred.Or_error.t

module Termination : module type of Termination

val register_process : Termination.t -> t -> Termination.process_kind -> unit