Synchronous filesystem operations
This module is independent of lwt. It might be useful, if you target windows:
include Uwt_base.Fs_functions with type 'a t := 'a Uwt_base.uv_resultinclude module type of Uwt_base.Fs_types
with type uv_open_flag = Uwt_base.Fs_types.uv_open_flag
with type file_kind = Uwt_base.Fs_types.file_kind
with type symlink_mode = Uwt_base.Fs_types.symlink_mode
with type access_permission = Uwt_base.Fs_types.access_permission
with type stats = Uwt_base.Fs_types.statstype uv_open_flag = Uwt_base.Fs_types.uv_open_flag = | O_RDONLYOpen for reading
*)| O_WRONLYOpen for writing
*)| O_RDWROpen for reading and writing
*)| O_NONBLOCKOpen in non-blocking mode, ignored on Windows
*)| O_CREATCreate if nonexistent
*)| O_EXCLFail if existing
*)| O_TRUNCTruncate to 0 length if existing
*)| O_APPENDOpen for append
*)| O_NOCTTYDon't make this dev a controlling tty, ignored on Windows
*)| O_DSYNCWrites complete as `Synchronised I/O data integrity completion', ignored by some platforms
*)| O_SYNCWrites complete as `Synchronised I/O file integrity completion', ignored by some platforms
*)| O_RSYNCReads complete as writes (depending on O_SYNC/O_DSYNC), only supported on some Unix platforms, ignored otherwise
*)| O_TEMPORARYwindows only, ignored on Unix
*)| O_SHORT_LIVEDwindows only, ignored on Unix
*)| O_SEQUENTIALwindows only, ignored on Unix
*)| O_RANDOMwindows only, ignored on Unix
*)| O_DIRECTOn Windows supported since libuv 1.16
*)| O_EXLOCKOS X (and Windows, but with different semantic)
*)| O_NOATIMEno windows, some Unix systems, ignored otherwise
*)| O_SYMLINKno windows, some Unix systems, ignored otherwise
*)| O_NOFOLLOWno windows, some Unix systems, ignored otherwise
*)| O_DIRECTORYno windows, some Unix systems, ignored otherwise
*)Flags for Fs_functions.openfile
O_CLOEXEC doesn't exist, because this flag is unconditionally added by libuv. O_SHARE_DELETE, O_SHARE_WRITE, O_SHARE_READ are always added on Windows, unless O_EXLOCK is specified.
type file_kind = Uwt_base.Fs_types.file_kind = type symlink_mode = Uwt_base.Fs_types.symlink_mode = On Windows it can be specified how to create symlinks.
type access_permission = Uwt_base.Fs_types.access_permission = type stats = Uwt_base.Fs_types.stats = {st_dev : int;Device number
*)st_kind : file_kind;Kind of the file
*)st_perm : int;Access rights
*)st_nlink : int;Number of links
*)st_uid : int;User id of the owner
*)st_gid : int;Group ID of the file's group
*)st_rdev : int;Device minor number
*)st_ino : int;Inode number
*)st_size : int64;Size in bytes
*)st_blksize : int;"Preferred" block size for efficient filesystem I/O
*)st_blocks : int;Number of blocks allocated to the file, in 512-byte units
*)st_flags : int;User defined flags for file
*)st_gen : int;File generation number
*)st_atime : int64;Last access time
*)st_atime_nsec : int;Nanosecond components of last access time
*)st_mtime : int64;Last modification time
*)st_mtime_nsec : int;Nanosecond components of last modification time
*)st_ctime : int64;Last status change time
*)st_ctime_nsec : int;Nanosecond components of lastt status change time
*)st_birthtime : int64;File creation time
*)st_birthtime_nsec : int;Nanosecond components of File creation time
*)}File status information. Support for the various fields differs depending on the OS and filesystem.
val openfile :
?perm:int ->
mode:uv_open_flag list ->
string ->
Uwt_base.file Uwt_base.uv_resultEquivalent to open(2).
val read :
?pos:int ->
?len:int ->
Uwt_base.file ->
buf:bytes ->
int Uwt_base.uv_resultread ~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.
val read_ba :
?pos:int ->
?len:int ->
Uwt_base.file ->
buf:Uwt_base.buf ->
int Uwt_base.uv_resultlike 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 ->
Uwt_base.file ->
fd_offset:int64 ->
buf:bytes ->
int Uwt_base.uv_resultval pread_ba :
?pos:int ->
?len:int ->
Uwt_base.file ->
fd_offset:int64 ->
buf:Uwt_base.buf ->
int Uwt_base.uv_resultval write :
?pos:int ->
?len:int ->
Uwt_base.file ->
buf:bytes ->
int Uwt_base.uv_resultwrite 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 ->
Uwt_base.file ->
buf:string ->
int Uwt_base.uv_resultval write_ba :
?pos:int ->
?len:int ->
Uwt_base.file ->
buf:Uwt_base.buf ->
int Uwt_base.uv_resultval pwrite :
?pos:int ->
?len:int ->
Uwt_base.file ->
fd_offset:int64 ->
buf:bytes ->
int Uwt_base.uv_resultval pwrite_string :
?pos:int ->
?len:int ->
Uwt_base.file ->
fd_offset:int64 ->
buf:string ->
int Uwt_base.uv_resultval pwrite_ba :
?pos:int ->
?len:int ->
Uwt_base.file ->
fd_offset:int64 ->
buf:Uwt_base.buf ->
int Uwt_base.uv_resultval writev :
Uwt_base.file ->
Uwt_base.Iovec_write.t list ->
int Uwt_base.uv_resultwrite 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 :
Uwt_base.file ->
Uwt_base.Iovec_write.t list ->
int64 ->
int Uwt_base.uv_resultval close : Uwt_base.file -> unit Uwt_base.uv_resultClose a file descriptor.
val unlink : string -> unit Uwt_base.uv_resultdelete a name and possibly the file it refers to
val mkdir : ?perm:int -> string -> unit Uwt_base.uv_resultCreate a directory.
val rmdir : string -> unit Uwt_base.uv_resultDelete an empty directory
val fsync : Uwt_base.file -> unit Uwt_base.uv_resultsynchronize a file's in-core state with storage device.
val fdatasync : Uwt_base.file -> unit Uwt_base.uv_resultval ftruncate : Uwt_base.file -> len:int64 -> unit Uwt_base.uv_resulttruncate a file to a specified length
val stat : string -> stats Uwt_base.uv_resultReturn the information for the named file.
val lstat : string -> stats Uwt_base.uv_resultval fstat : Uwt_base.file -> stats Uwt_base.uv_resultval rename : src:string -> dst:string -> unit Uwt_base.uv_resultchange the name or location of a file
val link : target:string -> link_name:string -> unit Uwt_base.uv_resultlink 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 Uwt_base.uv_resultsymlink creates a symbolic link named ~dst which contains the string ~src
val mkdtemp : string -> string Uwt_base.uv_resultThe 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:Uwt_base.file ->
src:Uwt_base.file ->
unit ->
nativeint Uwt_base.uv_resultA limited equivalent to sendfile(2). It copies data between one file descriptor and another
val utime : string -> access:float -> modif:float -> unit Uwt_base.uv_resultutime 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 :
Uwt_base.file ->
access:float ->
modif:float ->
unit Uwt_base.uv_resultval readlink : string -> string Uwt_base.uv_resultreadlink reads the value of a symbolic link
val access : string -> access_permission list -> unit Uwt_base.uv_resultCheck user's permissions for a file
val chmod : string -> perm:int -> unit Uwt_base.uv_resultChange the permissions of the named file.
val fchmod : Uwt_base.file -> perm:int -> unit Uwt_base.uv_resultChange the permissions of an opened file.
val chown : string -> uid:int -> gid:int -> unit Uwt_base.uv_resultChange the owner ~uid and owner ~gid of the named file.
val fchown : Uwt_base.file -> uid:int -> gid:int -> unit Uwt_base.uv_resultChange the owner ~uid and owner ~gid of the opened file.
val scandir : string -> (file_kind * string) array Uwt_base.uv_resultOn 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 Uwt_base.uv_resultEquivalent 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:
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 ->
?clone:clone_mode ->
src:string ->
dst:string ->
unit ->
unit Uwt_base.uv_resultCopies 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.
If ?clone is Try_clone, copyfile will attempt to create a copy-on-write reflink. If the underlying platform (or your installed libuv version) does not support copy-on-write, then a fallback copy mechanism is used. If ?clone is Force_clone, copyfile will attempt to create a copy-on-write reflink. If the underlying platform does not support copy-on-write, then an error is returned. The default behaviour is a normal copy (No_clone).
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.