package uwt

You can search for identifiers within the package.

in-package search v0.2.0

uwt
- Uwt
  - C_worker
  - Conv
  - Dns
  - Fs
  - Fs_event
  - Fs_functions
  - Fs_poll
  - Fs_types
  - Handle
  - Handle_ext
  - Handle_fileno
  - Int_result
  - Iovec_write
  - Main
  - Misc
  - Pipe
  - Poll
  - Process
  - Signal
  - Stream
  - Sys_info
  - Tcp
  - Timer
  - Tty
  - Udp
  - Unix
uwt.base
- Uwt_base
  - Conv
  - Fs_functions
  - Fs_types
  - Int_result
  - Iovec_write
  - Misc
  - Sys_info
- Uwt_bytes
uwt.compat
- Uwt_compat
  - Lwt_unix
    
    LargeFile
uwt.ext
- Uwt_chan
- Uwt_io
  - BE
  - LE
  - NumberIO
- Uwt_log
  - Section
- Uwt_process
- Uwt_throttle
  - Make
  - S
- Uwt_timeout
uwt.preemptive
- Uwt_preemptive
uwt.sync
- Uv_fs_sync

Legend:
Library
Module
Module type
Parameter
Class
Class type

type t

include module type of Handle with type t := t

val close : t -> Int_result.unit

Handles are closed automatically, if they are not longer referenced from the OCaml heap. Nevertheless, you should nearly always close them with close, because:

if they wrap a file descriptor, you will sooner or later run out of file descriptors. The OCaml garbage collector doesn't give any guarantee, when orphaned memory blocks are removed.

you might have registered some repeatedly called action (e.g. timeout, read_start,...), that prevent that all references get removed from the OCaml heap.

However, it's safe to write code in this manner:

let s = Uwt.Tcp.init () in
let c = Uwt.Tcp.init () in
Uwt.Tcp.nodelay s false;
Uwt.Tcp.simultaneous_accepts true;
if foobar () then (* no file descriptor yet assigned, no need to worry
                     about exceptions inside foobar,... *)
  Lwt.return_unit (* no need to close *)
else
  ...

If you want - for whatever reason - keep a file descriptor open for the whole lifetime of your process, remember to keep a reference to its handle.

val close_noerr : t -> unit

val close_wait : t -> unit Lwt.t

Prefer close or close_noerr to close_wait. close or close_noerr return immediately (there are no useful error messages, beside perhaps a notice, that you've already closed that handle).

close_wait is only useful, if you intend to wait until all concurrent write and read threads related to this handle are canceled.

val is_active : t -> bool

val ref' : t -> unit

val unref : t -> unit

val has_ref : t -> bool

val handle_type : t -> Misc.handle_type

val to_handle : t -> Handle.t

type stdio =

| Inherit_file of file
| Create_pipe of Pipe.t
| Inherit_pipe of Pipe.t
| Inherit_stream of Stream.t

type exit_cb = t -> exit_status:int -> term_signal:int -> unit

val spawn : 
  ?stdin:stdio ->
  ?stdout:stdio ->
  ?stderr:stdio ->
  ?uid:int ->
  ?gid:int ->
  ?verbatim_arguments:bool ->
  ?detach:bool ->
  ?hide:bool ->
  ?env:string list ->
  ?cwd:string ->
  ?exit_cb:exit_cb ->
  string ->
  string list ->
  t uv_result

parameter verbatim_arguments
default false

parameter detach
default false

parameter hide
default true

val spawn_exn : 
  ?stdin:stdio ->
  ?stdout:stdio ->
  ?stderr:stdio ->
  ?uid:int ->
  ?gid:int ->
  ?verbatim_arguments:bool ->
  ?detach:bool ->
  ?hide:bool ->
  ?env:string list ->
  ?cwd:string ->
  ?exit_cb:exit_cb ->
  string ->
  string list ->
  t

val disable_stdio_inheritance : unit -> unit

val pid : t -> Int_result.int

val pid_exn : t -> int

val process_kill : t -> int -> Int_result.unit

val process_kill_exn : t -> int -> unit

val kill : pid:int -> signum:int -> Int_result.unit

val kill_exn : pid:int -> signum:int -> unit