Some useful functions built on top of Unix.
status: unstable
val escape_str : Buffer.t -> string -> unitEscape a string so it can be a shell argument.
type call_result =
< stdout : string
; stderr : string
; status : Unix.process_status
; errcode : int >val call :
?bufsize:int ->
?stdin:[ `Gen of string gen | `Str of string ] ->
?env:string array ->
('a, Buffer.t, unit, call_result) Pervasives.format4 ->
'acall cmd wraps the result of Unix.open_process_full cmd into an object. It reads the full stdout and stderr of the subprocess before returning.
if provided, the generator or string is consumed and fed to the subprocess input channel, which is then closed.
buffer size used to read stdout and stderr
environment to run the command in
type async_call_result =
< stdout : line gen
; stderr : line gen
; stdin : line -> unit
; close_in : unit
; close_err : unit
; close_out : unit
; close_all : unit
; wait : Unix.process_status
; wait_errcode : int >A subprocess for interactive usage (read/write channels line by line)
val async_call :
?env:string array ->
('a, Buffer.t, unit, async_call_result) Pervasives.format4 ->
'aSpawns a subprocess, like call, but the subprocess's channels are line generators and line sinks (for stdin). if p is async_call "cmd", then p#wait waits for the subprocess to die. Channels can be closed independently.
val with_in :
?mode:int ->
?flags:Unix.open_flag list ->
string ->
f:(Pervasives.in_channel -> 'a) ->
'aOpen an input file with the given optional flag list, calls the function on the input channel. When the function raises or returns, the channel is closed.
opening flags. Unix.O_RDONLY is used in any cases
val with_out :
?mode:int ->
?flags:Unix.open_flag list ->
string ->
f:(Pervasives.out_channel -> 'a) ->
'aSame as with_in but for an output channel
opening flags (default [Unix.O_CREAT; Unix.O_TRUNC]) Unix.O_WRONLY is used in any cases.
val with_process_in : string -> f:(Pervasives.in_channel -> 'a) -> 'aOpen a subprocess and obtain a handle to its stdout
val with_process_out : string -> f:(Pervasives.out_channel -> 'a) -> 'aOpen a subprocess and obtain a handle to its stdin
type process_full =
< stdin : Pervasives.out_channel
; stdout : Pervasives.in_channel
; stderr : Pervasives.in_channel
; close : Unix.process_status >Handle to a subprocess.
val with_process_full :
?env:string array ->
string ->
f:(process_full -> 'a) ->
'aOpen a subprocess and obtain a handle to its channels.
environment to pass to the subprocess.
val with_connection :
Unix.sockaddr ->
f:(Pervasives.in_channel -> Pervasives.out_channel -> 'a) ->
'aWrap Unix.open_connection with a handler
val establish_server :
Unix.sockaddr ->
f:(Pervasives.in_channel -> Pervasives.out_channel -> _) ->
unitListen on the address and calls the handler in a blocking fashion. Using Thread is recommended if handlers might take time. The callback should raise ExitServer to stop the loop.
module Infix : sig ... endinclude module type of Infixval (?|) : ('a, Buffer.t, unit, call_result) Pervasives.format4 -> 'aInfix version of call
val (?|&) : ('a, Buffer.t, unit, async_call_result) Pervasives.format4 -> 'aInfix version of async_call