Index of values


(&&) [Ketrew.EDSL.Condition]
(&&) [Ketrew.EDSL.Program]
a && b is a program than runs a then b iff a succeeded.

A
absolute_directory_exn [Ketrew_pure.Path]
Create an absolute path to a directory, raises Invalid_argument _ if the path is not absolute.
absolute_file_exn [Ketrew_pure.Path]
Create an absolute path to a file, raises Invalid_argument _ if the path is not absolute.
activate_exn [Ketrew_pure.Target]
Get an activated target out of a “submitted” one, raises Invalid_argument _ if the target is in a wrong state.
activate_target [Ketrew.Persistent_data]
activated_by_user [Ketrew_pure.Target.State.Is]
active [Ketrew_pure.Target.State.Is]
add_tags [Ketrew.EDSL]
Add tags imperatively to a node, if recursive is true, follow the edges recursively to add tags.
add_target_ids_to_kill_list [Ketrew.Persistent_data.Killing_targets]
add_targets [Ketrew.Engine]
Add a list of targets to the engine.
add_targets [Ketrew.Client]
Submit a list of targets to the server/engine.
additional_log [Ketrew_pure.Target]
additional_queries [Ketrew.Long_running.LONG_RUNNING]
List of potential (query, description) pairs that can be passed to Ketrew.Long_running.LONG_RUNNING.query.
additional_queries [Ketrew.Plugin]
Get the potential additional queries ((key, description) pairs) that can be called on the target.
all_paths [Ketrew_pure.Target.Volume]
all_visible_targets [Ketrew.Persistent_data]
all_visible_targets [Ketrew.Engine]
Get the list of targets currently handled.
all_visible_targets [Ketrew.Client]
Get all the current targets.
already_done [Ketrew_pure.Target.State.Is]
answer_message [Ketrew.Process_holder]
Answer a request from the sub-protocol of the process-holder.
archival_age_threshold [Ketrew.Configuration]
Get the maximal ago of easily visible workflow-nodes.
as_client [Ketrew.Client]
Run the function f with a fresh-client created with the configuration.
ask_for_edition [Ketrew.Interaction]
Edit content in "$EDITOR".
authorized_token [Ketrew.Configuration]
Create an “inline” authentication token, i.e.
authorized_tokens [Ketrew.Configuration]
The path to the authorized_tokens file.
authorized_tokens_path [Ketrew.Configuration]
Ask the server to load tokens from a file at the given path.

B
bind [Ketrew_pure.Reactive.Signal]
bool [Ketrew.Eval_condition]
build_process [Ketrew.Document]
Transform complex Ketrew values into display-friendly Log.t values.
build_process [Ketrew_pure.Target.Summary]
build_process [Ketrew_pure.Target]
build_sublist_of_targets [Ketrew.Interaction]
Figure out the targets to be displayed.
building [Ketrew_pure.Target.State.Is]

