(&&) [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] |
Register a node as “Active” (i.e.
|
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] | |
already_done [Ketrew_pure.Target.State.Is] | |
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_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] |
Connect to the Postgresql database and initialize it (if needed).
|
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 | |
daemonize [Ketrew.EDSL] |
Create a “daemonize” build process:
|
database_parameters [Ketrew.Configuration] |
Get the database parameters.
|
database_to_string [Ketrew.Persistent_data.Error] | |
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.
|
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] | |
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:
|
engine_step_batch_size [Ketrew.Configuration] |
Get the amount of workflow-nodes treated by the engine in one
automaton step.
|
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] |
Go through all the active nodes.
|
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 ).
|
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_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 the node at a given ID, the function actually “follows
pointers” i.e.
|
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_pointer [Ketrew_pure.Target.Stored_target] | |
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.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.Stored_target] |
Get the name of the target, or the name of the name of the
“original” target if it has been made into a pointer.
|
name [Ketrew_pure.Target.State.Flat] | |
name [Ketrew_pure.Target.State] | |
name [Ketrew_pure.Target] |
Get a target's user-defined name.
|
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" .
|
orphan_killing_wait [Ketrew.Configuration] |
Get the minimal time between 2 “orphan-node killing sprees.”
|
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.
|
query_nodes [Ketrew.Persistent_data] | |
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] | |
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.
|
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.
|
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.Stored_target] |
Get the tag-cloud of the target, similarly as
Ketrew_pure.Target.Stored_target.name .
|
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.Persistent_data.Synchronize.Error] | |
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.Persistent_data] |
Close the connection to the DB.
|
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.
|
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.
|