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.

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

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

Get the list of targets currently handled.

Get all the current targets.

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_pure.Host.Error.classify.

Create a client configuration:

Cmdliner term which creates a host argument or flag.

Get the path to the “command” named pipe.

Safely concatenate two paths (calls Filename.concat).

Retrieve the configuration.

Retrieve the configuration used to create the client.

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_pure.Target.build_process (run parameters are already serialized), see Edsl.yarn_application.

Create a “long-running” Ketrew_pure.Target.build_process to run a Ketrew_pure.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 “long-running” Ketrew_pure.Target.build_process to run a Ketrew_pure.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 “long-running” Ketrew_pure.Target.build_process (run parameters are already serialized), see Edsl.daemonize for more details

Create a complete configuration:

Create a summary of a target value.

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

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

Tell whether the server should detach.

Create a “daemonize” build process:

Get the database parameters.

Default path to the configuration directory ("~/.ketrew/").

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 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 only the Ids of the targets for a given “query”:

Get a list of target IDs given the 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”).

Get a target from its id.

The latest contents of a given target.

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.

Get a target's id.

Initialize the module.

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 target

Kill a set of targets.

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

Get the most recent item.

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

Get the OpenSSL-or-not 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 a higher-level display document.

Get the maximum number of successive non-fatal failures.

Display a menu given the specified menu_items

Represent a menu item.

Merge two flat states into a sorted new one.

The (unique) name of the plugin.

Get a target's user-defined name.

Get a target's user-defined name.

A build process that does nothing.

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

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

A representation of an immutable subset of a target.

The thing holding targets.

A program.

General type of file-paths.

The definition of a monitored script.

The type of SSH-based hosts.

Host container.

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_pure.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_io.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.

Filter the history with a date, returning a flat-state containing only newer items if any.

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 long-running computation, the returned run_parameters will be stored and used for the first call to Ketrew.Long_running.LONG_RUNNING.update.

Start the server according to its configuration.

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.

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.

Convert the path to a “Unix” path.

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.

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 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.