C
call_process_holder [Ketrew.Client]
call_query [Ketrew.Plugin]
Call a query on a target.
call_query [Ketrew.Client]
Call a target's plugin query by name.
can [Ketrew.Authentication]
Determine if we have the desired capabilities
chain [Ketrew.EDSL.Program]
Chain a list of programs like with &&.
chain_and [Ketrew.EDSL.Condition]
check_and_really_add_targets [Ketrew.Persistent_data.Adding_targets]
classify [Ketrew.Host_io.Error]
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.
classify_and_transform_errors [Ketrew.Long_running_utilities]
Transform most known errors into long-running plugin API errors; using Ketrew_pure.Host.Error.classify.
client [Ketrew.Configuration]
Create a client configuration:
cmdliner_term [Ketrew.EDSL.Host]
Cmdliner term which creates a host argument or flag.
command_pipe [Ketrew.Configuration]
Get the path to the “command” named pipe.
concat [Ketrew_pure.Path]
Safely concatenate two paths (calls Filename.concat).
concurrent_automaton_steps [Ketrew.Configuration]
Get the maximum number of concurrent automaton steps.
condition [Ketrew_pure.Target.Summary]
condition [Ketrew_pure.Target]
configuration [Ketrew.Engine]
Retrieve the configuration.
configuration [Ketrew.Client]
Retrieve the configuration used to create the client.
configure_ssh_batch_option [Ketrew_pure.Host.Ssh]
Configure global “Batch option”, (call ssh without password/question): for OpenSSH, it is "-oBatchMode=yes",, for DropBear, it is "-s".
connection [Ketrew.Configuration]
connection [Ketrew_pure.Host]
consecutive_recent_attempts [Ketrew_pure.Target.State.Count]
Count how many times a current non-fatal failure state “repeats.” I.e.
constant [Ketrew_pure.Reactive.Signal]
copy [Ketrew.Persistent_data.Synchronize]
create [Ketrew.Yarn]
Create a “long-running” Ketrew_pure.Target.build_process (run parameters are already serialized), see Edsl.yarn_application.
create [Ketrew.Persistent_data]
create [Ketrew.Pbs]
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 [Ketrew.Lsf]
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 [Ketrew.Host_io]
create [Ketrew.Explorer]
create [Ketrew.EDSL.Condition.Volume]
Create a volume from a Host.t and an absolute directory ~root (function raises an exception if root is not absolute).
create [Ketrew.Daemonize]
Create a “long-running” Ketrew_pure.Target.build_process (run parameters are already serialized), see Edsl.daemonize for more details
create [Ketrew.Configuration]
Create a complete configuration:
create [Ketrew_pure.Target.Summary]
Create a summary of a target value.
create [Ketrew_pure.Target.Volume]
create [Ketrew_pure.Target]
Create a target value (not stored in the DB yet).
create [Ketrew_pure.Reactive.Source]
create [Ketrew_pure.Protocol.Server_status]
create [Ketrew_pure.Monitored_script]
Create a new script, which will run the list of commands, and store state values in the playground directory.

