Index of values

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.

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.

If a connection is currently established, close it.

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

connect ~host ~port is a convenience wrapper around connect_sock that returns a reader and writer on 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

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

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

multi-version dispatch

multi-version dispatch

finalise is rebound to avoid accidental use in Async programs.

finalize f x is like Gc.finalise f x, except that the finalizer is guaranteed to run as an Async job (i.e.

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

implement multiple versions at once

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.

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.

open_file filename open a file for writing.

get the port that the server is listening on

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.

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

serve ~port handler starts a server on the specified port.

serve server ~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.

serve_unix ~file handler starts a server on the specified file (unix domain socket).

state t

stop_serving t stops serving the file t to clients.

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_reader unpacker unpacks all the values from reader until reaching EOF.

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 in a reader and a writer for the connected socket.

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.