Index of values

a && b is a program than runs a then b iff a succeeded.

Create an absolute path to a directory, raises Invalid_argument _ if the path is not absolute.

Create an absolute path to a file, raises Invalid_argument _ if the path is not absolute.

Get an activated target out of a “submitted” one, raises Invalid_argument _ if the target is in a wrong state.

Add a list of targets to the engine.

Get the potential additional queries ((key, description) pairs) that can be called on the target.

List of potential (query, description) pairs that can be passed to Ketrew_long_running.LONG_RUNNING.query.

Get all the current targets.

Get the list of targets currently handled.

Run the function f with a fresh-client created with the configuration.

Edit content in "$EDITOR".

Create an “inline” authentication token, i.e.

The path to the authorized_tokens file.

Ask the server to load tokens from a file at the given path.

Transform complex Ketrew values into display-friendly Log.t values.

Figure out the targets to be displayed.

Call a query on a target.

Call a target's plugin query by name.

Chain a list of programs like with &&.

Get a glance at the gravity of the situation: `Unix: a function of the kind Unix.exec failed., `Ssh: SSH failed to run something but it does not mean that the actual command is wrong., `Execution: SSH/Unix succeeded but the command failed.

Transform most known errors into long-running plugin API errors; using Ketrew_host.Error.classify.

Create a client configuration:

Cmdliner term which creates a host argument or flag.

Go through a list of Items and find pairs of incoming/ending HTTP requests, return statistics about them.

Get the path to the “command” named pipe.

Comparison function that can be given to functions like List.sort.

Safely concatenate two paths (calls Filename.concat).

Retrieve the configuration used to create the client.

Retrieve the configuration.

Configure global “Batch option”, (call ssh without password/question): for OpenSSH, it is "-oBatchMode=yes",, for DropBear, it is "-s".

Count how many times a current non-fatal failure state “repeats.” I.e.

Create a “long-running” Ketrew_target.build_process (run parameters are already serialized), see Ketrew_edsl.yarn_application.

Create a fresh filename-compliant identifier.

Create a “long-running” Ketrew_target.build_process to run a Ketrew_program.t on a given PBS-enabled host (run parameters already serialized): ?queue is the name of the PBS queue requested ("-q" option). , ?name is the job name ("-N" option). , ?wall_limit is the job's Wall-time timeout ("-l" option, default: 24 H). , ?processors is the “processors” request ("-l" option). , ?email_user tell PBS to send emails to the given address. , ?shell sets the shell used for the "#!" of the PBS script.

Create a new script, which will run the list of commands, and store state values in the playground directory.

Create a “long-running” Ketrew_target.build_process to run a Ketrew_program.t on a given LSF-enabled host (run parameters already serialized): ?queue is the name of the LSF queue requested ("-q" option). , ?name is the job name ("-J" option). , ?wall_limit is the job's Wall-time timeout ("-W" option). , ?processors is the “processors” request ("-n" option). , ?project is the job assigned “project” ("-P" option).

Create a complete configuration:

Create a “long-running” Ketrew_target.build_process (run parameters are already serialized), see Ketrew_edsl.daemonize for more details

Create a target value (not stored in the DB yet).

Tell whether the server should detach.

Create a “daemonize” build process:

Get the database parameters.

Default path to the database (used when generating custom configuration files).

The default values of the Explorer configuration.

The “long-running” plugins loaded by default.

Use default_shell ~binary:"/bin/sh" ~options:["-l"; "--something"; "blah" ] ~command_option:"-c" "sh" to define a default-shell calling "sh -l --something blah -c <command>".

Specification of the default shell of a Host.

Default (upper bound) of the `?timeout` arguments.

Deserilize a target from a string.

Deserialize the run parameters from a string; the engine guaranties that deserialize_exn will be called on the result of Ketrew_long_running.LONG_RUNNING.serialize; and assumes that no exception will be thrown in that case.

Create a path to a directory.

Create a value `Distributed_shell _ to feed to Ketrew_yarn.create, see Ketrew_edsl.yarn_distributed_shell.

Check existence of a list of files/directories.

Build an engine configuration:

Make sure the directory path exists on the host.

Standard path for stderr files.

Display-friendly version of the errors of this module.

Execute a process with a given list of strings as “argv”, if you can provide the ~bin argument to specify the actual file to be executed.

