module type VERTEX
exception Process_error of OpamProcess.result
Exception raised when subprocess fails
val process_error : OpamProcess.result -> 'a
val raise_on_process_error : OpamProcess.result -> unit
Process_error if the process didn't return 0
val internal_error : ( 'a, unit, string, 'b ) format4 -> 'a
with_tmp_dir fn executes
fn creates a temporary directory and passes its name to
fn. The directory is alwasy removed on completion.
Runs a job with a temp dir that is cleaned up afterwards
Returns true if the default verbose level for base commands (cp, mv, etc.) is reached
Returns a directory name, in the temporary directory, composed by opam (if
prefix is not set), pid, and random number.
copy_file src dst copies
dst before the copy if it is a link.
copy_dir src dst copies the contents of directory
src into directory
dst, creating it if necessary, merging directory contents and ovewriting files otherwise
type install_warning = [
Warnings which come from
type install_warning_fn = string -> install_warning -> unit
val default_install_warning : install_warning_fn
The default warning function - displays a message on OpamConsole
val install : ?warning:install_warning_fn -> ?exec:bool -> string -> string -> unit
install ?exec src dst copies file
src as file
exec, make the resulting file executable (otherwise, look at the permissions of the original file to decide).
Checks if a file is an executable (regular file with execution permission)
link src dst links
dst if it is a file, not a directory.
real_path p returns the real path associated to
.. are expanded and relative paths become absolute.
val string_of_channel : in_channel -> string
Return the contents of a channel.
Raised when a file or directory can't be accessed (doesn't exist, bad permissions, etc.)
read filename returns the contents of
filename (while taking an advisory read lock to prevent concurrent writes)
write filename contents write
filename (while taking an advisory write lock to prevent concurrent reads or writes)
remove filename removes
filename. Works whether
filename is a file or a directory
remove_file filename removes
filename. Works only for normal files (or also at least for symlinks)
remove_dir filename removes
filename. Works only for directory (not for symlinks or other files).
Returns the list of files and directories in the given directory (full names)
files_with_links dir returns the files in the directory
dir. Links simulating directory are ignored, others links are returned.
rec_files dir returns the list of all files in
dir, recursively. Links behaving like directory are crossed.
Return the list of files in the current directory, inclduing any dangling symlinks.
rec_dirs dir return the list list of all directories recursively (going through symbolink links).
directories_with_links dir returns the directories in the directory
dir. Links pointing to directory are also returned.
val make_command : ?verbose:bool -> ?env:string array -> ?name:string -> ?text:string -> ?metadata:(string * string) list -> ?allow_stdin:bool -> ?stdout:string -> ?dir:string -> ?resolve_path:bool -> string -> string list -> OpamProcess.command
Make a comman suitable for OpamProcess.Job. if
verbose, is set, command and output will be displayed (at command end for the latter, if concurrent commands are running).
name is used for naming log files.
text is what is displayed in the status line for this command. May raise Command_not_found, unless
resolve_path is set to false (in which case you can end up with a process error instead)
OLD COMMAND API, DEPRECATED
Test whether a command exists in the environment, and returns it (resolved if found in PATH)
Returns a function which should be applied to arguments for a given command by determining if the command is the Cygwin variant of the command. Returns the identity function otherwise.
val command : ?verbose:bool -> ?env:string array -> ?name:string -> ?metadata:(string * string) list -> ?allow_stdin:bool -> command -> unit
command cmd executes the command
cmd in the correct OPAM environment.
val commands : ?verbose:bool -> ?env:string array -> ?name:string -> ?metadata:(string * string) list -> ?keep_going:bool -> command list -> unit
commands cmds executes the commands
cmds in the correct OPAM environment. It stops whenever one command fails unless
keep_going is set to
true. In this case, the first error is re-raised at the end.
val read_command_output : ?verbose:bool -> ?env:string array -> ?metadata:(string * string) list -> ?allow_stdin:bool -> command -> string list
read_command_output cmd executes the command
cmd in the correct OPAM environment and return the lines from stdout if the command exists normally. If the command does not exist or if the command exited with a non-empty exit-code, throw an error.
extract ~dir:dirname filename extracts the archive
dirname should not exists and
filename should contain only one top-level directory.
val extract_job : dir:string -> string -> exn option OpamProcess.job
extract, but as an OpamProcess.job
extract_in ~dir:dirname filename extracts the archive
val extract_in_job : dir:string -> string -> exn option OpamProcess.job
extract_in_job is similar to
extract_in, but as a job
val make_tar_gz_job : dir:string -> string -> exn option OpamProcess.job
The different kinds of unix advisory locks available (`Lock_none doesn't actually lock anything, or even create the lock file)
type lock_flag = [
val lock_none : lock
Force releases all open locks in the process. Required for Windows if an exception has been raised, since Windows doesn't permit unlinking while handles are open.
Acquires a lock on the given file. Raises
Locked if the lock can't be acquired and
dontblock is set. Raises
safe_mode is set and a write lock is required. Also raises Unix errors if the lock file can't be opened.
Updates an existing lock to the given level. Raises the same exceptions as
val funlock : lock -> unit
Releases an acquired lock (equivalent to
Returns the highest of the two lock flags (with the order no lock < read lock < write lock)
Returns true if the lock already has the lock_flag rights or more
Returns the underlying fd for the lock or raises Not_found for `No_lock
val patch : ?preprocess:bool -> dir:string -> string -> exn option OpamProcess.job
Apply a patch file in the current directory. If
preprocess is set to false, there is no CRLF translation. Returns the error if the patch didn't apply.
Returns the end-of-line encoding style for the given file.
None means that either the encoding of line endings is mixed, or the file contains no line endings at all (an empty file, or a file with one line and no EOL at EOF). Otherwise it returns
Some true if all endings are encoded CRLF.
translate_patch ~dir input_patch output_patch writes a copy of
output_patch as though
input_patch had been applied in
dir. The patch is rewritten such that if text files have different line endings then the patch is transformed to patch using the encoding on disk. In particular, this means that patches generated against Unix checkouts of Git sources will correctly apply to Windows checkouts of the same sources.
Create a temporary file in ~/.opam/logs/<name>XXX, if
dir is not set. ?auto_clean controls whether the file is automatically deleted when opam terminates (default:
Registers an exception printer that adds some OPAM version info, and details on process and Unix errors
Initialises signal handlers, catch_break and some exception printers. The lib may not perform properly without this if
Sys.catch_break isn't set and SIGPIPE isn't handled (with a no-op)
val classify_executable : string -> [ `Exe of [ `i386 | `x86 | `x86_64 ] | `Dll of [ `x86 | `x86_64 ] | `Script | `Unknown ]
Identifies kinds of executable files. At present, only useful on Windows. Executable or DLLs are recognised based on their content, not on their filename. Any file beginning "#!" is assumed to be a shell script and all files are classified