Os.Cmd
Executing commands.
val find_tool : ?win_exe:bool -> ?search:Fpath.t list -> Cmd.tool -> (Fpath.t option, string) result
find_tool ~win_exe ~search tool
is the file path, if any, to the program executable for the tool specification tool
. For portability do not add an .exe
suffix to tool
on Windows, see the win_exe
argument.
tool
has a single path segment: the filename tool
is searched, in list order, for the first matching executable file in the directories of search
. search
defaults to the env var PATH
parsed with Fpath.list_of_search_path
.tool
has multiple path segments: the file path tool
is simply tested for existence and executability. Ok (Some tool)
is returned if that is case and Ok None
otherwise.win_exe
is true
a .exe
suffix is added to tool
if it doesn't already have one. Defaults to Stdlib.Sys.win32
.get_tool
is like find_tool
except it errors if Ok None
is returned.
val get_first_tool : ?win_exe:bool -> ?search:Fpath.t list -> Cmd.tool list -> (Fpath.t, string) result
get_first_tool tools
is the first tool that can be found in the list with find_tool
or an error if none is found. tools
must be non-empty.
find cmd
is like find_tool
but looks and replaces cmd
's B00_std.Cmd.tool
.
get cmd
is like get_tool
but looks and replaces cmd
's B00_std.Cmd.tool
.
pp_cmd_status
is a formatter for command process exit statuses.
val in_string : string -> stdi
in_string s
is a standard input that reads the string s
.
val in_fd : close:bool -> Unix.file_descr -> stdi
in_fd ~close fd
is a standard input that reads from file descriptor fd
. If close
is true
, fd
is closed after the process is spawn.
val in_stdin : stdi
in_stdin
is in_fd ~close:false Unix.stdin
, a standard input that reads from the current process standard input.
val in_null : stdi
in_null
is in_file File.null
.
out_file ~force ~make_path file
is a standard output that writes to file file
.
make_path
is true
and the parent directory of file
does not exist the whole path to the parent is created as needed with permission 0o755
(readable and traversable by everyone, writable by the user).force
is true
and file
exists at call time as a regular file it tries to overwrite it, in all other cases the function errors if file
exists.mode
are the permissions of the written file; they default to 0o644
, readable by everyone, writable by the user.val out_fd : close:bool -> Unix.file_descr -> stdo
out_fd ~close fd
is a standard output that writes to file descriptor fd
. If close
is true
, fd
is closed after the process spawn.
val out_stdout : stdo
out_stdout
is out_fd ~close:false Unix.stdout
val out_stderr : stdo
out_stderr
is out_fd ~close:false Unix.stderr
val out_null : stdo
out_null
is out_file File.null
These functions wait for the command to complete before proceeding.
val run_status : ?env:Env.assignments -> ?cwd:Fpath.t -> ?stdin:stdi -> ?stdout:stdo -> ?stderr:stdo -> Cmd.t -> (status, string) result
run_status ~env ~cwd ~stdin ~stdout ~stderr cmd
runs and waits for the completion of cmd
in environment env
with current directory cwd
and standard IO connections stdin
, stdout
and stderr
.
env
defaults to Env.current_assignments
()
cwd
defaults to Dir.cwd
()
stdin
defaults to in_stdin
stdout
defaults to out_stdout
stderr
defaults to out_stderr
val run_status_out : ?env:Env.assignments -> ?cwd:Fpath.t -> ?stdin:stdi -> ?stderr:[ `Stdo of stdo | `Out ] ->
trim:bool -> Cmd.t -> (status * string, string) result
run_status_out
is like run_status
except stdout
is read from the process to a string. The string is String.trim
ed if trim
is true
(default). If stderr
is `Out
the process' stderr
is redirected to stdout
and thus read back in the string aswell.
val run : ?env:Env.assignments -> ?cwd:Fpath.t -> ?stdin:stdi -> ?stdout:stdo -> ?stderr:stdo -> Cmd.t -> (unit, string) result
run
is run_status
with non-`Exited 0
statuses turned into errors via pp_cmd_status
.
val run_out : ?env:Env.assignments -> ?cwd:Fpath.t -> ?stdin:stdi -> ?stderr:[ `Stdo of stdo | `Out ] -> trim:bool ->
Cmd.t -> (string, string) result
run
is run_status_out
with non-`Exited 0
statuses turned into errors via pp_cmd_status
.
Note. In contrast to waitpid(2)
the following API does not allow to collect any child process completion. There are two reasons: first this is not supported on Windows, second this is anti-modular.
val pid_to_int : pid -> int
pid_to_int pid
is the system identifier for process identifier pid
.
val spawn : ?env:Env.assignments -> ?cwd:Fpath.t -> ?stdin:stdi -> ?stdout:stdo -> ?stderr:stdo -> Cmd.t -> (pid, string) result
spawn ~env ~cwd ~stdin ~stdout ~stderr cmd
spawns command cmd
in environment env
with current directory cwd
and standard IO connections stdin
, stdout
and stderr
. env
defaults to Env.current_assignments
()
, cwd
to Dir.cwd
()
, stdin
to in_stdin
, stdout
to out_stdout
and stderr
to out_stderr
.
spawn_poll_status pid
tries to collect the exit status of command spawn pid
. If block
is false
, Ok None
is immediately returned if pid
has not terinated yet.
spawn_wait_status
blocks and waits for pid
's termination status to become available.
type spawn_tracer = pid option -> Env.assignments option -> cwd:Fpath.t option -> Cmd.t -> unit
The type for spawn tracers. Called with each blocking and non-blocking spawned command aswell as execv
. The function is given the process identifier of the spawn (or None
in case of execv
), the environment if different from the program's one, the current working directory if different from the program's one and the actual command.
val spawn_tracer_nop : spawn_tracer
spawn_tracer_nop
is a spawn tracer that does nothing. This is the initial spawn tracer.
val spawn_tracer : unit -> spawn_tracer
tracer ()
is the current spawn tracer. Initially this is spawn_tracer_nop
.
val set_spawn_tracer : spawn_tracer -> unit
set_tracer t
sets the current spawn tracer to t
.
Windows. On Windows a program executing an execv*
function yields back control to the terminal as soon as the child starts (vs. ends on POSIX). This entails all sorts of unwanted behaviours. To workaround this, the following function executes, on Windows, the file as a spawned child process which is waited on for completion via waitpid(2)
. Once the child process has terminated the calling process is immediately exit
ed with the status of the child.
val execv : ?env:Env.assignments -> ?cwd:Fpath.t -> Fpath.t -> Cmd.t -> ('a, string) result
execv ~env ~cwd file argv
executes file file
as a new process in environment env
with args
as the Sys
.argv of this process (in particular Sys.argv.(0)
is the name of the program not the first argument to the program). The function only recturns in case of error. env
defaults to B00_std.Os.Env.current_assignments
()
, cwd
to B00_std
.Dir.cwd ()
.
type t = Cmd.t
Exit
needs that alias to refer to B00_std.Cmd.t
.