Current
module Level : sig ... end
Each operation has a level, giving an estimate of the cost or risk of the operation. When testing a pipeline, it can be useful to set a maximum level, or to require confirmation for more risky operations.
module Config : sig ... end
class type actions = object ... end
module Metadata : sig ... end
Metadata associated with primitive terms.
module Primitive : sig ... end
An OCurrent pipeline is made up of primitive operations. A primitive is roughly the content of a single box in the diagram.
include Current_term.S.TERM
with type metadata := Metadata.t
and type 'a primitive := 'a Primitive.t
val active : Current_term.Output.active -> 'a t
active x
is a term indicating that the result is not determined yet.
val return : ?label:string -> 'a -> 'a t
return x
is a term that immediately succeeds with x
.
val fail : string -> 'a t
fail m
is a term that immediately fails with message m
.
val state :
?hidden:bool ->
'a t ->
('a, [ `Active of Current_term.Output.active | `Msg of string ])
Stdlib.result
t
state t
always immediately returns a successful result giving the current state of t
.
val catch : ?hidden:bool -> 'a t -> 'a Current_term.S.or_error t
catch t
successfully returns Ok x
if t
evaluates successfully to x
, or successfully returns Error e
if t
fails with error e
. If t
is active then catch t
will be active too.
val of_output : 'a Current_term.Output.t -> 'a t
of_output x
is a returned, failed or active term.
map f x
is a term that runs x
and then transforms the result using f
.
The optional equality function ?eq
defaults to physical equality. When f
produces an updated result following a change in x
, the equality function will be called with the previous and the new value eq b_old b_new
: returning true
indicates that the change can be ignored and should not propagate further down the pipeline.
map_error f x
is a term that runs x
and then transforms the error string (if any) using f
.
pair a b
is the pair containing the results of evaluating a
and b
(in parallel).
val list_map :
(module Current_term.S.ORDERED with type t = 'a) ->
?collapse_key:string ->
?label:string ->
('a t -> 'b t) ->
'a list t ->
'b list t
list_map (module T) f xs
adds f
to the end of each input term and collects all the results into a single list.
val list_iter :
(module Current_term.S.ORDERED with type t = 'a) ->
?collapse_key:string ->
?label:string ->
('a t -> unit t) ->
'a list t ->
unit t
Like list_map
but for the simpler case when the result is unit.
list_seq x
evaluates to a list containing the results of evaluating each element in x
, once all elements of x
have successfully completed.
option_map f x
is a term that evaluates to Some (f y)
if x
evaluates to Some y
, or to None
otherwise.
Like option_map
but for the simpler case when the result is unit.
option_seq None
is Current.return None
and option_seq (Some x)
is Current.map some x
. This is useful for handling optional arguments that are currents.
all xs
is a term that succeeds if every term in xs
succeeds. The labels are used if some terms fail, to indicate which ones are failing.
gate ~on:ctrl x
is the same as x
, once ctrl
succeeds.
Note: gate
does not delay x
; it only delays whatever you put after the gate. e.g.
let binary = build src in
let tests_ok = test binary in
binary |> gate ~on:tests_ok |> deploy
cutoff ~eq x
is the same as x
, but changes to x
that are equal according to eq
do not propagate further down. It should be used when values of type 'a
have a precise definition of equality to avoid triggering redundant work.
collapse ~key ~value ~input t
is a term that behaves just like t
, but when shown in a diagram it can be expanded or collapsed. When collapsed, it is shown as "input -> +
" and the user can expand it to show t
instead. The idea is that input
is a dependency of t
and the "+" represents everything in t
after that. key
and value
are used as the parameters (e.g. in a URL) to control whether this is expanded or not. For example collapse ~key:"repo" ~value:"mirage/mirage-www" ~input:repo (process repo)
Note: list_map ~collapse_key
provides an easy way to use this.
collapse_list ~key ~value ~input t
is a term that behaves just like t
list, but when shown in a diagram it can be expanded or collapsed.
with_context ctx f
is the term f ()
, where f
is evaluated in context ctx
. This means that ctx
will be treated as an input to all terms created by f
in the diagrams.
N.B. these operations create terms that cannot be statically analysed until after they are executed.
val bind :
?info:description ->
?eq:('b -> 'b -> bool) ->
('a -> 'b t) ->
'a t ->
'b t
bind f x
is a term that first runs x
to get y
and then behaves as the term f y
. Static analysis cannot look inside the f
function until x
is ready, so using bind
makes static analysis less useful. You can use the info
argument to provide some information here.
val primitive : info:description -> ('a -> 'b Primitive.t) -> 'a t -> 'b t
primitive ~info f x
is a term that evaluates f
on each new value of x
. This is used to provide the primitive operations, which can then be combined using the other combinators in this module. info
is used to label the operation in the diagram.
val component :
('a, Stdlib.Format.formatter, unit, description) Stdlib.format4 ->
'a
component name
is used to annotate binds, so that the system can show a name for the operations hidden inside the bind's function. name
is used as the label for the bind in the generated dot diagrams. For convenience, name
can also be a format string.
val observe : 'a t -> 'a Current_term.Output.Blockable.t
observe x
evaluates the current state of term x
. A `Blocked
value occurs when the term failed because an upstream dependency errored.
module Syntax : sig ... end
module Monitor : sig ... end
A monitor is an input pipeline stage that can watch for external events.
type 'a term = 'a t
An alias of t
to make it easy to refer to later in this file.
module Analysis :
Current_term.S.ANALYSIS
with type 'a term := 'a t
and type metadata := Metadata.t
Diagram generation, introspection, and statistics.
module Var (T : Current_term.S.T) : sig ... end
Variable pipeline inputs.
state_dir name
is a directory under which state (build results, logs) can be stored. name
identifies the sub-component of OCurrent, each of which gets its own subdirectory.
module String : sig ... end
module Unit : sig ... end
module Switch : sig ... end
Like Lwt_switch
, but the cleanup functions are called in sequence, not in parallel.
module Pool : sig ... end
Resource pools, to control how many jobs can use a resource at a time. To use a pool within a job, pass the pool to Job.start
or call Job.use_pool
.
module Job : sig ... end
Jobs with log files. This is mostly an internal interface - use Current_cache
instead.
module Engine : sig ... end
The main event loop.
module Process : sig ... end
Helper functions for spawning sub-processes.
module Db : sig ... end
Access to the sqlite database.
module Log_matcher : sig ... end
Analysing job logs.