package uwt

You can search for identifiers within the package.

in-package search v0.2.0

package uwt

uwt.async
- Uwt
  - Async
  - C_worker
  - Conv
  - Debug
  - 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

include Fs_functions with type 'a t := 'a Lwt.t

include sig ... end

type uv_open_flag = Fs_types.uv_open_flag =

| O_RDONLY
(*
Open for reading
*)
| O_WRONLY
(*
Open for writing
*)
| O_RDWR
(*
Open for reading and writing
*)
| O_NONBLOCK
(*
Open in non-blocking mode, ignored on Windows
*)
| O_CREAT
(*
Create if nonexistent
*)
| O_EXCL
(*
Fail if existing
*)
| O_TRUNC
(*
Truncate to 0 length if existing
*)
| O_APPEND
(*
Open for append
*)
| O_NOCTTY
(*
Don't make this dev a controlling tty, ignored on Windows
*)
| O_DSYNC
(*
Writes complete as `Synchronised I/O data integrity completion', ignored by some platforms
*)
| O_SYNC
(*
Writes complete as `Synchronised I/O file integrity completion', ignored by some platforms
*)
| O_RSYNC
(*
Reads complete as writes (depending on O_SYNC/O_DSYNC), only supported on some Unix platforms, ignored otherwise
*)
| O_TEMPORARY
(*
windows only, ignored on Unix
*)
| O_SHORT_LIVED
(*
windows only, ignored on Unix
*)
| O_SEQUENTIAL
(*
windows only, ignored on Unix
*)
| O_RANDOM
(*
windows only, ignored on Unix
*)
| O_DIRECT
(*
On Windows supported since libuv 1.16
*)
| O_EXLOCK
(*
OS X (and Windows, but with different semantic)
*)
| O_NOATIME
(*
no windows, some Unix systems, ignored otherwise
*)
| O_SYMLINK
(*
no windows, some Unix systems, ignored otherwise
*)
| O_NOFOLLOW
(*
no windows, some Unix systems, ignored otherwise
*)
| O_DIRECTORY
(*
no windows, some Unix systems, ignored otherwise
*)

O_CLOEXEC and O_SHARE_DELETE, O_SHARE_WRITE, O_SHARE_READ don't exist, because these flags are unconditionally added by libuv, if the platform supports them.

type file_kind = Fs_types.file_kind =

| S_REG
(*
Regular file
*)
| S_DIR
(*
Directory
*)
| S_CHR
(*
Character device
*)
| S_BLK
(*
Block device
*)
| S_LNK
(*
Symbolic link
*)
| S_FIFO
(*
Named pipe
*)
| S_SOCK
(*
Socket
*)
| S_UNKNOWN
(*
Everything else - possible on some platforms.
*)

type symlink_mode = Fs_types.symlink_mode =

| S_Default
| S_Dir
(*
indicates that path points to a directory.
*)
| S_Junction
(*
request that the symlink is created using junction points.
*)

On Windows it can be specified how the symlink will be created:

type access_permission = Fs_types.access_permission =

| Read
(*
Read permission
*)
| Write
(*
Write permission
*)
| Exec
(*
Execution permission
*)
| Exists
(*
File exists
*)

type stats = Fs_types.stats = {

st_dev : int;
st_kind : file_kind;
st_perm : int;
st_nlink : int;
st_uid : int;
st_gid : int;
st_rdev : int;
st_ino : int;
st_size : int64;
st_blksize : int;
st_blocks : int;
st_flags : int;
st_gen : int;
st_atime : int64;
st_atime_nsec : int;
st_mtime : int64;
st_mtime_nsec : int;
st_ctime : int64;
st_ctime_nsec : int;
st_birthtime : int64;
st_birthtime_nsec : int;

}

val openfile : ?perm:int -> mode:uv_open_flag list -> string -> file Lwt.t

Equivalent to open(2).

parameter perm
defaults are 0o644

val read : ?pos:int -> ?len:int -> file -> buf:bytes -> int Lwt.t

read ~pos ~len fd ~buf reads ~len bytes from descriptor fd, storing them in byte sequence buf, starting at position ~pos in ~buf. Return the number of bytes actually read.

parameter pos
default is always zero

parameter len
default is always the still available length of the string / bigarray / Bytes.t

val read_ba : ?pos:int -> ?len:int -> file -> buf:buf -> int Lwt.t

like read, buf for bigarrays. Bigarrays are passed directly to libuv (no copy to c heap or stack). It's faster, but you must manually ensure, that the bigarray is not accessed from another thread.

val pread : 
  ?pos:int ->
  ?len:int ->
  file ->
  fd_offset:int64 ->
  buf:bytes ->
  int Lwt.t

pread is equivalent to read, except that it reads from a given position ~fd_offset in the file without changing the file offset.

val pread_ba : 
  ?pos:int ->
  ?len:int ->
  file ->
  fd_offset:int64 ->
  buf:buf ->
  int Lwt.t

val write : ?pos:int -> ?len:int -> file -> buf:bytes -> int Lwt.t

write fd ~pos ~len fd ~buf writes ~len bytes to descriptor fd, taking them from byte sequence buf, starting at position ~pos in ~buf. Return the number of bytes actually written.

val write_string : ?pos:int -> ?len:int -> file -> buf:string -> int Lwt.t

