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 creates a new, unstarted, bus.

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.

The default buffer capacity for UDP-oriented buffers is 1472, determined as the typical Ethernet MTU (1500 octets) less the typical UDP header length (28).

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.

flushed t returns a deferred that becomes determined when all subscribers have processed all values previously writen to t.

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.

reader_exn t returns a pipe that contains all elements subsequently written to t (and including prior values, if t is unstarted).

recvfrom_loop_with_buffer_replacement callback calls callback synchronously on each message received.

recvmmsg_loop ~socket callback iteratively receives up to max_count packets at a time on socket and passes them to callback.

recvmmsg_no_sources_loop ~socket callback is identical to recvmmsg_loop, but can be used when sources are ignored to avoid some overhead incurred by optional arguments.

request an rpc version menu from an rpc connection

Returns a pipe of samples as described above, one per second.

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.

sendto_sync sock buf addr does not try again if sock is not ready to write.

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.

Errors cause the stream to be closed.

No_longer_delayed_due_to_null_reads occurs after a nonempty sequence of Delayed_due_to_null_reads_for warnings, once the file tail gets a read that does not contain null reads.

Stat_failed occurs if stat fails.

start t starts the bus; it starts delivery of queued messages to readers.

state t

stop_serving t stops serving the file t to clients.

Get summarized cpu usage.

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.

waiting_create path repeatedly tries to lock path, becoming determined when path is locked or raising when abort becomes determined.

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 t a enqueues a on the bus, but does not call any subscriber functions immediately.

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.