|
(=) [Versioned_typed_tcp.Mode] |
|
(=) [Versioned_typed_tcp.Dont_care_about_mode] |
|
A |
abort [Rpc.State_rpc] |
|
abort [Rpc.Pipe_rpc] |
|
add [Versioned_typed_tcp.Version] |
|
add [Versioned_rpc.Menu] |
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 .
|
B |
bigsubstring_allocator [Versioned_typed_tcp] |
|
bin_read_t [Versioned_typed_tcp.Datumable_of_binable.T_bin] |
|
bin_read_t [Versioned_typed_tcp.Client_msg.Control] |
|
bin_read_t [Versioned_typed_tcp.Client_msg] |
|
bin_read_t [Versioned_typed_tcp.Server_msg.Control] |
|
bin_read_t [Versioned_typed_tcp.Read_result] |
|
bin_read_t [Versioned_typed_tcp.Dont_care_about_mode] |
|
bin_read_t [Tcp_file.Client.Message] |
|
bin_read_t [Log.Message] |
|
bin_read_t_ [Versioned_typed_tcp.Datumable_of_binable.T_bin] |
|
bin_read_t_ [Versioned_typed_tcp.Client_msg.Control] |
|
bin_read_t_ [Versioned_typed_tcp.Client_msg] |
|
bin_read_t_ [Versioned_typed_tcp.Server_msg.Control] |
|
bin_read_t_ [Versioned_typed_tcp.Read_result] |
|
bin_read_t_ [Versioned_typed_tcp.Dont_care_about_mode] |
|
bin_read_t_ [Tcp_file.Client.Message] |
|
bin_read_t_ [Log.Message] |
|
bin_read_t__ [Versioned_typed_tcp.Datumable_of_binable.T_bin] |
|
bin_read_t__ [Versioned_typed_tcp.Client_msg.Control] |
|
bin_read_t__ [Versioned_typed_tcp.Client_msg] |
|
bin_read_t__ [Versioned_typed_tcp.Server_msg.Control] |
|
bin_read_t__ [Versioned_typed_tcp.Read_result] |
|
bin_read_t__ [Versioned_typed_tcp.Dont_care_about_mode] |
|
bin_read_t__ [Tcp_file.Client.Message] |
|
bin_read_t__ [Log.Message] |
|
bin_reader_t [Versioned_typed_tcp.Datumable_of_binable.T_bin] |
|
bin_reader_t [Versioned_typed_tcp.Client_msg.Control] |
|
bin_reader_t [Versioned_typed_tcp.Client_msg] |
|
bin_reader_t [Versioned_typed_tcp.Server_msg.Control] |
|
bin_reader_t [Versioned_typed_tcp.Read_result] |
|
bin_reader_t [Versioned_typed_tcp.Dont_care_about_mode] |
|
bin_reader_t [Tcp_file.Client.Message] |
|
bin_reader_t [Log.Message] |
|
bin_size_t [Versioned_typed_tcp.Datumable_of_binable.T_bin] |
|
bin_size_t [Versioned_typed_tcp.Client_msg.Control] |
|
bin_size_t [Versioned_typed_tcp.Client_msg] |
|
bin_size_t [Versioned_typed_tcp.Server_msg.Control] |
|
bin_size_t [Versioned_typed_tcp.Read_result] |
|
bin_size_t [Versioned_typed_tcp.Dont_care_about_mode] |
|
bin_size_t [Tcp_file.Client.Message] |
|
bin_size_t [Log.Message] |
|
bin_t [Versioned_typed_tcp.Datumable_of_binable.T_bin] |
|
bin_t [Versioned_typed_tcp.Client_msg.Control] |
|
bin_t [Versioned_typed_tcp.Client_msg] |
|
bin_t [Versioned_typed_tcp.Server_msg.Control] |
|
bin_t [Versioned_typed_tcp.Read_result] |
|
bin_t [Versioned_typed_tcp.Dont_care_about_mode] |
|
bin_t [Tcp_file.Client.Message] |
|
bin_t [Log.Message] |
|
bin_write_t [Versioned_typed_tcp.Datumable_of_binable.T_bin] |
|
bin_write_t [Versioned_typed_tcp.Client_msg.Control] |
|
bin_write_t [Versioned_typed_tcp.Client_msg] |
|
bin_write_t [Versioned_typed_tcp.Server_msg.Control] |
|
bin_write_t [Versioned_typed_tcp.Read_result] |
|
bin_write_t [Versioned_typed_tcp.Dont_care_about_mode] |
|
bin_write_t [Tcp_file.Client.Message] |
|
bin_write_t [Log.Message] |
|
bin_write_t_ [Versioned_typed_tcp.Datumable_of_binable.T_bin] |
|
bin_write_t_ [Versioned_typed_tcp.Client_msg.Control] |
|
bin_write_t_ [Versioned_typed_tcp.Client_msg] |
|
bin_write_t_ [Versioned_typed_tcp.Server_msg.Control] |
|
bin_write_t_ [Versioned_typed_tcp.Read_result] |
|
bin_write_t_ [Versioned_typed_tcp.Dont_care_about_mode] |
|
bin_write_t_ [Tcp_file.Client.Message] |
|
bin_write_t_ [Log.Message] |
|
bin_writer_t [Versioned_typed_tcp.Datumable_of_binable.T_bin] |
|
bin_writer_t [Versioned_typed_tcp.Client_msg.Control] |
|
bin_writer_t [Versioned_typed_tcp.Client_msg] |
|
bin_writer_t [Versioned_typed_tcp.Server_msg.Control] |
|
bin_writer_t [Versioned_typed_tcp.Read_result] |
|
bin_writer_t [Versioned_typed_tcp.Dont_care_about_mode] |
|
bin_writer_t [Tcp_file.Client.Message] |
|
bin_writer_t [Log.Message] |
|
bytes_to_write [Rpc_intf.Connection] |
|
bytes_to_write [File_writer] |
bytes_to_write () returns the sum over all async_file_writers of how
many bytes they need to write.
|
C |
client [Rpc_intf.Connection] |
client ~host ~port connects to the server at (host ,port ) and returns the
connection or an Error if a connection could not be made.
|
client_addr_port [Typed_tcp_intf.S] |
|
close [Versioned_typed_tcp.S.Server] |
close t client close connection to client if it
exists.
|
close [Versioned_typed_tcp.Make.Server] |
|
close [Typed_tcp_intf.Arg.Transport] |
|
close [Typed_tcp_intf.S] |
|
close [Tcp_file.Server] |
close t closes the file t for writing.
|
close [Tcp.Server] |
|
close [Rpc_intf.Connection] |
|
close [Log] |
close closes a log so that further write attempts will raise an error.
|
close [File_writer] |
|
close_connection [Versioned_typed_tcp.S.Client] |
If a connection is currently established, close it.
|
close_connection [Versioned_typed_tcp.Make.Client] |
|
close_finished [Tcp.Server] |
|
close_finished [Rpc_intf.Connection] |
|
connect [Versioned_typed_tcp.S.Client] |
connect t If the connection is not currently established, initiate one.
|
connect [Versioned_typed_tcp.Make.Client] |
|
connect [Tcp_file.Client] |
|
connect [Tcp] |
|
connect_sock [Tcp] |
connect_sock ~host ~port opens a TCP connection to the specified hostname
and port, returning the socket.
|
create [Weak_hashtbl] |
|
create [Versioned_typed_tcp.S.Client] |
create a new (initially disconnected) client
|
create [Versioned_typed_tcp.S.Server] |
create a new server, and start listening
|
create [Versioned_typed_tcp.Make.Client] |
|
create [Versioned_typed_tcp.Make.Server] |
|
create [Typed_tcp_intf.Arg.Transport] |
|
create [Typed_tcp_intf.S] |
|
create [Tcp.Server] |
create where_to_listen handler starts a server listening to a socket as specified
by where_to_listen .
|
create [Tcp.Where_to_listen] |
|
create [Rpc_intf.Connection] |
Initiate an Rpc connection on the given reader/writer pair.
|
create [Rpc.State_rpc] |
|
create [Rpc.Pipe_rpc] |
|
create [Rpc.Rpc] |
|
create [Rpc.Server] |
create ~implementations ~on_unknown_rpc creates a server
capable of responding to the rpc's implemented in the implementation list.
|
create [Log.Blocking.Output] |
|
create [Log.Output] |
create f returns a t, given a function that actually performs the final output
work.
|
create [Log] |
create create a new log
|
create [Lock_file] |
create ?message path tries to create a file at path containing the text message ,
pid if none provided.
|
create [File_writer] |
create file opens file , creating it if it doesn't exist.
|
create [File_tail] |
create file creates a File_tail.t that will immediately begin reading file , and
then will start the stat-read loop.
|
create_exn [Rpc.Server] |
|
create_exn [Lock_file] |
create_exn ?message path is like create except that it throws an exception on
failure instead of returning a boolean value
|
current [Versioned_typed_tcp.Mode] |
|
current [Versioned_typed_tcp.Dont_care_about_mode] |
|
D |
debug [Log.Global_intf] |
|
debug [Log.Blocking] |
error printf like logging at the `Info log level
|
debug [Log] |
error printf like logging at the `Info log level
|
debug_snapshot [Tcp_file.Server] |
debug_snapshot () returns an s-expression containing details of the current
state of the Tcp_file server.
|
description [Rpc.Implementation] |
|
disconnect [Tcp_file.Client] |
|
dispatch [Rpc.State_rpc] |
|
dispatch [Rpc.Pipe_rpc] |
|
dispatch [Rpc.Rpc] |
|
dispatch_exn [Rpc.Pipe_rpc] |
|
dispatch_exn [Rpc.Rpc] |
|
dispatch_multi [Versioned_rpc.Caller_converts.Pipe_rpc.S] |
multi-version dispatch
|
dispatch_multi [Versioned_rpc.Caller_converts.Rpc.S] |
multi-version dispatch
|
E |
error [Log.Global_intf] |
|
error [Log.Blocking] |
error printf like logging at the `Info log level
|
error [Log] |
error printf like logging at the `Info log level
|
F |
file [Log.Output] |
|
find [Weak_hashtbl] |
|
find_or_add [Weak_hashtbl] |
|
flushed [Versioned_typed_tcp.S.Server] |
|
flushed [Versioned_typed_tcp.Make.Server] |
|
flushed [Tcp_file.Server] |
flushed t becomes determined only once all messages written to t have been
written to disk.
|
flushed [Log.Global_intf] |
|
flushed [Log] |
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 [File_writer] |
|
flushed_time [Typed_tcp_intf.Arg.Transport] |
|
flushed_time [Typed_tcp_intf.S] |
|
H |
has_client_id [Typed_tcp_intf.S] |
|
I |
implement [Rpc.State_rpc] |
|
implement [Rpc.Pipe_rpc] |
|
implement [Rpc.Rpc] |
|
implement_multi [Versioned_rpc.Callee_converts.S] |
implement multiple versions at once
|
info [Log.Global_intf] |
|
info [Log.Blocking] |
info printf like logging at the `Info log level
|
info [Log] |
info printf like logging at the `Info log level
|
inject [Weak_hashtbl.Box] |
|
invariant [Versioned_typed_tcp.S.Server] |
|
invariant [Versioned_typed_tcp.Make.Server] |
|
invariant [Tcp.Server] |
|
is_closed [Tcp.Server] |
|
is_closed [Rpc_intf.Connection] |
|
is_locked [Lock_file] |
is_locked path returns true when the file at path exists and is locked, false
otherwise.
|
L |
last_connect_error [Versioned_typed_tcp.S.Client] |
last_connect_error t returns the error (if any) that happened on the
last connection attempt.
|
last_connect_error [Versioned_typed_tcp.Make.Client] |
|
length [Tcp_file.Client.Message] |
|
level [Log.Message] |
|
listen [Versioned_typed_tcp.S.Client] |
listen t
|
listen [Versioned_typed_tcp.S.Server] |
listen t listen to the stream of messages and errors coming from clients
|
listen [Versioned_typed_tcp.Make.Client] |
|
listen [Versioned_typed_tcp.Make.Server] |
|
listen [Typed_tcp_intf.S] |
|
listen_ignore_errors [Versioned_typed_tcp.S.Client] |
listen_ignore_errors t like listen , but with no errors or meta data.
|
listen_ignore_errors [Versioned_typed_tcp.S.Server] |
listen_ignore_errors t like listen, but omit error conditions and
metadata.
|
listen_ignore_errors [Versioned_typed_tcp.Make.Client] |
|
listen_ignore_errors [Versioned_typed_tcp.Make.Server] |
|
listen_ignore_errors [Typed_tcp_intf.S] |
|
listening_on [Tcp.Server] |
|
load [Persistent_singleton.S] |
|
load [Persistent_singleton.Make] |
|
lookup_marshal_fun [Versioned_typed_tcp.Datumable] |
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_marshal_fun [Versioned_typed_tcp.Datumable_of_binable.Make_datumable5] |
|
lookup_unmarshal_fun [Versioned_typed_tcp.Datumable] |
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.
|
lookup_unmarshal_fun [Versioned_typed_tcp.Datumable_of_binable.Make_datumable5] |
|
low_version [Versioned_typed_tcp.Versions] |
|
low_version [Versioned_typed_tcp.Datumable_of_binable.Pre_versions] |
|
M |
message [Log.Global_intf] |
|
message [Log.Message] |
|
message [Log] |
|
monitor [File_writer] |
|
N |
name [Rpc.State_rpc] |
|
name [Rpc.Pipe_rpc] |
|
name [Rpc.Rpc] |
|
null [Rpc.Server] |
|
O |
of_lazy [Log.Global_intf] |
|
of_lazy [Log] |
of_lazy logging of lazy values.
|
of_v [Versioned_typed_tcp.Datumable_of_binable.V.S] |
|
on_file [Tcp] |
|
on_port [Tcp] |
|
on_port_chosen_by_os [Tcp] |
|
open_file [Tcp_file.Server] |
open_file filename open a file for writing.
|
ounit_tests [Typed_tcp_intf] |
|
ounit_tests [Weak_hashtbl] |
|
ounit_tests [Versioned_typed_tcp] |
|
ounit_tests [Versioned_rpc] |
|
ounit_tests [Unpack_sequence] |
|
ounit_tests [Typed_tcp] |
|
ounit_tests [Tcp_file] |
|
ounit_tests [Tcp] |
|
ounit_tests [Std] |
|
ounit_tests [Rpc_intf] |
|
ounit_tests [Rpc] |
|
ounit_tests [Persistent_singleton] |
|
ounit_tests [Log] |
|
ounit_tests [Lock_file] |
|
ounit_tests [Inline_tests] |
|
ounit_tests [Import] |
|
ounit_tests [File_writer] |
|
ounit_tests [File_tail] |
|
P |
pipe [Log.Reader] |
|
port [Versioned_typed_tcp.S.Server] |
get the port that the server is listening on
|
port [Versioned_typed_tcp.Make.Server] |
|
printf [Log.Global_intf] |
|
printf [Log] |
printf generalized printf style logging
|
prod_version [Versioned_typed_tcp.Versions] |
|
prod_version [Versioned_typed_tcp.Datumable_of_binable.Pre_versions] |
|
project [Weak_hashtbl.Box] |
|
protocol_version [Versioned_typed_tcp] |
|
R |
raw [Log.Global_intf] |
logging functions as the functions that operate on a given log.
|
raw [Log.Blocking] |
raw printf like logging for raw (no level) messages.
|
raw [Log] |
raw printf like logging for raw (no level) messages.
|
read [Typed_tcp_intf.Arg.Transport] |
|
read [Tcp_file.Client] |
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 .
|
remove [Weak_hashtbl] |
|
replace [Weak_hashtbl] |
|
request [Versioned_rpc.Menu] |
request an rpc version menu from an rpc connection
|
rotating_file [Log.Output] |
|
rpc [Versioned_rpc.Callee_converts.Make.Register] |
|
rpc [Versioned_rpc.Caller_converts.Pipe_rpc.Make.Register] |
|
rpc [Versioned_rpc.Caller_converts.Rpc.Make.Register] |
|
run [Inline_tests] |
|
S |
save [Persistent_singleton.S] |
|
save [Persistent_singleton.Make] |
|
schedule_bigstring [File_writer] |
|
schedule_message [Tcp_file.Server] |
schedule_message t msg is write, but the message is taken from the
provided bigstring.
|
screen [Log.Blocking.Output] |
|
screen [Log.Output] |
|
send [Versioned_typed_tcp.S.Client] |
send t msg send a message to the server.
|
send [Versioned_typed_tcp.S.Server] |
send t client msg send msg to client .
|
send [Versioned_typed_tcp.Make.Client] |
|
send [Versioned_typed_tcp.Make.Server] |
|
send [Typed_tcp_intf.S] |
|
send_ignore_errors [Versioned_typed_tcp.S.Client] |
send_ignore_errors t exactly like send but with no error reporting.
|
send_ignore_errors [Versioned_typed_tcp.S.Server] |
send_ignore_errors t client msg Just like send, but does not report
results.
|
send_ignore_errors [Versioned_typed_tcp.Make.Client] |
|
send_ignore_errors [Versioned_typed_tcp.Make.Server] |
|
send_ignore_errors [Typed_tcp_intf.S] |
|
send_to_all [Versioned_typed_tcp.S.Server] |
send_to_all t msg send the same message to all connected clients.
|
send_to_all [Versioned_typed_tcp.Make.Server] |
|
send_to_all [Typed_tcp_intf.S] |
|
send_to_all_ignore_errors [Versioned_typed_tcp.S.Server] |
send_to_all_ignore_errors t msg Just like send_to_all but with no error
reporting.
|
send_to_all_ignore_errors [Versioned_typed_tcp.Make.Server] |
|
serve [Tcp_file.Server] |
serve ~port () must be called before clients will be able to connect.
|
serve [Rpc_intf.Connection] |
serve server ~port ?on_handshake_error () starts a server with the given
implementation on port .
|
serve_existing_static_file [Tcp_file.Server] |
serve_existing_static_file filename adds filename to the list of files
that can be accessed via the Client module.
|
server_with_close [Rpc_intf.Connection] |
|
set_level [Log.Global_intf] |
|
set_level [Log.Blocking] |
|
set_level [Log] |
set_level sets the level of the given log.
|
set_output [Log.Global_intf] |
|
set_output [Log.Blocking] |
|
set_output [Log] |
set_output changes the output type of the log, which can be useful when daemonizing.
|
sexp [Log.Global_intf] |
|
sexp [Log] |
sexp logging of values without first converting them to a string.
|
sexp_of_t [Versioned_typed_tcp.Client_msg.Control] |
|
sexp_of_t [Versioned_typed_tcp.Client_msg] |
|
sexp_of_t [Versioned_typed_tcp.Server_msg.Control] |
|
sexp_of_t [Versioned_typed_tcp.Read_result] |
|
sexp_of_t [Versioned_typed_tcp.Dont_care_about_mode] |
|
sexp_of_t [Unpack_sequence.Result] |
|
sexp_of_t [Tcp_file.Client.Error] |
|
sexp_of_t [Rpc.Implementation.Description] |
|
sexp_of_t [Log.Message] |
|
sexp_of_t [Log.Level] |
|
sexp_of_t [File_writer] |
|
sexp_of_t [File_tail.Update] |
|
sexp_of_t [File_tail.Warning] |
|
sexp_of_t [File_tail.Error] |
|
state [Versioned_typed_tcp.S.Client] |
state t
|
state [Versioned_typed_tcp.Make.Client] |
|
stop_serving [Tcp_file.Server] |
stop_serving t stops serving the file t to clients.
|
supported_rpcs [Versioned_rpc.Menu] |
find what rpcs are supported
|
supported_versions [Versioned_rpc.Menu] |
find what versions of a particular rpc are supported
|
T |
t_of_sexp [Versioned_typed_tcp.Client_msg.Control] |
|
t_of_sexp [Versioned_typed_tcp.Client_msg] |
|
t_of_sexp [Versioned_typed_tcp.Server_msg.Control] |
|
t_of_sexp [Versioned_typed_tcp.Read_result] |
|
t_of_sexp [Versioned_typed_tcp.Dont_care_about_mode] |
|
t_of_sexp [Tcp_file.Client.Error] |
|
t_of_sexp [Rpc.Implementation.Description] |
|
t_of_sexp [Log.Message] |
|
t_of_sexp [Log.Level] |
|
t_of_sexp__ [Versioned_typed_tcp.Client_msg.Control] |
|
t_of_sexp__ [Versioned_typed_tcp.Client_msg] |
|
t_of_sexp__ [Versioned_typed_tcp.Server_msg.Control] |
|
t_of_sexp__ [Versioned_typed_tcp.Read_result] |
|
t_of_sexp__ [Versioned_typed_tcp.Dont_care_about_mode] |
|
t_of_sexp__ [Log.Level] |
|
tags [Log.Message] |
|
tail [Tcp_file.Client] |
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 .
|
test_version [Versioned_typed_tcp.Versions] |
|
tests [Inline_tests] |
|
time [Log.Message] |
|
to_bigstring [Tcp_file.Client.Message] |
|
to_error [Unpack_sequence.Result] |
|
to_file [Tcp] |
|
to_host_and_port [Tcp] |
|
to_string [Tcp_file.Client.Message] |
|
to_string [Tcp_file.Client.Error] |
|
to_string_exn [Tcp_file.Client.Message] |
|
to_string_hum [File_tail.Update] |
|
to_string_hum [File_tail.Warning] |
|
to_string_hum [File_tail.Error] |
|
to_v [Versioned_typed_tcp.Datumable_of_binable.V.S] |
|
U |
unpack_bin_prot_from_reader [Unpack_sequence] |
|
unpack_from_reader [Unpack_sequence] |
|
unpack_from_string_pipe [Unpack_sequence] |
unpack_from_string_pipe unpack_buffer input returns (output, result) , and uses
unpack_buffer to unpack values from input until input is closed.
|
V |
version [Rpc.Rpc] |
|
versions [Versioned_rpc.Callee_converts.S] |
all versions implemented by implement_multi
(useful for computing which old versions may be pruned)
|
versions [Versioned_rpc.Caller_converts.Pipe_rpc.S] |
all versions supported by dispatch_multi .
|
versions [Versioned_rpc.Caller_converts.Rpc.S] |
all versions supported by dispatch_multi .
|
W |
waiting_create [Lock_file] |
wait_create ~path ~message becomes determined when the file at path gets locked.
|
with_client [Rpc_intf.Connection] |
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 [Rpc_intf.Connection] |
with_close tries to create a t using the given reader and writer.
|
with_connection [Tcp] |
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 [Tcp_file.Server] |
with_file filename ~f opens filename and runs f , passing the resultant
t .
|
write [Typed_tcp_intf.Arg.Transport] |
|
write [File_writer] |
write t s writes s to the file.
|
write_bigsubstring [File_writer] |
|
write_bin_prot [File_writer] |
|
write_message [Tcp_file.Server] |
write_message t msg write msg to t .
|
write_sexp [Tcp_file.Server] |
write_sexp t sexp writes a Sexp.t as a single message
|
write_sexp [File_writer] |
|
write_substring [File_writer] |
|
writer [Log.Output] |
|
writer_monitor [Tcp_file.Server] |
monitor t returns a monitor which will listen to errors arising from the
internal writer used by t .
|