val write_ba : ?pos:int -> ?len:int -> file -> buf:buf -> int Lwt.t

val pwrite : 
  ?pos:int ->
  ?len:int ->
  file ->
  fd_offset:int64 ->
  buf:bytes ->
  int Lwt.t

pwrite is equivalent to write, except that it writes into a given position ~fd_offset and does not change the file offset

val pwrite_string : 
  ?pos:int ->
  ?len:int ->
  file ->
  fd_offset:int64 ->
  buf:string ->
  int Lwt.t

val pwrite_ba : 
  ?pos:int ->
  ?len:int ->
  file ->
  fd_offset:int64 ->
  buf:buf ->
  int Lwt.t

val writev : file -> Iovec_write.t list -> int Lwt.t

write multiple buffers at once. If the number of buffers is greater than IOV_MAX, newer libuv versions already contains code to circumvent this issue

val pwritev : file -> Iovec_write.t list -> int64 -> int Lwt.t

pwritev is equivalent to pwrite, except that it writes into a given position and does not change the file offset

val close : file -> unit Lwt.t

Close a file descriptor.

val unlink : string -> unit Lwt.t

delete a name and possibly the file it refers to

val mkdir : ?perm:int -> string -> unit Lwt.t

Create a directory.

parameter perm
defaults are 0o777

val rmdir : string -> unit Lwt.t

Delete an empty directory

val fsync : file -> unit Lwt.t

synchronize a file's in-core state with storage device.

val fdatasync : file -> unit Lwt.t

fdatasync is similar to fsync, but does not flush modified metadata unless that metadata is needed in order to allow a subsequent data retrieval to be correctly handled.

val ftruncate : file -> len:int64 -> unit Lwt.t

truncate a file to a specified length

val stat : string -> stats Lwt.t

Return the information for the named file.

val lstat : string -> stats Lwt.t

lstat is identical to stat, except that if pathname is a symbolic link. In this case it returns information about the link itself.

val fstat : file -> stats Lwt.t

fstat is identical to stat, except that the file about which information is to be retrieved is specified by the file descriptor

val rename : src:string -> dst:string -> unit Lwt.t

change the name or location of a file

val link : target:string -> link_name:string -> unit Lwt.t

link creates a new link (also known as a hard link) to an existing file

val symlink : 
  ?mode:symlink_mode ->
  src:string ->
  dst:string ->
  unit ->
  unit Lwt.t

symlink creates a symbolic link named ~dst which contains the string ~src

parameter mode
default S_Default

val mkdtemp : string -> string Lwt.t

The mkdtemp function generates a uniquely named temporary directory from template. The last six characters of template must be XXXXXX and these are replaced with a string that makes the directory name unique

val sendfile : 
  ?pos:int64 ->
  ?len:nativeint ->
  dst:file ->
  src:file ->
  unit ->
  nativeint Lwt.t

A limited equivalent to sendfile(2). It copies data between one file descriptor and another

parameter pos
default 0

parameter len
Nativeint.max_int

val utime : string -> access:float -> modif:float -> unit Lwt.t

utime changes the access and modification times of a file. If both times are 0.0, the access and last modification times are both set to the current time.

val futime : file -> access:float -> modif:float -> unit Lwt.t

futime is identical to utime, except that the file about which information is to be retrieved is specified by the file descriptor

val readlink : string -> string Lwt.t

readlink reads the value of a symbolic link

val access : string -> access_permission list -> unit Lwt.t

Check user's permissions for a file

val chmod : string -> perm:int -> unit Lwt.t

Change the permissions of the named file.

val fchmod : file -> perm:int -> unit Lwt.t

Change the permissions of an opened file.

val chown : string -> uid:int -> gid:int -> unit Lwt.t

Change the owner ~uid and owner ~gid of the named file.

val fchown : file -> uid:int -> gid:int -> unit Lwt.t

Change the owner ~uid and owner ~gid of the opened file.

val scandir : string -> (file_kind * string) array Lwt.t

On Linux, getting the type of an entry is only supported by some filesystems (btrfs, ext2, ext3 and ext4 at the time of this writing), check the getdents(2) man page.

val realpath : string -> string Lwt.t

Equivalent to realpath(3) on Unix. Windows uses GetFinalPathNameByHandle.

Warning This function has certain platform specific caveats that were discovered when used in Node.

macOS and other BSDs: this function will fail with UV_ELOOP if more than 32 symlinks are found while resolving the given path. This limit is hardcoded and cannot be sidestepped.

Windows: while this function works in the common case, there are a number of corner cases where it doesn't:

Paths in ramdisk
volumes created by tools which sidestep the Volume Manager (such as ImDisk) cannot be resolved.
Inconsistent casing when using drive letters.
Resolved path bypasses subst'd drives.

While this function can still be used, it's not recommended if scenarios such as the above need to be supported.

val copyfile : ?excl:bool -> src:string -> dst:string -> unit -> unit Lwt.t

Copies a file from ~src to ~dst.

If ?excl is true, copyfile() will fail with EEXIST if the destination path already exists. The default behavior is to overwrite the destination if it exists.

Warning: If the destination path is created, but an error occurs while copying the data, then the destination path is removed. There is a brief window of time between closing and removing the file where another process could access the file.