Index of values

abort rpc connection id given an RPC and the id returned as part of a call to dispatch, abort requests that the other side of the connection stop sending updates.

add impls extends a list of rpc implementations with an additional rpc implementation for providing a Menu.t when one is requested via Menu.request.

For use with Command.

async_basic is exactly the same as Core.Command.basic, except that the function it wraps returns unit Deferred.t, instead of unit.

bytes_to_write () returns the sum over all async_file_writers of how many bytes they need to write.

client ~host ~port () connects to the server at (host,port) and returns the connection or an Error if a connection could not be made.

close t client close connection to client if it exists.

close t closes the file t for writing.

close t starts closing the listening socket, and returns a deferred that becomes determined after Fd.close_finished fd on the socket's fd.

close closes a log so that further write attempts will raise an error.

If a connection is currently established, close it.

connect t If the connection is not currently established, initiate one.

connect ~host ~port connect to the server at (host,port)

connect ~host ~port is a convenience wrapper around connect_sock that returns the socket, and a reader and writer for the socket.

connect_sock ~host ~port opens a TCP connection to the specified hostname and port, returning the socket.

create a new (initially disconnected) client

create a new server, and start listening

create where_to_listen handler starts a server listening to a socket as specified by where_to_listen.

Initiate an Rpc connection on the given reader/writer pair.

create ~implementations ~on_unknown_rpc creates a server capable of responding to the rpc's implemented in the implementation list.

create f returns a t, given a function that actually performs the final output work.

create create a new log

create ?message path tries to create a file at path containing the text message, pid if none provided.

create file opens file, creating it if it doesn't exist.

create file creates a File_tail.t that will immediately begin reading file, and then will start the stat-read loop.

create_exn ?message path is like create except that it throws an exception on failure instead of returning a boolean value

error printf like logging at the `Info log level

debug printf like logging at the `Debug log level

debug_snapshot () returns an s-expression containing details of the current state of the Tcp_file server.

disconnect t disconnect from t.

This has (..., 'error) Result.t as its return type to represent the possibility of the call itself being somehow erroneous (but understood - the outer Or_error.t encompasses failures of that nature).

multi-version dispatch

multi-version dispatch

enqueue t ~key f enqueues f for key.

error printf like logging at the `Info log level

error printf like logging at the `Error log level

One can pass a t from parent to child by including flag_args t in the command-line arguments and using flag in the Command.t in the child.

flushed t becomes determined only once all messages written to t have been written to disk.

flushed returns a Deferred.t that is fulfilled when the last message delivered to t before the call to flushed is out the door.

Fold over keys with states or pending/running jobs.

implement multiple versions at once

implement multiple versions at once

implement multiple versions at once

info printf like logging at the `Info log level

info printf like logging at the `Info log level

is_locked path returns true when the file at path exists and is locked, false otherwise.

last_connect_error t returns the error (if any) that happened on the last connection attempt.

None is returned in cases where the message cannot fit into a string (original message was a very large Bigstring

We may want to use an 'a t implementation (perhaps provided by someone else) in a 'b t context.

listen t

listen t listen to the stream of messages and errors coming from clients

listen_ignore_errors t like listen, but with no errors or meta data.

listen_ignore_errors t like listen, but omit error conditions and metadata.

lookup_marshal_fun v This function takes a version v, and returns a function that will downgrade (if necessary) the current version to v and then write it to a bigsubstring.

lookup_unmarshal_fun v This function takes a version v, and returns a function that unmarshals a message and upgrades it, returning zero or more messages as a result of the upgrade.

mem t key returns true if there is state or an pending/running job

the same values as were passed to create.

a server that can handle no queries

num_unfinished_jobs t key returns the number of jobs for key including including pending and running.

of_lazy logging of lazy values.

open_file filename open a file for writing.

pipe format filename returns a pipe of all the messages in the log.

get the port that the server is listening on

printf generalized printf style logging

logging functions as the functions that operate on a given log.

raw printf like logging for raw (no level) messages.

raw printf like logging for raw (no level) messages.

read t filename provides a pipe that will be filled with messages from filename starting from the beginning, and continuing until the server calls unlink or close.

request an rpc version menu from an rpc connection

schedule_message t msg is write, but the message is taken from the provided bigstring.

send t msg send a message to the server.

send t client msg send msg to client.

send_ignore_errors t exactly like send but with no error reporting.

send_ignore_errors t client msg Just like send, but does not report results.

send_to_all t msg send the same message to all connected clients.

send_to_all_ignore_errors t msg Just like send_to_all but with no error reporting.

send_to_some t msg names send the same message to multiple connected clients.

send_to_some_ignore_errors t msg Just like send_to_some but with no error reporting.

serve ~port () must be called before clients will be able to connect.

serve implementations ~port ?on_handshake_error () starts a server with the given implementation on port.

serve_existing_static_file filename adds filename to the list of files that can be accessed via the Client module.

set_level sets the level of the given log.

set_output changes the output type of the log, which can be useful when daemonizing.

set_state t key state_opt sets the state for key immediately.

sexp logging of values without first converting them to a string.

state t

stop_serving t stops serving the file t to clients.

find what rpcs are supported

find what versions of a particular rpc are supported

tail t filename same as read, but delivers messages starting at some unspecified point near the current end of the file and continuing until the server calls unlink or close.

unpack_from_string_pipe unpack_buffer input returns (output, result), and uses unpack_buffer to unpack values from input until input is closed.

all supported versions.

all versions supported by dispatch_multi.

all versions implemented by implement_multi (useful for computing which old versions may be pruned)

all versions supported by dispatch_multi.

all versions supported by dispatch_multi.

wait_create ~path ~message becomes determined when the file at path gets locked.

with_client ~host ~port f connects to the server at (host,port) and runs f until an exception is thrown or until the returned Deferred is fulfilled.

with_close tries to create a t using the given reader and writer.

with_connection ~host ~port f looks up host from a string (using DNS as needed), connects, then calls f, passing the connected socket and a reader and writer for it.

with_file filename ~f opens filename and runs f, passing the resultant t.

write t s writes s to the file.

write_message t msg write msg to t.

write_sexp t sexp writes a Sexp.t as a single message

monitor t returns a monitor which will listen to errors arising from the internal writer used by t.