D
daemon [Ketrew.Configuration]
Tell whether the server should detach.
daemonize [Ketrew.EDSL]
Create a “daemonize” build process:
database_parameters [Ketrew.Configuration]
Get the database parameters.
default_configuration_directory_path [Ketrew.Configuration]
Default path to the configuration directory ("~/.ketrew/").
default_explorer_defaults [Ketrew.Configuration]
The default values of the Explorer configuration.
default_plugins [Ketrew.Plugin]
The “long-running” plugins loaded by default.
default_shell [Ketrew_pure.Host]
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>".
default_shell_of_yojson [Ketrew_pure.Host]
Specification of the default shell of a Host.
default_shell_to_yojson [Ketrew_pure.Host]
default_timeout_upper_bound [Ketrew.Host_io]
Default (upper bound) of the `?timeout` arguments.
delete_named_host [Ketrew.Host_io]
dependencies_failed [Ketrew_pure.Target.State.Is]
dependency_dead [Ketrew_pure.Target.State.Is]
depends_on [Ketrew.EDSL]
Create a “dependency” edge, in other words, the node using the edges “depends on” the node given as argument.
depends_on [Ketrew_pure.Target.Summary]
depends_on [Ketrew_pure.Target]
deserialize [Ketrew_pure.Target.Stored_target]
Deserilize a target from a string.
deserialize_exn [Ketrew.Long_running.LONG_RUNNING]
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.
did_not_ensure_condition [Ketrew_pure.Target.State.Is]
dir [Ketrew.EDSL.Condition.Volume]
dir [Ketrew_pure.Target.Volume]
directory [Ketrew_pure.Path]
Create a path to a directory.
distributed_shell_program [Ketrew.Yarn]
Create a value `Distributed_shell _ to feed to Ketrew.Yarn.create, see Edsl.yarn_distributed_shell.
do_files_exist [Ketrew.Host_io]
Check existence of a list of files/directories.

E
empty [Ketrew_pure.Target.State.Flat]
engine [Ketrew.Configuration]
Build an engine configuration:
ensure_directory [Ketrew.Host_io]
Make sure the directory path exists on the host.
equivalence [Ketrew_pure.Target.Summary]
equivalence [Ketrew_pure.Target]
err_file_path [Ketrew.Long_running_utilities]
Standard path for stderr files.
error_to_string [Ketrew.Unix_process]
Display-friendly version of the errors of this module.
exec [Ketrew.Unix_process]
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.
exec [Ketrew.EDSL.Program]
Create a program that run in Unix.exec mode (i.e.
execute [Ketrew.Host_io]
Generic execution which tries to behave like Unix.execv even on top of SSH.
execution_timeout [Ketrew_pure.Host]
The execution timeout configured for the host.
exists_shell_condition [Ketrew_pure.Path]
Create a "/bin/sh" command that checks if the file or directory exists.
explore [Ketrew.Explorer]
explore ~client exploration_states runs a read-eval loop to explore and interact with targets.
explorer [Ketrew.Configuration]
Create a configuration of the Explorer:

F
fail_fatal [Ketrew.Long_running_utilities]
Call Deferred_result.fail with a “fatal error” (Mandatory in the Long-running API).
failed_from_condition [Ketrew_pure.Target.State.Is]
failed_from_running [Ketrew_pure.Target.State.Is]
failed_from_starting [Ketrew_pure.Target.State.Is]
failed_running [Ketrew_pure.Target.State.Is]
failed_to_kill [Ketrew_pure.Target.State.Is]
failed_to_start [Ketrew_pure.Target.State.Is]
file [Ketrew.EDSL.Condition.Volume]
file [Ketrew.EDSL]
Create a volume containing one file.
file [Ketrew_pure.Target.Volume]
file [Ketrew_pure.Path]
Create a path to a file.
file_target [Ketrew.EDSL]
Create a file Ketrew.EDSL.user_artifact and the Ketrew.EDSL.user_target that produces it.
find_all_orphans [Ketrew.Persistent_data]
find_all_orphans goes through the cache and returns all the targets that are passive but not reachable, i.e.
find_plugin [Ketrew.Plugin]
finished [Ketrew_pure.Target.State.Flat]
finished [Ketrew_pure.Target.State.Is]
finished_time [Ketrew_pure.Target.State]
fix_point [Ketrew.Engine.Run_automaton]
Run Ketrew.Engine.Run_automaton.step many times until nothing happens or nothing “new” happens.
fold_active_targets [Ketrew.Persistent_data]
force_add_passive_target [Ketrew.Persistent_data.Adding_targets]
Bypass the normal flow of target addition and put a target in the DB.
forget_product [Ketrew.EDSL]
“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).
freeze_state_duration [Ketrew.Configuration]
Get the maximal time workflow-nodes can get frozen by the engine.
fresh_playground_or_fail [Ketrew.Long_running_utilities]
Get a fresh-playground from a Host.t.

G
generate_configuration_directory [Ketrew.User_initialization]
Generate a configurated directory given a specification.
get_file [Ketrew.Host_io]
Read the file from the host at path.
get_fresh_playground [Ketrew.Host_io]
Get a new subdirectory in the host's playground
get_host [Ketrew_pure.Target.Command]
Get the host.
get_key [Ketrew.Interaction]
Get a key from the terminal input.
get_list_of_target_ids [Ketrew.Engine]
Get only the Ids of the targets for a given “query”:
get_list_of_target_ids [Ketrew.Client]
Get a list of target IDs given the query.
get_local_engine [Ketrew.Client]
Get the handle to the engine (returns None if the client is an HTTP one).
get_log_of_monitored_script [Ketrew.Long_running_utilities]
Fetch and parse the log file of a monitored-script.
get_pid_of_monitored_script [Ketrew.Long_running_utilities]
Fetch and parse the pid file of a monitored-script.
get_playground [Ketrew.Daemonize]
get_shell_command_output [Ketrew.Host_io]
Run a shell command on the host, and return its (stdout, stderr) pair (succeeds iff the exit status is 0).
get_shell_command_return_value [Ketrew.Host_io]
Run a shell command on the host, and return its exit status value.
get_status [Ketrew.Engine]
Get the state description of a given target (by “id”).
get_target [Ketrew.Persistent_data]
get_target [Ketrew.Engine]
Get a target from its id.
get_target [Ketrew.Client]
The latest contents of a given target.
get_target [Ketrew_pure.Target.Stored_target]
get_targets [Ketrew.Client]
Same as Ketrew.Client.get_target but “in bulk.”
grab_file_or_log [Ketrew.Host_io]
Weakly typed version of Ketrew.Host_io.get_file, it fails with a Log.t (for use in “long-running” plugins).

H
history [Ketrew_pure.Target.State.Flat]
host_io [Ketrew.Engine]
host_timeout_upper_bound [Ketrew.Configuration]
Get the upper bound for the timeout of SSH calls, if any.

I
id [Ketrew_pure.Target.Summary]
Get a target's id.
id [Ketrew_pure.Target.Stored_target]
id [Ketrew_pure.Target]
Get a target's id.
init [Ketrew.Interaction]
Initialize the module.
is_equivalent [Ketrew_pure.Target]
Tell whether the first on is equivalent to the second one.
is_unix_ssh_failure_fatal [Ketrew.Configuration]
Should we kill targets on ssh/unix errors.
item_of_yojson [Ketrew_pure.Target.State.Flat]
item_to_yojson [Ketrew_pure.Target.State.Flat]

K
kill [Ketrew.Long_running.LONG_RUNNING]
Kill the long-running computation.
kill [Ketrew.Engine]
Kill a target
kill [Ketrew.Client]
Kill a set of targets.
kill [Ketrew_pure.Target]
Get dead target out of a killable one, or None if not killable.
killable [Ketrew_pure.Target.State.Is]
killed [Ketrew_pure.Target.State.Is]
killed_from_passive [Ketrew_pure.Target.State.Is]
killing [Ketrew_pure.Target.State.Is]

L
latest [Ketrew_pure.Target.State.Flat]
Get the most recent item.
latest_run_parameters [Ketrew_pure.Target]
Get the most recent serialized run_parameters if the target is a “long-running”, None otherwise.
list [Ketrew_pure.Reactive.Signal]
list_of_files [Ketrew.EDSL]
Create a list_of_files product (#is_done checks the existence of all these files).
listen_to [Ketrew.Configuration]
Get the OpenSSL-or-not server configuration.
load [Ketrew.Process_holder]
Create a new process-holder.
load [Ketrew.Engine]
load [Ketrew.Authentication]
Load tokens that represent your authentication.
load_exn [Ketrew.Configuration]
Load a configuration.
load_plugins [Ketrew.Plugin]
load_plugins_no_lwt_exn [Ketrew.Plugin]
Dynamically load a list of plugins, this function is not cooperative (with Lwt) and may raise Failure.
localhost [Ketrew_pure.Host]
The host "localhost" (i.e.
log [Ketrew.Long_running.LONG_RUNNING]
Get a list of things to display.
log [Ketrew.Host_io.Error]
log [Ketrew.Configuration]
Get a display-friendly list of configuration items.
log [Ketrew.Client.Error]
log [Ketrew.Authentication]
Describe the source of the authentication.
log [Ketrew_pure.Target.State]
log [Ketrew_pure.Target.Condition]
log [Ketrew_pure.Target.Volume]
log [Ketrew_pure.Target.Command]
Get a display document.
log [Ketrew_pure.Target]
Get a Log.t “document” to display the target.
log [Ketrew_pure.Program]
Create a Log.t document to display a program.
log [Ketrew_pure.Host]
Get a Log.t document.
log_file [Ketrew_pure.Monitored_script]
Path to the log file of the script.
log_path [Ketrew.Configuration]
Get the path to the server's log directory.
log_structure [Ketrew_pure.Target.Volume]
long_running_log [Ketrew.Plugin]
long_running_log ~state plugin_name serialized_run_params calls Ketrew.Long_running.LONG_RUNNING.log with the right plugin.
lsf [Ketrew.EDSL]
Create an “LSF” build process.

M
make_pointer [Ketrew_pure.Target.Stored_target]
make_target_menu [Ketrew.Interaction]
Create a menu with the targets.
map [Ketrew_pure.Reactive.Signal]
map_signal [Ketrew_pure.Reactive.Source]
markup [Ketrew.Daemonize]
markup [Ketrew_pure.Target.Condition]
markup [Ketrew_pure.Target.Volume]
markup [Ketrew_pure.Target.Command]
markup [Ketrew_pure.Program]
markup [Ketrew_pure.Path]
markup [Ketrew_pure.Host]
Get a higher-level display document.
max_blocking_time [Ketrew.Configuration]
max_name_length [Ketrew.Yarn]
maximum_successive_attempts [Ketrew.Configuration]
Get the maximum number of successive non-fatal failures.
menu [Ketrew.Interaction]
Display a menu given the specified menu_items
menu_item [Ketrew.Interaction]
Represent a menu item.
merge [Ketrew_pure.Target.State.Flat]
Merge two flat states into a sorted new one.
message [Ketrew_pure.Target.State.Flat]
metadata [Ketrew.Document]
metadata [Ketrew_pure.Target.Summary]
metadata [Ketrew_pure.Target]
mode [Ketrew.Configuration]
modify [Ketrew_pure.Reactive.Source]
modify_opt [Ketrew_pure.Reactive.Source]
more_info [Ketrew_pure.Target.State.Flat]

N
name [Ketrew.Long_running.LONG_RUNNING]
The (unique) name of the plugin.
name [Ketrew_pure.Target.Summary]
Get a target's user-defined name.
name [Ketrew_pure.Target.State.Flat]
name [Ketrew_pure.Target.State]
name [Ketrew_pure.Target]
Get a target's user-defined name.
named [Ketrew_pure.Host]
Create an "named" host, the actual connection will be resolved form the name by the engine.
next_changes [Ketrew.Persistent_data]
next_changes [Ketrew.Engine]
Block until the next batch of changes happening at the persistence-level, this stream is itself rate-limited.
node_id [Ketrew.EDSL]
Get the unique ID of the workdlow node.
node_name [Ketrew.EDSL]
Get the name of the workdlow node.
nop [Ketrew_pure.Target.Build_process]
A build process that does nothing.

O
of_state [Ketrew_pure.Target.State.Flat]
of_string [Ketrew_pure.Host]
Parse an RFC-3986-compliant string into a host, see Ketrew_pure.Host.of_uri.
of_target [Ketrew_pure.Target.Stored_target]
of_uri [Ketrew_pure.Host]
Get a Host.t from an URI (library ocaml-uri); the “path” part of the URI is the playground.
of_yojson [Ketrew_pure.Target.Summary]
A representation of an immutable subset of a target.
of_yojson [Ketrew_pure.Target.State.Flat]
of_yojson [Ketrew_pure.Target]
The thing holding targets.
of_yojson [Ketrew_pure.Program]
A program.
of_yojson [Ketrew_pure.Path]
General type of file-paths.
of_yojson [Ketrew_pure.Monitored_script]
The definition of a monitored script.
of_yojson [Ketrew_pure.Host.Ssh]
The type of SSH-based hosts.
of_yojson [Ketrew_pure.Host]
Host container.
on_failure_activate [Ketrew.EDSL]
Create an edge to a node that will be activated after a node fails.
on_failure_activate [Ketrew_pure.Target.Summary]
on_failure_activate [Ketrew_pure.Target]
on_success_activate [Ketrew.EDSL]
Create an edge to a node that will be activated after a node succeeds.
on_success_activate [Ketrew_pure.Target.Summary]
on_success_activate [Ketrew_pure.Target]
open_in_dollar_editor [Ketrew.Interaction]
Open a file in "$EDITOR".
out_file_path [Ketrew.Long_running_utilities]
Standard path for stdout files (given a fresh playground).
output [Ketrew.Configuration]
Output a configuration file containing a list of profiles to stdout.

P
parse [Ketrew.EDSL.Host]
Parse a URI string into a Ketrew-host.
parse_log [Ketrew_pure.Monitored_script]
Parse the log file of a monitored_script.
passive [Ketrew_pure.Target.State.Is]
passive_time [Ketrew_pure.Target.State]
The date the target's creation.
pbs [Ketrew.EDSL]
Create a “PSB” build process.
pid_file [Ketrew_pure.Monitored_script]
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).
playground [Ketrew_pure.Host]
plugins [Ketrew.Configuration]
Get the configured list of plugins.
pp [Ketrew.Persistent_data.Change]
pp_simple [Ketrew_pure.Target.State]
pp_target_query [Ketrew_pure.Protocol.Up_message]
proceed_to_mass_killing [Ketrew.Persistent_data.Killing_targets]
profile [Ketrew.Configuration]
Create a profile value.
program [Ketrew.EDSL.Condition]
program [Ketrew_pure.Target.Command]
Create a Command.t that runs a Ketrew_pure.Program.t.
put_file [Ketrew.Host_io]
Write a file on the host at path containing contents.

Q
query [Ketrew.Long_running.LONG_RUNNING]
Perform a query.

R
ran_successfully [Ketrew_pure.Target.State.Is]
reactivate [Ketrew_pure.Target]
read_only_mode [Ketrew.Configuration]
read_password_exn [Ketrew.Interaction]
Read a line form stdin without echoing to the terminal.
register_long_running_plugin [Ketrew.Plugin]
Function to be called from dynamically loaded plugins.
register_targets_to_add [Ketrew.Persistent_data.Adding_targets]
relative_directory_exn [Ketrew_pure.Path]
Create a relative path to a directory, raises Invalid_argument _ if the path is not relative.
relative_file_exn [Ketrew_pure.Path]
Create a relative to a file, raises Invalid_argument _ if the path is not relative.
reload [Ketrew.Authentication]
Reload tokens based upon their original source.
request_targets_ids [Ketrew.Configuration]
restart [Ketrew.Client]
Restart a set of targets.
restart_target [Ketrew.Engine]
Make new activated targets out of a given target and its “transitive reverse dependencies”
return_error_messages [Ketrew.Configuration]
Get the value of return_error_messages.
root [Ketrew_pure.Path]
The root directory (i.e.
run_main [Ketrew.Command_line]
The “main” function for the application, it will exit n with n = 0 if succeed or n > 0 if an error occurs.
run_parameters_of_yojson [Ketrew.Daemonize]
run_parameters_to_yojson [Ketrew.Daemonize]
run_shell_command [Ketrew.Host_io]
Run a shell command on the host (succeeds iff the exit status is 0).
run_with_quit_key [Ketrew.Interaction]
Start and run an action until it finishes or unitl the key "q" is pressed.

S
scp_pull [Ketrew.Host_io.Ssh]
Generate an SCP command for the given host as source.
scp_push [Ketrew.Host_io.Ssh]
Generate an SCP command for the given host with the destination directory or file path.
script_path [Ketrew.Long_running_utilities]
Standard path for monitored-script files.
serialize [Ketrew.Long_running.LONG_RUNNING]
Serialize the run parameters for storage by the engine.
serialize [Ketrew_pure.Target.Stored_target]
Serialize a target (for the database).
server [Ketrew.Configuration]
Create a server configuration (to pass as optional argument to the Ketrew.Configuration.create function).
server_configuration [Ketrew.Configuration]
Get the potentiel server configuration.
server_engine [Ketrew.Configuration]
set [Ketrew_pure.Reactive.Source]
set_named_host [Ketrew.Host_io]
setsid_ssh [Ketrew.Process_holder.Ssh_connection]
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.
sh [Ketrew.EDSL.Program]
Create a program that runs a shell command.
shell [Ketrew_pure.Target.Command]
Create a “shell” command for a given Host.t.
shell_command_output_or_log [Ketrew.Long_running_utilities]
Call Ketrew.Host_io.get_shell_command_output and transform errors into a Log.t.
shell_of_default_shell [Ketrew_pure.Host]
shell_sh [Ketrew.Host_io]
Call sh-style commands using the command argument (e.g.
shf [Ketrew.EDSL.Program]
Printf-like function to create shell commands.
show [Ketrew.Persistent_data.Change]
show_simple [Ketrew_pure.Target.State]
show_target_query [Ketrew_pure.Protocol.Up_message]
signal [Ketrew_pure.Reactive.Source]
simple [Ketrew_pure.Target.State.Flat]
simple_of_yojson [Ketrew_pure.Target.State]
simple_to_yojson [Ketrew_pure.Target.State]
simplify [Ketrew_pure.Target.State]
since [Ketrew_pure.Target.State.Flat]
Filter the history with a date, returning a flat-state containing only newer items if any.
single_file [Ketrew.EDSL]
Create a single_file product.
singleton [Ketrew_pure.Reactive.Signal]
size_shell_command [Ketrew_pure.Path]
Create a "/bin/sh" command that outputs "0" for directories and their size for files.
ssh [Ketrew.EDSL.Host]
ssh [Ketrew_pure.Host]
Create an SSH host.
ssh_batch_option [Ketrew_pure.Host.Ssh]
Get the right option for the SSH client, for now this does not actually depend on the Host.
ssh_connection [Ketrew.Configuration]
ssh_connection_name_uri [Ketrew.Configuration]
ssh_connections [Ketrew.Configuration]
ssh_processes_ui [Ketrew.Configuration]
standalone [Ketrew.Configuration]
standalone_engine [Ketrew.Configuration]
standalone_of_server [Ketrew.Configuration]
start [Ketrew.Long_running.LONG_RUNNING]
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 [Ketrew.Server]
Start the server according to its configuration.
started_running [Ketrew_pure.Target.State.Is]
starting [Ketrew_pure.Target.State.Is]
state [Ketrew_pure.Target]
status [Ketrew.Server]
Ask for the status of the server running locally by calling "https://127.0.0.1:<port>/hello".
step [Ketrew.Engine.Run_automaton]
Run one step of the engine; step returns true if something happened.
still_building [Ketrew_pure.Target.State.Is]
still_running [Ketrew_pure.Target.State.Is]
stop [Ketrew.Server]
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.
sub_commands [Ketrew.Named_hosts_text_ui]
Create a list of cmdliner sub-commands to integrate in a greater command line application.
submit [Ketrew.Client]
This is like Ketrew.Client.submit_workflow but for the deprecated/legacy API (i.e.
submit_workflow [Ketrew.Client]
Submit a high-level workflow description to the engine; this function calls Lwt_main.run.
succeed [Ketrew.Unix_process]
Do like Ketrew.Unix_process.exec but fail if the process does not exit with 0 status.
successfully_did_nothing [Ketrew_pure.Target.State.Is]
summary [Ketrew_pure.Target.State]

T
tags [Ketrew_pure.Target.Summary]
tags [Ketrew_pure.Target]
target [Ketrew.EDSL]
Construct a new target, the node of a workflow graph.
target [Ketrew.Document]
target_for_menu [Ketrew.Document]
target_query_markup [Ketrew_pure.Protocol.Up_message]
targets_per_page [Ketrew.Configuration]
targets_to_prefetch [Ketrew.Configuration]
time [Ketrew_pure.Target.State.Flat]
tmp_on_localhost [Ketrew.EDSL.Host]
tmp_on_localhost [Ketrew_pure.Host]
The host "localhost", with "/tmp" as playground.
to_display_string [Ketrew.EDSL]
Build a display-friendly string summarizing the workflow.
to_json [Ketrew.Configuration]
Create the contents of a configuration file containing a list of profiles.
to_json [Ketrew_pure.Target.Stored_target]
Serialize a target to Json.t intermediate representation.
to_log [Ketrew.Unix_process.Exit_code]
to_shell_commands [Ketrew_pure.Program]
Convert a program to a list of shell commands.
to_single_shell_command [Ketrew_pure.Program]
Convert a program to a shell command.
to_string [Ketrew.Unix_process.Exit_code]
to_string [Ketrew_pure.Path]
Convert the path to a “Unix” path.
to_string [Ketrew_pure.Monitored_script]
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.
to_string_hum [Ketrew_pure.Target.Condition]
to_string_hum [Ketrew_pure.Target.Volume]
to_string_hum [Ketrew_pure.Target.Command]
Get a Human-readable string.
to_string_hum [Ketrew_pure.Program]
Get a display-friendly string of a program.
to_string_hum [Ketrew_pure.Host]
Get a display-friendly string for the host.
to_string_quoted [Ketrew_pure.Path]
Convert the path to a “Unix” path quoted for a shell command (c.f.
to_uri [Ketrew_pure.Host]
Convert a Host.t to an URI representing it.
to_yojson [Ketrew_pure.Target.Summary]
to_yojson [Ketrew_pure.Target.State.Flat]
to_yojson [Ketrew_pure.Target]
to_yojson [Ketrew_pure.Program]
to_yojson [Ketrew_pure.Path]
to_yojson [Ketrew_pure.Monitored_script]
to_yojson [Ketrew_pure.Host.Ssh]
to_yojson [Ketrew_pure.Host]
toggle_verbose [Ketrew.Interaction]
Turn on or off messages about which key is pressed.
token [Ketrew.Configuration]
transition [Ketrew_pure.Target.Automaton]
tried_to_eval_condition [Ketrew_pure.Target.State.Is]
tried_to_kill [Ketrew_pure.Target.State.Is]
tried_to_start [Ketrew_pure.Target.State.Is]
try_to_fix_step_error [Ketrew.Engine.Run_automaton]
tuple_2 [Ketrew_pure.Reactive.Signal]
tuple_3 [Ketrew_pure.Reactive.Signal]

U
ui [Ketrew.Configuration]
Create a configuration of the UI:
unit [Ketrew.EDSL]
The artifact that is “never done” (i.e.
unload [Ketrew.Process_holder]
Destroy a process-holder by attempting to kill all its processes.
unload [Ketrew.Persistent_data]
unload [Ketrew.Engine]
update [Ketrew.Long_running.LONG_RUNNING]
Check and update the status of the long-running job.
update_target [Ketrew.Persistent_data]
use_cbreak [Ketrew.Configuration]
See the documentation of with_cbreak.

V
value [Ketrew_pure.Reactive.Signal]
value [Ketrew_pure.Reactive.Source]
verified_success [Ketrew_pure.Target.State.Is]
view_in_dollar_editor [Ketrew.Interaction]
View a string in "$EDITOR".
volume_exists [Ketrew.EDSL.Condition]
Condition that ensures the all the structure of a Volume.t is present.
volume_size_greater_of_equal [Ketrew.EDSL.Condition]

W
with_color [Ketrew.Configuration]
with_engine [Ketrew.Engine]
Create a engine.t, run the function passed as argument, and properly dispose of it.
with_ssh_connection [Ketrew_pure.Host]
without_product [Ketrew.EDSL]
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.
workflow_node [Ketrew.EDSL]
Create a workflow node:
workflow_to_string [Ketrew.EDSL]
Build a display-friendly string summarizing the workflow.

Y
yarn_application [Ketrew.EDSL]
Create a build process that requests resources from Yarn, the command must be an application in the Yarn sense (i.e.
yarn_distributed_shell [Ketrew.EDSL]
Create a build process that will use Hadoop's `DistributedShell` class to request a container to run the given arbitrary program.