bistro 0.3.0 · OCaml Package

A library to build scientific workflows.

This module introduces a type 'a worfklow that describe a set of inter-dependent actions that will eventually generate a target (file or directory). The 'a type represents the format of the file or the layout of the directory. Actions may be either command lines to be executed, or OCaml expressions to be evaluated.

To build workflows, use the EDSL module, that provide a set of combinators to write shell scripts easily. For instance, the following function shows how to create a gzipped file using the output of another workflow:

let gzip (x : 'a workflow) : 'a gz workflow =
  workflow ~descr:"unix.gzip" [
    cmd "gzip" [ string "-c" ; dep x ; string ">" dest ]
  ]

Note that a workflow is just a recipe to build some result. Building the workflow won't actually generate anything. In order to run the workflow, you have to run it using an execution engine like the one provided by bistro.engine.

type +'a workflow

The type representing a set of actions (shell scripts or (evaluations of OCaml expressions) to build a target of type 'a. The type 'a is a phantom type, which can be used to enforce static invariants.

type 'a directory = [

| `directory of 'a

]

Conventional type to represent directory targets

class type ['a, 'b] file = object ... end

Conventional type to represent file targets. The object type is to represent properties of the file, like the type of encoding (text or binary) or the format.

class type 'a value = object ... end

Conventional type to represent OCaml values saved with the Marshal module.

type any_workflow =

| Workflow : _ workflow -> any_workflow
(*
Encapsulate a workflow target type
*)

module Path : sig ... end

Helper functions to represent paths as string lists. For absolute paths, the first element of the list is "/".

type u = private

| Input of string * Path.t
| Select of string * u * Path.t
| Step of step

Workflow representation

and step = private {

id : string;
descr : string;
deps : u list;
action : action;
np : int;
(*
Required number of processors
*)
mem : int;
(*
Required memory in MB
*)
version : int option;
(*
Version number of the wrapper
*)

}

and action =

| Exec of command
| Eval of some_expression

and command =

| Docker of docker_image * command
| Simple_command of token list
| And_list of command list
| Or_list of command list
| Pipe_list of command list

and token =

| S of string
| D of u
| F of token list
| DEST
| TMP
| NP
| MEM

and some_expression =

| Value : _ expression -> some_expression
| File : unit expression -> some_expression
| Directory : unit expression -> some_expression

and _ expression =

| Expr_pure : {
1. id : string;
2. value : 'a;
} -> 'a expression
| Expr_app : ('a -> 'b) expression * 'a expression -> 'b expression
| Expr_dest : string expression
| Expr_tmp : string expression
| Expr_np : int expression
| Expr_mem : int expression
| Expr_dep : _ workflow -> string expression
| Expr_deps : _ workflow list -> string list expression
| Expr_valdep : 'a value workflow -> 'a expression
| Expr_valdeps : 'a value workflow list -> 'a list expression

and docker_image = private {

dck_account : string;
dck_name : string;
dck_tag : string option;
dck_registry : string option;

}

Name and version of an external dependency for a workflow

type (-'a, +'b) selector = private

| Selector of Path.t

Describes the (relative) path from a 'a directory workflow target to some 'b workflow target. This is useful to construct new workflows by selecting a file or surdirectory in the result of a directory workflow.

module Workflow : sig ... end

module Template : sig ... end

Represents a text with special symbols

module EDSL : sig ... end

This module provides combinators to define new workflows that execute shell commands.

module EDSL' : sig ... end

This module provides an alternative DSL to construct workflows whose action is to evaluate an OCaml expression.

module Std : sig ... end

Standard definitions

package bistro