Create a program that run in Unix.exec mode (i.e.

Generic execution which tries to behave like Unix.execv even on top of SSH.

The execution timeout configured for the host.

Create a "/bin/sh" command that checks if the file or directory exists.

explore ~client exploration_states runs a read-eval loop to explore and interact with targets.

Create a configuration of the Explorer:

Call Deferred_result.fail with a “fatal error” (Mandatory in the Long-running API).

Create a volume containing one file.

Create a path to a file.

Create a file Ketrew_edsl.user_artifact and the Ketrew_edsl.user_target that produces it.

Run Ketrew_engine.Run_automaton.step many times until nothing happens or nothing “new” happens.

Get a fresh-playground from a Host.t.

Read the file from the host at path.

Get a new subdirectory in the host's playground

Get the host.

Get a key from the terminal input.

Get a list of target IDs given the query.

Get only the Ids of the targets for a given “query”:

Get the handle to the engine (returns None if the client is an HTTP one).

Fetch and parse the log file of a monitored-script.

Fetch and parse the pid file of a monitored-script.

Run a shell command on the host, and return its (stdout, stderr) pair (succeeds iff the exit status is 0).

Run a shell command on the host, and return its exit status value.

Get the state description of a given target (by “id”).

The latest contents of a given target.

Get a target from its id.

Same as Ketrew_client.get_target but “in bulk.”

Weakly typed version of Ketrew_host_io.get_file, it fails with a Log.t (for use in “long-running” plugins).

Get a target's id.

Initialize the module.

Function that have a documented, easy to check contract, can raise Invalid_argument _ (their name should end in _exn).

Tell whether the first on is equivalent to the second one.

Should we kill targets on ssh/unix errors.

Kill the long-running computation.

Kill a set of targets.

Kill a target

Get dead target out of a killable one, or None if not killable.

Get the most recent serialized run_parameters if the target is a “long-running”, None otherwise.

Get the OpenSSL server configuration.

Load a configuration.

Dynamically load a list of plugins, this function is not cooperative (with Lwt) and may raise Failure.

The host "localhost" (i.e.

Get a list of things to display.

Get a display-friendly list of configuration items.

Get a display document.

Get a Log.t “document” to display the target.

Create a Log.t document to display a program.

Get a Log.t document.

Path to the log file of the script.

Get the path to the server's log file.

long_running_log ~state plugin_name serialized_run_params calls Ketrew_long_running.LONG_RUNNING.log with the right plugin.

Create an “LSF” build process.

Create a menu with the targets.

Get the maximum number of successive non-fatal failures.

Display a menu given the specified menu_items

Represent a menu item.

The (unique) name of the plugin.

Get a target's user-defined name.

A build process that does nothing.

Parse an RFC-3986-compliant string into a host, see Ketrew_host.of_uri.

Get a Host.t from an URI (library ocaml-uri); the “path” part of the URI is the playground.

The definition of a monitored script.

The thing holding targets.

A program.

The type of SSH-based hosts.

Host container.

General type of file-paths.

Open a file in "$EDITOR".

Standard path for stdout files (given a fresh playground).

Output a configuration file containing a list of profiles to stdout.

Parse an URI string into a host.

Parse the log file of a monitored_script.

The date the target's creation.

Create a “PSB” build process.

Path to the “PID” file: where the script stores the PID of the process running the script, - pid will be the process id of the process group created by `setsid` (useful for killing the whole process tree).

Get the configured list of plugins.

Create a profile value.

Create a Command.t that runs a Ketrew_program.t.

Write a file on the host at path containing contents.

Perform a query.

Function to be called from dynamically loaded plugins.

Create a relative path to a directory, raises Invalid_argument _ if the path is not relative.

Create a relative to a file, raises Invalid_argument _ if the path is not relative.

Restart a set of targets.

Make new activated targets out of a given target and its “transitive reverse dependencies”

Get the value of return_error_messages.

The root directory (i.e.

The “main” function for the application, it will exit n with n = 0 if succeed or n > 0 if an error occurs.

Run a shell command on the host (succeeds iff the exit status is 0).

Start and run an action until it finishes or unitl the key "q" is pressed.

Generate an SCP command for the given host as source.

Generate an SCP command for the given host with the destination directory or file path.

Standard path for monitored-script files.

Serialize the run parameters for storage by the engine.

Serialize a target (for the database).

Create a server configuration (to pass as optional argument to the Ketrew_configuration.create function).

Get the potentiel server configuration.

Create a program that runs a shell command.

Create a “shell” command for a given Host.t.

Call Ketrew_host.get_shell_command_output and transform errors into a Log.t.

Call sh-style commands using the command argument (e.g.

Printf-like function to create shell commands.

Create a "/bin/sh" command that outputs "0" for directories and their size for files.

Create an SSH host.

Get the right option for the SSH client, for now this does not actually depend on the Host.

Start the server according to its configuration.

Start the long-running computation, the returned run_parameters will be stored and used for the first call to Ketrew_long_running.LONG_RUNNING.update.

Ask for the status of the server running locally by calling "https://127.0.0.1:<port>/hello".

Run one step of the engine; step returns true if something happened.

Stop the server by calling the commad "die" on the configured command-pipe, stopping will fail with `Stop_server_error _ if that path is not configured.

Submit a high-level workflow description to the engine; this function calls Lwt_main.run.

Do like Ketrew_unix_process.exec but fail if the process does not exit with 0 status.

Construct a new target, the node of a workflow graph.

Get the date recorded for the item.

The host "localhost", with "/tmp" as playground.

Build a display-friendly string summarizing the workflow.

Create the contents of a configuration file containing a list of profiles.

Serialize a target to Json.t intermediate representation.

Convert a program to a list of shell commands.

Convert a program to a shell command.

Render the monitored_script to a shell-script string; if write_pid is true (the default), the script writes the pid to pid_file t.

Convert the path to a “Unix” path.

Get a Human-readable string.

Get a display-friendly string of a program.

Get a display-friendly string for the host.

Convert the path to a “Unix” path quoted for a shell command (c.f.

Convert an item to a list of displayable functions.

Convert a Host.t to an URI representing it.

Turn on or off messages about which key is pressed.

Create a configuration of the UI:

The artifact that is “never done” (i.e.

Check and update the status of the long-running job.

See the documentation of with_cbreak.

View a string in "$EDITOR".

Create a engine.t, run the function passed as argument, and properly dispose of it.

Create a build process that requests resources from Yarn, the command must be an application in the Yarn sense (i.e.

Create a build process that will use Hadoop's `DistributedShell` class to request a container to run the given arbitrary program.