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 tags imperatively to a node, if recursive is true, follow the edges recursively to add tags.

Add a list of targets to the engine.

Submit a list of targets to the server/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.

Answer a request from the sub-protocol of the process-holder.

Get the maximal ago of easily visible workflow-nodes.

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.

Determine if we have the desired capabilities

Chain a list of programs like with &&.

Get a glance at the gravity of the situation: `Local_system: a function of the kind Unix.exec failed., `Connectivity: Host_io failed to run something but it does not mean that the actual command is wrong; connectivity can be restored later., `Command_execution: the system and networking did their job but the particular 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).

Get the maximum number of concurrent automaton steps.

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 volume from a Host.t and an absolute directory ~root (function raises an exception if root is not absolute).

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.

Create a “dependency” edge, in other words, the node using the edges “depends on” the node given as argument.

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.

find_all_orphans goes through the cache and returns all the targets that are passive but not reachable, i.e.

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

Bypass the normal flow of target addition and put a target in the DB.

“Cast” a node to the unknown_product workflow_node type, this is useful to make some programs that generate workflows type check (putting nodes into lists, or in different branches of a match .. with).

Get the maximal time workflow-nodes can get frozen by the engine.

Get a fresh-playground from a Host.t.

Generate a configurated directory given a specification.

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 the upper bound for the timeout of SSH calls, if any.

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.

Create a list_of_files product (#is_done checks the existence of all these files).

Get the OpenSSL-or-not server configuration.

Create a new process-holder.

Load tokens that represent your authentication.

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.

Describe the source of the authentication.

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

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.

Create an "named" host, the actual connection will be resolved form the name by the engine.

Block until the next batch of changes happening at the persistence-level, this stream is itself rate-limited.

Get the unique ID of the workdlow node.

Get the name of the workdlow node.

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.

Create an edge to a node that will be activated after a node fails.

Create an edge to a node that will be activated after a node succeeds.

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 a URI string into a Ketrew-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.

Read a line form stdin without echoing to the terminal.

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.

Reload tokens based upon their original source.

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.

Daemonize an SSH connection with a control-path as a control-master, one can communicate with the client (as an SSH "ASKPASS" program) with the pipe_in and pipe_out named fifo files.

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

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.

Create a named Ketrew.Configuration.ssh_connection (cf.

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.

Create a list of cmdliner sub-commands to integrate in a greater command line application.

This is like Ketrew.Client.submit_workflow but for the deprecated/legacy API (i.e.

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.

Destroy a process-holder by attempting to kill all its processes.

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

See the documentation of with_cbreak.

View a string in "$EDITOR".

Condition that ensures the all the structure of a Volume.t is present.

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

Create an “empty” product, it won't require checking any condition, so the node carrying it (unless forced with the ?is_done argument) will always run.

Create a workflow node:

Build a display-friendly string summarizing the workflow.

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.