# Index of class methods

A
abort [Nethttpd_kernel.http_protocol] | Stops the transmission of data.
abort [Ftp_client.ftp_client_pi] | Shuts any active connection immediately down, and changes the state of the engine to ``Aborted`.
abort [Uq_engines.cache_t] | Any engine running to get the cache value is aborted, and the contents of the cache are invalidated.
abort [Uq_engines.engine] | Forces that the engine aborts operation.
abort [Uq_resolver.engine] |
abort_rw [Rpc_transport.rpc_multiplex_controller] | Aborts the current reader and/or writer forever.
accept [Uq_engines.server_endpoint_acceptor] | Instantiates an engine that accepts connections on the listening endpoint.
accept_body [Nethttpd_reactor.http_reactive_request] | Call this method to unlock the body channels.
accept_sec_context [Netgssapi.gss_api] | On the first call, pass `~context:None`.
acquire_cred [Netgssapi.gss_api] |
activate_lever [Netplex_types.container] | Runs a lever function registered in the controller.
activate_lever [Netplex_types.controller] | Runs the registered lever directly
add [Netsys_pollset.pollset] | Add a descriptor or modify an existing descriptor
add [Http_client.pipeline] | Adds the call to the end of the pipeline.
add_abort_action [Unixqueue_select.sb_event_system] |
add_abort_action [Unixqueue.event_system] |
add_admin [Netplex_types.controller] | `add_admin setup`: Allows to bind another RPC program to the admin socket.
add_auth_handler [Http_client.pipeline] | adds a new-style authentication handler
add_authentication_method [Http_client.pipeline] | adds an old-style authentication method
add_close_action [Unixqueue_select.sb_event_system] |
add_close_action [Unixqueue.event_system] |
add_cred [Netgssapi.gss_api] |
add_e [Http_client.pipeline] | The same as engine: The call `c` is added to the pipeline, and when it is processed, the returned engine transitions to the state ``Done c`.
add_event [Unixqueue_select.sb_event_system] |
add_event [Unixqueue.event_system] |
add_handler [Unixqueue_select.sb_event_system] |
add_handler [Unixqueue.event_system] |
add_key [Http_client.key_ring] | Adds a key to the ring
add_message_receiver [Netplex_types.controller] | Adds a message receiver.
add_plugin [Netplex_types.controller] | Adds a plugin.
add_resource [Unixqueue_select.sb_event_system] |
add_resource [Unixqueue.event_system] |
add_service [Netplex_types.controller] | Adds a new service.
add_weak_resource [Unixqueue_select.sb_event_system] |
add_weak_resource [Unixqueue.event_system] |
add_with_callback [Http_client.pipeline] | Adds the call to the end of the pipeline.
addresses [Netplex_types.protocol] | The addresses of the master sockets.
adjust [Netplex_types.workload_manager] | This function is called by the controller at certain events to adjust the number of available containers.
advance [Nethttpd_kernel.http_response] | Tell this object that `n` bytes of the front token could be really sent using `Unix.write`.
alive [Rpc_transport.rpc_multiplex_controller] | If the controller is alive, the socket is not yet completely down.
alive [Uq_engines.multiplex_controller] | If the controller is alive, the socket is not yet completely down.
apop [Netpop.client] | Specifies the user and password using APOP authentication.
argument [Netcgi1_compat.Netcgi_types.cgi_activation] |
argument [Netcgi.cgi] | `#argument name` returns the value of the argument named `name`.
argument [Netcgi_common.cgi] |
argument_exists [Netcgi.cgi] | `#argument_exists` returns `false` if the named parameter is missing and `true` otherwise.
argument_exists [Netcgi_common.cgi] |
argument_value [Netcgi1_compat.Netcgi_types.cgi_activation] |
argument_value [Netcgi.cgi] | `#argument_value` returns the value of the argument as a string.
argument_value [Netcgi_common.cgi] |
arguments [Netcgi1_compat.Netcgi_types.cgi_activation] | Mutability of arguments has been dropped.
arguments [Netcgi.cgi] | The complete list of arguments.
arguments [Netcgi_common.cgi] |
as_auth_handler [Http_client.basic_auth_method] |
as_memory [Xdr_mstring.mstring] | Returns the contents as memory.
as_string [Xdr_mstring.mstring] | Returns the contents as string.
assoc_multi_req_header [Http_client.http_call] | Return all header values for a given field name (header entries which allow several values separated by commas can also be transmitted by several header lines with the same name).
assoc_multi_resp_header [Http_client.http_call] | Return all response header values for a given field name (header entries which allow several values separated by commas can also be transmitted by several header lines with the same name).
assoc_req_header [Http_client.http_call] | Query a specific header entry, or raise `Not_found`
assoc_resp_header [Http_client.http_call] | Query a specific header entry of the response.
at_exit [Netcgi.cgi] | `#at_exit f` registers the function `f` to be executed when `#finalize` is called (which is done automatically when the request finishes).
at_exit [Netcgi_common.cgi] |
attach [Telnet_client.telnet_session] | Attach to the event system.
auth_domain [Http_client.auth_session] | The list of domain URIs defines the protection space.
auth_in_advance [Http_client.auth_session] | Whether "authentication in advance" is enabled
auth_method [Rpc_client.auth_protocol] |
auth_protocol [Rpc_client.auth_session] | Return the corresponding protocol
auth_realm [Http_client.auth_session] | The realm
auth_scheme [Http_client.auth_session] | The authentication scheme, e.g.
auth_user [Http_client.auth_session] | The user identifier
authenticate [Rpc_server.auth_method] | `authenticate srv conn_id details f`: This method is called when a remote call has arrived.
authenticate [Http_client.auth_session] | Returns a list of additional headers that will authenticate the passed call for this session.
avoid_proxy_for [Http_client.pipeline] | sets a list of host names or domain suffixes for which no proxy should be used.
B
bidirectional_phase [Nethttpd_kernel.http_response] | The bidrectional phase starts after "100 Continue" has been sent to the client, and stops when the response body begins.
blit_to_memory [Xdr_mstring.mstring] | `blit_to_string mpos mem mempos len`: Copies the substring of the managed string from `mpos` to `mpos+len-1` to the substring of `mem` from `mempos` to `mempos+len-1`
blit_to_string [Xdr_mstring.mstring] | `blit_to_string mpos s spos len`: Copies the substring of the managed string from `mpos` to `mpos+len-1` to the substring of `s` from `spos` to `spos+len-1`
block_size [Netstream.in_obj_stream] | The block size of the stream
body_size [Nethttpd_kernel.http_response] | Accumulated size of the response body
bool_param [Netplex_types.config_file] |
broadcast [Netsys_oothr.condition] | In a multi-threaded program: Signal all waiting processes that the condition holds.
C
call_plugin [Netplex_types.container] | `call_plugin p procname procarg`: This method can be called from the container context to invoke the plugin `p` procedure `procname`.
callback [Netcgi_modtpl.template] | Set a callback in the template.
can_input [Uq_engines.async_in_channel] | Whether input is possible, i.e.
can_output [Uq_engines.async_out_channel] | Whether output is possible, i.e.
cancel [Netfs.stream_fs] | Cancels any ongoing `write`.
cancel [Http_fs.http_stream_fs] |
cancel_rd_polling [Rpc_transport.rpc_multiplex_controller] | Cancels polling for the next input message.
cancel_reading [Uq_engines.multiplex_controller] | Cancels the read job.
cancel_shutting_down [Rpc_transport.rpc_multiplex_controller] | Cancels the shutdown procedure.
cancel_shutting_down [Uq_engines.multiplex_controller] | Cancels the shutdown procedure.
cancel_wait [Netsys_pollset.pollset] | There is a cancel bit in the pollset, and this method sets it to the argument value.
cancel_writing [Uq_engines.multiplex_controller] | Cancels the write job.
canonicalize_name [Netgssapi.gss_api] |
capacity [Netplex_types.workload_manager] | Computes the capacity, i.e.
cgi_auth_type [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_auth_type [Netcgi.cgi_environment] |
cgi_auth_type [Netcgi_common.cgi_environment] |
cgi_gateway_interface [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_gateway_interface [Netcgi.cgi_environment] |
cgi_gateway_interface [Netcgi_common.cgi_environment] |
cgi_https [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_https [Netcgi.cgi_environment] | A well-known extension is the HTTPS property.
cgi_https [Netcgi_common.cgi_environment] |
cgi_path_info [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_path_info [Netcgi.cgi_environment] |
cgi_path_info [Netcgi_common.cgi_environment] |
cgi_path_translated [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_path_translated [Netcgi.cgi_environment] |
cgi_path_translated [Netcgi_common.cgi_environment] |
cgi_properties [Nethttpd_types.request_info] | The distilled CGI properties
cgi_properties [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_properties [Netcgi.cgi_environment] | Return all properties as an associative list.
cgi_properties [Netcgi_common.cgi_environment] | Return the parameter `properties`.
cgi_property [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_property [Netcgi.cgi_environment] | Returns a (possibly non-standard) CGI environment property.
cgi_property [Netcgi_common.cgi_environment] |
cgi_query_string [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_query_string [Netcgi.cgi_environment] | This is the row query string.
cgi_query_string [Netcgi_common.cgi_environment] |
cgi_remote_addr [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_remote_addr [Netcgi.cgi_environment] |
cgi_remote_addr [Netcgi_common.cgi_environment] |
cgi_remote_host [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_remote_host [Netcgi.cgi_environment] |
cgi_remote_host [Netcgi_common.cgi_environment] |
cgi_remote_ident [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_remote_ident [Netcgi.cgi_environment] |
cgi_remote_ident [Netcgi_common.cgi_environment] |
cgi_remote_user [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_remote_user [Netcgi.cgi_environment] |
cgi_remote_user [Netcgi_common.cgi_environment] |
cgi_request_method [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_request_method [Netcgi.cgi_environment] | We recommend you to use the method `Netcgi.cgi.request_method` which is more type-safe and informative.
cgi_request_method [Netcgi_common.cgi_environment] |
cgi_request_uri [Nethttpd_types.v_extended_environment] | The full request URI.
cgi_request_uri [Netcgi1_compat.Netcgi_env.cgi_environment] | I rest to be convinced we need this.
cgi_script_name [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_script_name [Netcgi.cgi_environment] |
cgi_script_name [Netcgi_common.cgi_environment] |
cgi_server_name [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_server_name [Netcgi.cgi_environment] |
cgi_server_name [Netcgi_common.cgi_environment] |
cgi_server_port [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_server_port [Netcgi.cgi_environment] |
cgi_server_port [Netcgi_common.cgi_environment] |
cgi_server_protocol [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_server_protocol [Netcgi.cgi_environment] |
cgi_server_protocol [Netcgi_common.cgi_environment] |
cgi_server_software [Netcgi1_compat.Netcgi_env.cgi_environment] |
cgi_server_software [Netcgi.cgi_environment] |
cgi_server_software [Netcgi_common.cgi_environment] |
change_user_to [Netplex_types.socket_service_config] | Instructs the container to change the user of the process after starting the service.
channel_binding [Http_client.pipeline] | Reports the current channel binding of this call
charset [Netcgi1_compat.Netcgi_types.cgi_argument] |
charset [Netcgi.cgi_argument] | The `charset` parameter of the content type of the header, or `""` when there is no such parameter, or no header.
charset [Netcgi_common.cgi_argument] |
cleanup [Uq_lwt.lwt_backend] |
clear [Http_client.key_ring] | Deletes all keys from this key ring
clear [Unixqueue_select.sb_event_system] |
clear [Unixqueue.event_system] |
client_addr [Rpc_server.auth_details] |
close [Netfs.local_file] | Indicate that we are done with the file
close [Nethttpd_reactor.http_reactor] | Closes the file descriptor with a reliable method.
close [Ftp_fs.ftp_stream_fs] | Forces that the FTP client is closed.
close_all [Http_client_conncache.connection_cache] | Closes all descriptors known to the cache
close_connection [Nethttpd_kernel.http_response] | Returns whether the connection should be closed after this response.
close_connection [Http_client_conncache.connection_cache] | Deletes the connection from the cache, and closes it
close_in [Netchannels.augment_raw_in_channel] | As in `raw_in_channel`
close_in [Netchannels.rec_in_channel] | Closes the channel for input.
close_in [Uq_engines.async_in_channel] | Closes the channel
close_out [Netchannels.augment_raw_out_channel] | As in `raw_out_channel`
close_out [Netchannels.rec_out_channel] | Flushes the buffer, if any, and closes the channel for output.
close_out [Uq_engines.async_out_channel] | Closes the channel
cnt_crashed_connections [Http_client.pipeline] | Counts connections with network or protocol errors
cnt_failed_connections [Http_client.pipeline] | Counts totally failed connections (no more reconnects allowed)
cnt_new_connections [Http_client.pipeline] | Counts new connections (or better: attempts to establish connections)
cnt_server_eof_connections [Http_client.pipeline] | Counts connections the server terminated with EOF
cnt_successful_connections [Http_client.pipeline] | Counts connections closed because pipelines become empty
cnt_timed_out_connections [Http_client.pipeline] | Counts connections given up because of timeouts
commit_work [Netchannels.trans_out_obj_channel] | Flushes the transaction buffer, and writes its contents to the underlying resource.
compare_name [Netgssapi.gss_api] |
conditional [Netcgi_modtpl.template] | Set a conditional in the template.
config [Nethttpd_kernel.http_protocol] | Just returns the configuration
config [Netcgi1_compat.Netcgi_env.cgi_environment] |
config [Netcgi.cgi_environment] | The configuration of the request.
config [Netcgi_common.cgi_environment] |
config_announce_server [Nethttpd_kernel.http_protocol_config] | Whether to set the `Server` header: ``Ignore`: The kernel does not touch the `Server` header., ``Ocamlnet`: Announce this web server as "Ocamlnet/<version>", ``Ocamlnet_and s`: Announce this web server as `s` and append the Ocamlnet string., ``As s`: Announce this web server as `s`
config_cgi [Nethttpd_reactor.http_processor_config] | The CGI configuration to use in the Netcgi environment
config_error_response [Nethttpd_reactor.http_processor_config] | Get HTML error text for the HTTP status code.
config_error_response [Nethttpd_types.min_config] |
config_input_flow_control [Nethttpd_engine.http_engine_config] | If `true`, the engine stops reading input tokens from the HTTP kernel when there is data in the input channel of the engine not yet read.
config_limit_pipeline_length [Nethttpd_kernel.http_protocol_config] | Limits the length of the pipeline (= unreplied requests).
config_limit_pipeline_size [Nethttpd_kernel.http_protocol_config] | Limits the size of the pipeline in bytes.
config_log_access [Nethttpd_reactor.http_processor_config] | Logs the access after the request/response cycle is complete.
config_log_error [Nethttpd_reactor.http_processor_config] | `config_log_error info msg`: Log the message `msg`.
config_log_error [Nethttpd_types.min_config] |
config_max_header_length [Nethttpd_kernel.http_protocol_config] | Maximum size of the header, including the request line.
config_max_reqline_length [Nethttpd_kernel.http_protocol_config] | Maximum size of the request line.
config_max_trailer_length [Nethttpd_kernel.http_protocol_config] | Maximum size of the trailer
config_output_flow_control [Nethttpd_engine.http_engine_config] | If `true`, the engine signals the user when there is already enough data to output, and no more output should be generated.
config_reactor_synch [Nethttpd_reactor.http_reactor_config] | Specifies when to synchronize output, i.e.
config_suppress_broken_pipe [Nethttpd_kernel.http_protocol_config] | Whether to suppress ``Broken_pipe` errors.
config_synch_input [Nethttpd_engine.http_engine_processing_config] | The "input synchronizer": It is called as `obj # config_synch_input f ch` to create a synchronous input channel from an asynchronous one, `ch`.
config_synch_output [Nethttpd_engine.http_engine_processing_config] | The "output synchronizer": It is called as `obj # config_synch_output f ch` to create a synchronous output channel from an asynchronous one, `ch`.
config_timeout [Nethttpd_reactor.http_processor_config] | General timeout for network I/O (per I/O primitive).
config_timeout_next_request [Nethttpd_reactor.http_processor_config] | Timeout in seconds to wait for the next request after the previous one has been completely received.
configure_slave_socket [Netplex_types.protocol] | A user-supplied function to configure slave sockets (after `accept`).
configure_timeout [Ftp_client.ftp_client] | Configures a timeout for both the control and the data connection.
configure_transport [Http_client.pipeline] | `configure_transport id transport`: Configures that messages with channel binding ID `id` are exchanged on `transport`.
conn_limit [Netplex_types.socket_service_config] | An optional limit of the number of connections this container can accept.
connect [Uq_engines.client_endpoint_connector] | Instantiates an engine that connects to the endpoint given by the `connect_address` argument.
connection_cache [Http_client.pipeline] | The current connection cache.
connections [Http_client.pipeline] | Reports which connections exist: `(host, port, queue_length)`
container_count [Netplex_types.controller] | The number of containers for a certain socket service name
container_event_system [Netplex_types.processor_hooks] | This method is called to get the event systems for containers.
container_id [Netplex_types.container] | Return the container ID
container_run [Netplex_types.processor_hooks] | `container_run esys`: By default, it just runs `esys#run()`.
container_state [Netplex_types.socket_controller] |
containers [Netplex_types.controller] | Lists the containers
containers_for [Netplex_types.controller] | Lists the containers for a certain socket service name
content_disposition [Netmime.mime_header_ro] | Returns the Content-disposition field as parsed value.
content_length [Netmime.mime_header_ro] | Returns the Content-length field as integer
content_transfer_encoding [Netmime.mime_header_ro] | Returns the Content-transfer-encoding as string
content_type [Netmime.mime_header_ro] | Returns the Content-type as parsed value.
content_type [Netcgi1_compat.Netcgi_types.cgi_argument] |
content_type [Netcgi.cgi_argument] | Returns the content type of the header and its parameters as a couple `(hdr, params)`.
content_type [Netcgi_common.cgi_argument] |
content_type_params [Netcgi1_compat.Netcgi_types.cgi_argument] | Method `content_type : unit -> string * (string * Mimestring.s_param) list` defined instead of `content_type` and `content_type_params` to be coherent with `Netmime.mime_header_ro` -- yet as easy to use.
context_time [Netgssapi.gss_api] |
continue [Http_client.transport_channel_type] | `continue` is called when an already established circuit needs to be continued.
continue [Https_client.transport_channel_type] |
controller_config [Netplex_types.netplex_config] |
controller_config [Netplex_types.socket_service_config] | Make this config accessible here too, for convenience
controller_config [Netplex_types.controller] |
cookie [Netcgi.cgi_environment] | `#cookie cn` returns the cookie with name `cn`.
cookie [Netcgi_common.cgi_environment] |
cookies [Netcgi1_compat.Netcgi_env.cgi_environment] | Cookies are returned in decoded form.
cookies [Netcgi.cgi_environment] | Returns the list of valid cookies found in the request header.
cookies [Netcgi_common.cgi_environment] |
copy [Netfs.stream_fs] | Copies a file to a new name.
copy [Http_fs.http_stream_fs] |
create_condition [Netsys_oothr.mtprovider] | In a multi-threaded program: Creates a condition variable and returns the object.
create_container [Netplex_types.socket_service] | Internal method.
create_datagram_socket [Uq_engines.datagram_socket_provider] | Creates an engine that creates a `wrapped_datagram_socket` object and that sets up any further resources the objects needs.
create_from_memory [Xdr_mstring.mstring_factory] | `create_from_memory m pos len must_copy`: Creates the `mstring` from the sub string of m starting at `pos` with length `len`
create_from_string [Xdr_mstring.mstring_factory] | `create_from_string s pos len must_copy`: Creates the `mstring` from the sub string of s starting at `pos` with length `len`
create_logger [Netplex_types.logger_factory] |
create_logger [Netplex_types.controller_config] | Create a logger to be used for the whole Netplex system.
create_mem_mutex [Netplex_types.parallelizer] | `let lock, unlock = par#create_mem_locker()`: Creates a mutex that is sufficient to protect process memory from uncoordinated access.
create_mutex [Netsys_oothr.mtprovider] | In a multi-threaded program: Creates a mutex and returns the object.
create_processor [Netplex_types.processor_factory] |
create_proxy_session [Http_client.auth_handler] | Same for proxy authentication
create_session [Http_client.auth_handler] | Create a new authentication session.
create_thread [Netsys_oothr.mtprovider] | In a multi-threaded program: Starts a new thread, and calls the passed function with the passed argument in the new thread (like `Thread.create`).
create_workload_manager [Netplex_types.workload_manager_factory] |
credential [Rpc_server.auth_details] |
ctrl_added [Netplex_types.plugin] | This method is invoked when the plugin has been added to this controller.
ctrl_container_finished [Netplex_types.plugin] | This method is called when a container finishes (after `post_finish_hook`).
ctrl_receive_call [Netplex_types.plugin] | `ctrl_receive_call ctrl cid procname procarg emit`: This method is called in the controller context `ctrl` when a procedure named `procname` is called.
ctrl_unplugged [Netplex_types.plugin] | The plugin has been unplugged from this controller
current_sys_id [Netplex_types.parallelizer] | Returns the system-dependent thread identifier of the caller
cycle [Nethttpd_kernel.lingering_close] | Reads data from the file descriptor until EOF or until a fixed timeout is over.
cycle [Nethttpd_kernel.http_protocol] | Looks at the file descriptor.
D
data [Netsmtp.client] | This method really send the mail.
data [Netcgi_fcgi.cgi] | This the the channel on which the filter data is available.
data_length [Netcgi_fcgi.cgi] | How many bytes of the data are available.
data_mtime [Netcgi_fcgi.cgi] | The data last modification time, expressed as an integer number of seconds since the epoch (January 1, 1970 UTC).
datagram_type [Uq_engines.wrapped_datagram_socket] |
def_empty_path_replacement [Http_client.generic_call] |
def_has_req_body [Http_client.generic_call] |
def_has_resp_body [Http_client.generic_call] |
def_is_idempotent [Http_client.generic_call] |
def_request_method [Http_client.generic_call] | The following methods define the values for the corresponding methods without the `def_` prefix:
def_term [Nethttpd_types.http_service] | The definition term
default_user_name [Netmech_scram_gssapi.client_key_ring] | This method may return a default user name
dele [Netpop.client] | Marks the message number of the current mailbox for deletion.
delete_argument [Netcgi1_compat.Netcgi_types.cgi_activation] |
delete_field [Netmime.mime_header] | These methods modify the fields of the header.
delete_sec_context [Netgssapi.gss_api] | Output tokens are not supported (this is a deprecated feature of GSSAPI)
descr [Ftp_data_endpoint.ftp_data_engine] | The socket to use for data transfers.
descr_state [Ftp_data_endpoint.ftp_data_engine] | The socket state
descriptor [Uq_engines.wrapped_datagram_socket] | The underlying file descriptor.
dest_status [Http_client.http_call] | Returns the status line of the last response (but status lines with code 100 are ignored).
disable [Netplex_types.socket_controller] | Disable a socket service temporarily
disable_local_option [Telnet_client.telnet_session] |
disable_remote_option [Telnet_client.telnet_session] |
display_minor_status [Netgssapi.gss_api] | Note that `display_minor_status` decodes all status value parts in one step and returns the result as `string list`.
display_name [Netgssapi.gss_api] |
dispose [Netsys_pollset.pollset] | Release any OS resources associated with the pollset.
do_input [Nethttpd_kernel.http_protocol] | Returns `true` iff the protocol engine is interested in new data from the socket.
do_output [Nethttpd_kernel.http_protocol] | Returns `true` iff the protocol engine has data to output to the socket
domain [Http_client.key] | The domain URIs defining the protection space.
E
effective_request_uri [Http_client.http_call] | The URI actually sent to the server in the request line of the protocol.
emit [Rpc_client.auth_protocol] | Emits a token for this `xid`, `prog_nr` and `vers_nr`.
empty_path_replacement [Http_client.http_call] | The string to substitute in the request line for the empty path.
enable [Netplex_types.socket_controller] | Enables a disabled socket service again
enable_local_option [Telnet_client.telnet_session] |
enable_remote_option [Telnet_client.telnet_session] |
engine [Nethttpd_engine.http_engine_processing_context] | The engine doing HTTP
enhanced_input [Netchannels.enhanced_raw_in_channel] | Works similar to `input`, but distinguishes between normal data and end-of-line separators.
enhanced_input_line [Netchannels.enhanced_raw_in_channel] | An improved implementation of `input_line` that uses the buffer
environment [Nethttpd_engine.http_request_notification] | The request environment.
environment [Nethttpd_engine.http_request_header_notification] | The request environment.
environment [Nethttpd_reactor.http_reactive_request] | The Netcgi environment representing the request header, the response header, and the channels to receive the request body and to send the response body.
environment [Netcgi1_compat.Netcgi_types.cgi_activation] |
environment [Netcgi.cgi] | The environment object.
environment [Netcgi_common.cgi] |
error_message [Nethttpd_types.error_response_params] | The error message explaining the detail that went wrong
event_system [Rpc_transport.rpc_multiplex_controller] | Returns the event system
event_system [Netplex_types.container] | The event system the container uses
event_system [Netplex_types.controller] | The event system used by the controller.
event_system [Ftp_client.ftp_client_pi] | The used event system
event_system [Ftp_client.ftp_client] |
event_system [Http_client.pipeline] | Returns the event system
event_system [Uq_engines.multiplex_controller] | Returns the event system
event_system [Uq_engines.engine_mixin] |
event_system [Uq_engines.engine] | Returns the event system the engine is attached to
event_system [Uq_resolver.engine] |
exec [Ftp_client.ftp_client] | Runs the method synchronously.
exec_e [Ftp_client.ftp_client_pi] | Run another command as engine.
exec_e [Ftp_client.ftp_client] | Runs the method asynchronously as engine.
exists_resource [Unixqueue_select.sb_event_system] |
exists_resource [Unixqueue.event_system] |
expect_input [Telnet_client.telnet_session] | Set whether the timeout value is to be applied to the input side of the connection.
expn [Netsmtp.client] | Expand command : `expn list` will try to expand the Mailing list `list`.
export_name [Netgssapi.gss_api] |
export_sec_context [Netgssapi.gss_api] |
F
fd [Nethttpd_kernel.lingering_close] | The file descriptor
fd [Nethttpd_kernel.http_protocol] | Just returns the socket
fetch_subnegotiation [Telnet_client.telnet_session] | This method should be called as follows: If you find a `Telnet_sb` at the beginning of the input queue, remove this command `Queue.take`, and invoke `fetch_subnegotiation`.
field [Netmime.mime_header_ro] |
fields [Netmime.mime_header_ro] |
file_descr [Rpc_transport.rpc_multiplex_controller] | If the transport mechanism is on top of a file descriptor, this is returned here.
file_exists [Netglob.glob_fsys] | Whether the file name is valid and refers to an existing file, or to a symlink pointing to an existing file.
file_is_dir [Netglob.glob_fsys] | Whether the file name is valid and a directory, or a symlink to a directory.
filename [Netfs.local_file] | The filename
filename [Netplex_types.config_file] |
filename [Netcgi1_compat.Netcgi_types.cgi_argument] |
filename [Netcgi.cgi_argument] | The `filename` parameter found in the header of file uploads.
filename [Netcgi_common.cgi_argument] |
finalize [Netmime.mime_body_ro] | After the body has been finalized, it cannot be accessed any longer.
finalize [Netcgi1_compat.Netcgi_types.cgi_activation] |
finalize [Netcgi1_compat.Netcgi_types.cgi_argument] |
finalize [Netcgi.cgi] | This method calls `#finalize` for every CGI argument (including the possible one of PUT) to ensure that all files are deleted.
finalize [Netcgi.cgi_argument] | Arguments stored in temp files must be deleted when the argument is no longer used.
finalize [Netcgi_common.cgi_argument] |
finalize [Netcgi_common.cgi] |
find [Netsys_pollset.pollset] | Checks whether a descriptor is member of the set, and returns its event mask.
find_inactive_connection [Http_client_conncache.connection_cache] | Returns an inactive connection to the passed peer, or raise `Not_found`.
find_my_connections [Http_client_conncache.connection_cache] | Returns all active connections owned by the object
finish [Nethttpd_reactor.http_reactive_request] | This method should be called after the request has been fully processed.
finish_request [Nethttpd_reactor.http_reactive_request] | Reads the rest of the body (if any), and discards that data
fixup_request [Http_client.generic_call] | This method is called just before sending the request.
flavors [Rpc_server.auth_method] | Which credential flavors are handled by this method
float_param [Netplex_types.config_file] |
flush [Netchannels.augment_raw_out_channel] | As in `raw_out_channel`
flush [Netchannels.rec_out_channel] | If there is a write buffer, it will be flushed.
flush [Uq_engines.async_out_channel] | Flushes the channel.
frame_len [Rpc_server.auth_details] |
free_resources [Netplex_types.controller] | Should be called when the controller is finished, in order to free resources again.
front_token [Nethttpd_kernel.http_response] | The first token of the queue, represented as `data_chunk`.
ftp_client [Ftp_fs.ftp_stream_fs] | The FTP client backing this filesystem
ftp_state [Ftp_client.ftp_client_pi] | Returns the current ftp_state
G
gc_when_idle [Netplex_types.socket_service_config] | If set, idle containers run a `Gc.full_major` cycle.
generate_response [Nethttpd_types.http_service_generator] | Third stage of HTTP processing: This method is called when the HTTP request has been completely received, and the response is going to be generated.
get_connection_state [Http_client_conncache.connection_cache] | Returns the state of the file descriptor, or raises `Not_found`
get_engine [Uq_engines.cache_t] | Requests the value.
get_host [Http_client.http_call] | The host name of the content server, extracted from the URI.
get_local_option [Telnet_client.telnet_session] |
get_mic [Netgssapi.gss_api] |
get_opt [Uq_engines.cache_t] | Returns the cached value if available
get_options [Telnet_client.telnet_session] | Get the configuration options.
get_options [Http_client.pipeline] |
get_path [Http_client.http_call] | The path (incl.
get_port [Http_client.http_call] | The port number of the content server, extracted from the URI.
get_reconnect_mode [Http_client.http_call] | Get what to do if the server needs to be reconnected, i.e.
get_redirect_mode [Http_client.http_call] | By default, the redirect mode is `Redirect_if_idem`.
get_remote_option [Telnet_client.telnet_session] |
get_req_body [Http_client.http_call] | What has been sent as body in the (last) request.
get_req_header [Http_client.http_call] | Deprecated.
get_req_method [Http_client.http_call] | Get the name of the request method.
get_resp_body [Http_client.http_call] | Deprecated.
get_resp_header [Http_client.http_call] | Deprecated.
get_uri [Http_client.http_call] | the full URI of this message: http://server:port/path.
getpeername [Rpc_transport.rpc_multiplex_controller] | The address of the peer's socket.
getsockname [Rpc_transport.rpc_multiplex_controller] | The address of this socket
global_exception_handler [Netplex_types.processor_hooks] | This method is called when an uncaught exception would otherwise terminate the container.
greedy_accepts [Netplex_workload.dynamic_workload_config] | Whether greedy accepts are permitted
group [Uq_engines.poll_engine] | Returns the group the engine is member of
H
has_req_body [Http_client.http_call] | Whether the method allows to send a request body
has_resp_body [Http_client.http_call] | Whether the method allows to reply with a body.
hello [Netplex_types.workload_manager] | Called by the controller when the service is added
helo [Netsmtp.client] | Sends an HELLO command to the server.
help [Netsmtp.client] | Performs the Help command.
home_directory [Netglob.user_info] | Returns the home directory of the passed user, or the home directory of the current user for the empty string.
host_by_name [Uq_resolver.resolver] | Look up the passed host name up.
I
id [Netsys_oothr.thread] | In a multi-threaded program: Returns the thread ID.
id [Netmcore.compute_resource] | an ID of the resource that is valid in the whole Netplex system
import_name [Netgssapi.gss_api] |
import_sec_context [Netgssapi.gss_api] |
inactivate [Rpc_transport.rpc_multiplex_controller] | Inactivates the connection immediately, and releases any resources the controller is responsible for (e.g.
inactivate [Uq_engines.multiplex_controller] | Inactivates the connection immediately, and releases any resources the controller is responsible for (e.g.
inactivate_no_close [Uq_ssl.ssl_multiplex_controller] | Inactivates the controller by deleting all event handlers.
inactivity_timeout [Netplex_workload.dynamic_workload_config] | After this number of seconds a free thread can be terminated
indicate_mechs [Netgssapi.gss_api] |
info_string [Netplex_types.par_thread] | Outputs the process or thread ID
init [Netplex_types.parallelizer] | Initializes the main process for usage with this parallelizer.
init_sec_context [Netgssapi.gss_api] | On the first call, pass `~context:None`.
initial_argument [Netcgi1_compat.Netcgi_types.cgi_activation] |
initial_argument_value [Netcgi1_compat.Netcgi_types.cgi_activation] |
initial_arguments [Netcgi1_compat.Netcgi_types.cgi_activation] |
initial_multiple_argument [Netcgi1_compat.Netcgi_types.cgi_activation] |
input [Netchannels.augment_raw_in_channel] | As in `raw_in_channel`
input [Netchannels.rec_in_channel] | Reads octets from the channel and puts them into the string.
input [Uq_engines.async_in_channel] | `input s k n`: Reads channel data into the substring of `s` beginning at index `k` with length `n`.
input_body_size [Nethttpd_types.request_info] | The size of the input body.
input_body_size [Nethttpd_types.v_extended_environment] | so far known, or 0L
input_byte [Netchannels.compl_in_channel] | Reads exactly one octet from the channel and returns its code, or raises `End_of_file`
input_ch [Netcgi1_compat.Netcgi_env.cgi_environment] | Not the user business.
input_ch_async [Nethttpd_engine.extended_async_environment] | This is the `input_ch` channel taken as asynchonous channel.
input_channel [Nethttpd_types.v_extended_environment] | The input channel for reading the body of the request
input_char [Netchannels.compl_in_channel] | Reads exactly one character from the channel, or raises `End_of_file`
input_content_length [Netcgi1_compat.Netcgi_env.cgi_environment] |
input_content_length [Netcgi.cgi_environment] | Returns the `"Content-length"` request header field.
input_content_length [Netcgi_common.cgi_environment] |
input_content_type [Netcgi1_compat.Netcgi_env.cgi_environment] | Type now is `unit -> string * (string * Mimestring.s_param) list` to be coherent with `Netmime.mime_header_ro`.
input_content_type [Netcgi.cgi_environment] | Returns the parsed `"Content-type"` request header field.
input_content_type [Netcgi_common.cgi_environment] |
input_content_type_string [Netcgi1_compat.Netcgi_env.cgi_environment] |
input_content_type_string [Netcgi.cgi_environment] | Returns the `"Content-type"` request header field as a plain string or `""` if it is not set.
input_content_type_string [Netcgi_common.cgi_environment] |
input_eor [Ftp_data_endpoint.in_record_channel] | Skips over the remaining data of the current record and the record boundary to the next record.
input_header [Nethttpd_types.request_info] | The request header.
input_header [Netcgi1_compat.Netcgi_env.cgi_environment] |
input_header [Netcgi.cgi_environment] | The whole HTTP header.
input_header [Netcgi_common.cgi_environment] | For special header structures, just override this method.
input_header_field [Netcgi1_compat.Netcgi_env.cgi_environment] |
input_header_field [Netcgi.cgi_environment] | `#input_header_field ?default f` returns the value of a field `f` of the HTTP request header.
input_header_field [Netcgi_common.cgi_environment] |
input_header_fields [Netcgi1_compat.Netcgi_env.cgi_environment] |
input_header_fields [Netcgi.cgi_environment] | Returns the input header as (name,value) pairs.
input_header_fields [Netcgi_common.cgi_environment] |
input_line [Netchannels.compl_in_channel] | Reads the next line from the channel.
input_queue [Telnet_client.telnet_session] | The queue of commands received from the remote side.
input_state [Netcgi1_compat.Netcgi_env.cgi_environment] | Not the user business.
input_timeout_class [Nethttpd_kernel.http_protocol] | Suggests the calculation of a timeout value for input: ``Normal`: The normal timeout value applies, ``Next_message`: The timeout value applies while waiting for the next message, ``None`: The connection is output-driven, no input timeout value
inquire_context [Netgssapi.gss_api] |
inquire_cred [Netgssapi.gss_api] |
inquire_cred_by_mech [Netgssapi.gss_api] |
inquire_key [Http_client.key_handler] | The method is called when a new session must be authenticated.
inquire_mechs_for_name [Netgssapi.gss_api] |
inquire_names_for_mech [Netgssapi.gss_api] |
int_param [Netplex_types.config_file] |
invalidate [Http_client.auth_session] | The session is notified that authentication failed.
invalidate [Uq_engines.cache_t] | Invalidates the cache - if a value exists in the cache, it is removed.
invalidate_key [Http_client.key_handler] | The handler is notified that authentication failed for this key
is_empty [Ftp_client.ftp_client_pi] | Whether the queue is empty
is_idempotent [Http_client.http_call] | Whether the method is to be considered as idempotent ( = repeated invocations have the same result and no side effect).
is_proxy_allowed [Http_client.http_call] | Deprecated.
is_running [Unixqueue_select.sb_event_system] |
is_running [Unixqueue.event_system] |
is_served [Http_client.http_call] | `true` if request/response cycle(s) have been finished, i.e.
iter [Uq_lwt.lwt_backend] |
J
job [Shell_uq.job_handler_engine_type] | Returns the called job
job [Shell_sys.job_handler_engine_type] | Returns the called job
job_instance [Shell_uq.job_handler_engine_type] | Returns the job instance
job_instance [Shell_sys.job_handler_engine_type] | Returns the job instance
join [Netsys_oothr.thread] | In a multi-threaded program: Suspends the calling thread until this thread terminates.
K
keys [Http_client.key_ring] | List of all known keys
L
last_ftp_state [Ftp_fs.ftp_stream_fs] | The last state of the last operation, or `Not_found`
last_response_header [Http_fs.http_stream_fs] | Returns the header of the HTTP response of the last operation.
last_stderr [Shell_fs.shell_stream_fs] | The stderr output of the last operation
length [Xdr_mstring.mstring] | The length of the managed string
lingering [Nethttpd_kernel.lingering_close] | Whether the socket is still lingering
list [Netpop.client] | Returns the scan listing for an optional message number or for all messages in the current mailbox.
listen [Uq_engines.server_endpoint_listener] | Instantiates an engine that listens for connections on the socket given by the `listen_address` argument.
listen_options [Rpc_server.socket_config] |
local_receiver [Ftp_data_endpoint.ftp_data_receiver] | The local receiver.
local_sender [Ftp_data_endpoint.ftp_data_sender] | The local sender.
lock [Netsys_oothr.mutex] | In a multi-threaded program: Suspends the calling thread until the mutex is locked.
log [Netplex_types.container] | Sends a log message to the controller.
log [Netplex_types.logger] | Same as `log_subch` when `subchannel` is set to the empty string.
log_access [Nethttpd_reactor.internal_environment] |
log_component [Netplex_log.generic_config] |
log_directory [Netplex_log.multi_file_config] |
log_error [Netcgi1_compat.Netcgi_env.cgi_environment] |
log_error [Netcgi.cgi_environment] | `#log_error msg` appends `msg` to the webserver log.
log_error [Netcgi_common.cgi_environment] | You may want to override this with your custom logging method.
log_facility [Netplex_log.syslog_config] |
log_files [Netplex_log.multi_file_config] | Triples `(component, subchannel, max_level, file, format)` .
log_format [Netplex_log.generic_config] |
log_identifier [Netplex_log.syslog_config] |
log_max_level [Netplex_log.generic_config] |
log_props [Nethttpd_types.v_extended_environment] | Remember this version of `cgi_properties` as the one sent to the `config_log_access` function
log_subch [Netplex_types.container] | Sends a log message to the controller.
log_subch [Netplex_types.logger] | Receive a log `message` of `level` from `component`.
log_subchannel [Netplex_log.generic_config] |
logger [Netplex_types.controller] | The logger
lookup [Netplex_types.container] | `lookup service_name protocol_name` tries to find a Unix domain socket for the service and returns it.
lookup_container_sockets [Netplex_types.container] | `lookup_container_sockets service_name protocol_name`: returns the Unix Domain paths of all container sockets for this service and protocol.
lstn_backlog [Netplex_types.protocol] | The backlog (argument of Unix.listen)
lstn_reuseaddr [Netplex_types.protocol] | Whether to reuse ports immediately
M
mail [Netsmtp.client] | Performs a MAIL FROM command.
mailboxes [Netaddress.group] | The member mailboxes
max_free_job_capacity [Netplex_workload.dynamic_workload_config] | If more job capacity is available than this number, threads are terminated.
max_jobs_per_thread [Netplex_workload.dynamic_workload_config] | How many jobs every thread can execute concurrently until it is considered as fully loaded.
max_level [Netplex_types.controller_config] | Return the maximum global log level
max_response_body_length [Http_client.http_call] | Returns the current maximum length (initially `Int64.max_int`)
max_threads [Netplex_workload.dynamic_workload_config] | The manager does not start more threads than this number
mem_supported [Uq_engines.multiplex_controller] | Whether `start_mem_reading` and `start_mem_writing` are possible
message [Rpc_server.auth_details] |
min_free_job_capacity [Netplex_workload.dynamic_workload_config] | The manager starts as many threads as required to ensure that this number of jobs can be executed.
mkdir [Netfs.stream_fs] | Creates a new directory.
mkdir [Http_fs.http_stream_fs] |
mlst_enabled_facts [Ftp_client.ftp_client_pi] | The enabled facts for ``MLST` and ``MLSD`
mlst_facts [Ftp_client.ftp_client_pi] | All available facts for ``MLST` and ``MLSD`
multiple_argument [Netcgi1_compat.Netcgi_types.cgi_activation] |
multiple_argument [Netcgi.cgi] | `#multiple_argument name` returns all the values of the argument named `name`.
multiple_argument [Netcgi_common.cgi] |
multiple_connections [Uq_engines.server_endpoint_acceptor] | Whether it is possible to accept multiple connections
multiple_field [Netmime.mime_header_ro] | The current fields of the header.
multiple_input_header_field [Netcgi1_compat.Netcgi_env.cgi_environment] |
multiple_input_header_field [Netcgi.cgi_environment] | Returns the values of all fields with the passed name of the request header.
multiple_input_header_field [Netcgi_common.cgi_environment] |
multiple_output_header_field [Netcgi1_compat.Netcgi_env.cgi_environment] |
multiple_output_header_field [Netcgi.cgi_environment] | Returns the values of all fields with the passed name of the repsonse header.
multiple_output_header_field [Netcgi_common.cgi_environment] |
multiplexing [Rpc_server.socket_config] |
multiplexing [Rpc_client.socket_config] |
N
n_connections [Netplex_types.container] | The current number of connections
n_total [Netplex_types.container] | The sum of all connections so far
name [Rpc_server.auth_method] | The name of the authentication method
name [Rpc_client.auth_method] | The name of this method, used for errors etc.
name [Netsys_posix.post_fork_handler] |
name [Netaddress.group] | The name of the group
name [Netaddress.mailbox] | The name of the mailbox.
name [Netplex_types.logger_factory] |
name [Netplex_types.workload_manager_factory] |
name [Netplex_types.processor_factory] |
name [Netplex_types.ctrl_message_receiver] | The name of this receiver
name [Netplex_types.protocol] | The protocol name is an arbitrary string identifying groups of sockets serving the same protocol for a `socket_service`.
name [Netplex_types.socket_service_config] | The proposed name for the `socket_service`
name [Netplex_types.socket_service] | The name of the `socket_service` is used to identify the service in the whole netplex process cluster.
name [Nethttpd_types.http_service] | The name of the type of the service provider
name [Http_client.basic_auth_method] |
name [Netcgi1_compat.Netcgi_types.cgi_argument] |
name [Netcgi.cgi_argument] | The name of the argument.
name [Netcgi_common.cgi_argument] |
need_ip6 [Ftp_client.ftp_client_pi] | Whether ``EPSV` or ``EPRT` are required instead of ``PASV` and ``PORT`, respectively.
need_linger [Nethttpd_kernel.http_protocol] | Returns `true` when a lingering close operation is needed to reliably shut down the socket.
new_group [Unixqueue_select.sb_event_system] |
new_group [Unixqueue.event_system] |
new_session [Rpc_client.auth_method] | Request a new session.
new_wait_id [Unixqueue_select.sb_event_system] |
new_wait_id [Unixqueue.event_system] |
next_credentials [Rpc_client.auth_session] | Called with `client prog proc xid`.
next_request [Nethttpd_reactor.http_reactor] | Tries to read the next request.
no_credential [Netgssapi.gss_api] | A substitute credential for `GSS_C_NO_CREDENTIAL`
no_name [Netgssapi.gss_api] | A substitute name for `GSS_C_NO_NAME`
no_proxy [Http_client.http_call] | Same as `set_proxy_enabled false`
nominal_dot_dot [Netfs.stream_fs] | Whether the effect of `..` can be obtained by stripping off the last path component, i.e.
nominal_dot_dot [Http_fs.http_stream_fs] |
non_blocking_connect [Rpc_client.socket_config] | `non_blocking_connect`: Whether the remote service is connected in the background.
noop [Netsmtp.client] | NOOP : does nothing, keeps the connection alive.
noop [Netpop.client] | Pings the server to keep the session alive.
notify [Uq_engines.engine_mixin] |
number_of_open_connections [Http_client.pipeline] | Returns the number of connections which are open at the same time and currently being used by this object (i.e.
number_of_open_messages [Http_client.pipeline] | Returns the number of messages which are still in the pipeline.
O
offer_local_option [Telnet_client.telnet_session] |
on_add [Netplex_types.socket_service] | Get some runtime configuration aspects from this controller.
open_value_rd [Netmime.mime_body_ro] | Opens the value for reading.
open_value_rd [Netcgi1_compat.Netcgi_types.cgi_argument] |
open_value_rd [Netcgi.cgi_argument] | Open the contents of the value as an input channel.
open_value_rd [Netcgi_common.cgi_argument] |
open_value_wr [Netcgi1_compat.Netcgi_types.cgi_argument] | See `#set_value`.
open_value_wr [Netmime.mime_body] | Opens the value for writing.
open_value_wr [Netcgi.rw_cgi_argument] |
open_value_wr [Netcgi_common.rw_cgi_argument] |
option_negotiation_is_over [Telnet_client.telnet_session] |
out_channel [Netcgi.cgi] | The output channel to which the generated content is intended to be written.
out_channel [Netcgi.cgi_environment] | The "raw" output channel.
out_channel [Netcgi_common.cgi] |
out_channel [Netcgi_common.cgi_environment] |
output [Netchannels.augment_raw_out_channel] | As in `raw_out_channel`
output [Netchannels.rec_out_channel] | Takes octets from the string and writes them into the channel.
output [Netcgi1_compat.Netcgi_types.cgi_activation] |
output [Netcgi.cgi] |
output [Netcgi_common.cgi] |
output [Netcgi_modtpl.template] | `output cgi` outputs the template to the CGI session `cgi`.
output [Uq_engines.async_out_channel] | `output s k n`: Writes the substring of `s` beginning at index `k` with length `n` into the channel.
output_body_size [Nethttpd_types.full_info] | The size of the output body.
output_buffer [Netchannels.compl_out_channel] | Writes exactly the contents of the buffer
output_byte [Netchannels.compl_out_channel] | Writes exactly one byte passed as integer code
output_ch [Netcgi1_compat.Netcgi_env.cgi_environment] |
output_ch [Netcgi.cgi_environment] |
output_ch [Netcgi_common.cgi_environment] |
output_ch_async [Nethttpd_engine.extended_async_environment] | This is the `output_ch` channel taken as asynchronous channel.
output_channel [Netchannels.compl_out_channel] | Writes the contents of an `in_obj_channel` until the end of the input channel is reached.
output_char [Netchannels.compl_out_channel] | Writes exactly one character
output_eor [Ftp_data_endpoint.out_record_channel] | Finishes the current record.
output_header [Nethttpd_types.full_info] | The response header
output_header [Netcgi1_compat.Netcgi_env.cgi_environment] |
output_header [Netcgi.cgi_environment] | The whole HTTP response header
output_header [Netcgi_common.cgi_environment] | For special header structures, override this method and maybe `#send_output_header`.
output_header_field [Netcgi1_compat.Netcgi_env.cgi_environment] |
output_header_field [Netcgi.cgi_environment] | Returns the value of a field of the response header.
output_header_field [Netcgi_common.cgi_environment] |
output_header_fields [Netcgi1_compat.Netcgi_env.cgi_environment] |
output_header_fields [Netcgi.cgi_environment] | Returns the output header as (name,value) pairs.
output_header_fields [Netcgi_common.cgi_environment] |
output_queue [Telnet_client.telnet_session] | The queue of commands to send to the remote side.
output_state [Nethttpd_types.v_extended_environment] | Reflects the state of the output generation: ``Start`: Nothing is generated yet, ``Sending`: Output is already being sent, ``End`: The response (for a single request) has been fully sent
output_state [Nethttpd_types.extended_environment] |
output_state [Netcgi1_compat.Netcgi_env.cgi_environment] | Not the user business.
output_string [Netchannels.compl_out_channel] | Writes exactly the passed string
owned_container_sockets [Netplex_types.container] | List of pairs `(protocol_name, path)` of all container sockets of this container
P
parallelizer [Netplex_types.par_thread] | Returns the parallelizer that created this thread.
pass [Netpop.client] | Authenticates a user with the plain-text password `pass`.
password [Http_client.key] | The password in cleartext
password_of_user_name [Netmech_scram_gssapi.client_key_ring] | Returns the cleartext password for a user name, or raises `Not_found` if the user is unknown
path_encoding [Netglob.glob_fsys] | Paths of filesystems may be encoded
path_encoding [Netglob.user_info] | Paths of filesystems may be encoded
path_encoding [Netfs.stream_fs] | The encoding must be ASCII-compatible (`Netconversion.is_ascii_compatible`).
path_encoding [Http_fs.http_stream_fs] |
path_exclusions [Netfs.stream_fs] | Code points that must not occur in path components between slashes.
path_exclusions [Http_fs.http_stream_fs] |
peek [Rpc_server.auth_method] | If available, this function is called for every accepted connection.
peek_recv [Nethttpd_kernel.http_protocol] | Peeks the first token, but leaves it in the queue.
peer_user_name [Rpc_transport.rpc_multiplex_controller] | If the transport mechanism provides a way to authenticate the peer, it can return the name here.
pi [Ftp_client.ftp_client] | The curerent protocol interpreter.
pipeline [Http_fs.http_stream_fs] | The HTTP pipeline backing this file system
pipeline_len [Nethttpd_kernel.http_protocol] | Returns the number of unanswered requests = Number of received ``Req_end` tokens minus number of responses in state ``Processed`.
pos_in [Netchannels.augment_raw_in_channel] | As in `raw_in_channel`
pos_in [Netchannels.raw_in_channel] | Returns the current channel position.
pos_in [Uq_engines.async_in_channel] | Returns the number of characters read from the channel
pos_out [Netchannels.augment_raw_out_channel] | As in `raw_out_channel`
pos_out [Netchannels.raw_out_channel] | Returns the current channel position.
pos_out [Uq_engines.async_out_channel] | Returns the number of characters output into the channel
post_add_hook [Netplex_types.processor_hooks] | A user-supplied function that is called after the service has been added to the controller
post_finish_hook [Netplex_types.processor_hooks] | A user-supplied function that is called after the container is terminated.
post_rm_hook [Netplex_types.processor_hooks] | A user-supplied function that is called after the service has been removed from the controller
post_start_hook [Netplex_types.processor_hooks] | A user-supplied function that is called after the container is created and started, but before the first service request arrives.
pre_finish_hook [Netplex_types.processor_hooks] | A user-supplied function that is called just before the container is terminated.
pre_start_hook [Netplex_types.processor_hooks] | A user-supplied function that is called before the container is created and started.
preferred [Xdr_mstring.mstring] | Whether `as_memory` or `as_string` is cheaper
print [Netplex_types.config_file] |
print [Nethttpd_types.http_service] | Outputs the definition term to a formatter
prioritized [Uq_engines.prioritizer_t] | `let pe = prioritized f p`: Queues up `f` on priority level `p`.
private_api [Http_client.http_call] |
procedure [Rpc_server.auth_details] |
process [Netplex_kit.v_processor] |
process [Netplex_types.processor] | A user-supplied function that is called when a new socket connection is established.
process_body [Nethttpd_types.http_service_receiver] | Second stage of HTTP processing: This method is called when the body is expected to be arriving.
process_context_token [Netgssapi.gss_api] |
process_header [Nethttpd_types.http_service] | First stage of HTTP processing: This method is called when the HTTP header has been received.
process_option_command [Telnet_client.telnet_session] |
processor [Netplex_types.socket_service] | A user-supplied object to process incoming connections
program [Rpc_server.auth_details] |
program [Netplex_types.plugin] | The RPC program structure on which the messaging bases.
protocol [Rpc_transport.rpc_multiplex_controller] | The protocol encapsulation
protocol [Nethttpd_kernel.http_response] | The HTTP version of the response.
protocol [Netcgi1_compat.Netcgi_env.cgi_environment] |
protocol [Netcgi.cgi_environment] | The server protocol in a decoded form.
protocol [Netcgi_common.cgi_environment] |
protocols [Netplex_types.socket_service_config] | This list describes the sockets to create in detail
provider [Netgssapi.gss_api] | A string name identifying the provider
proxy_enabled [Http_client.http_call] | Returns the proxy mode
proxy_type [Http_client.pipeline] | `proxy_type url` returns `Some pt` if a proxy would be used for this `url`, and `None` if a direct connection would be made.
proxy_type_of_call [Http_client.pipeline] | Same for an already created call object
proxy_use_connect [Http_client.http_call] | Whether to use the CONNECT method if the connection is made via a web proxy.
ptype [Netplex_types.netplex_config] |
ptype [Netplex_types.parallelizer] |
ptype [Netplex_types.par_thread] |
ptype [Netplex_types.container] | The parallelization type actually used for this container
ptype [Netplex_types.controller] | The actually effective parallelization type
put [Uq_engines.cache_t] | Puts a value immediately into the cache.
Q
queue_events [Unixqueue_select.sb_event_system] |
quit [Netsmtp.client] | Requests the server to end this session.
quit [Netpop.client] | Requests the server to end this session.
R
rcpt [Netsmtp.client] | Performs a RCPT TO command.
read [Netfs.stream_fs] | `read flags filename`: Opens the file `filename` for reading, and returns the input stream.
read [Http_fs.http_stream_fs] | Additional flag: ``Header h`: Set these headers in the submitted GET request
read_dir [Netglob.glob_fsys] | Returns the file names contained in the directory, without path.
read_eof [Rpc_transport.rpc_multiplex_controller] | Whether the EOF marker has been read
read_eof [Uq_engines.multiplex_controller] | Whether the EOF marker has been read
read_file [Netfs.stream_fs] | `read_file flags filename`: Opens the file `filename` for reading, and returns the contents as a `local_file`.
read_file [Http_fs.http_stream_fs] | Additional flag: ``Header h`: Set these headers in the submitted GET request
readdir [Netfs.stream_fs] | Reads the contents of a directory.
readdir [Http_fs.http_stream_fs] |
reading [Rpc_transport.rpc_multiplex_controller] | True iff there is a reader
reading [Uq_engines.multiplex_controller] | True iff there is a reader
readlink [Netfs.stream_fs] | Reads the target of a symlink
readlink [Http_fs.http_stream_fs] |
really_input [Netchannels.compl_in_channel] | Reads exactly as many octets from the channel as the second `int` argument specifies.
really_output [Netchannels.compl_out_channel] | Writes exactly as many octets to the channel as the second `int` argument specifies.
realm [Http_client.key] | The realm
receive [Rpc_client.auth_protocol] | Receive a token for the `xid` announced in `state`.
receive [Nethttpd_kernel.http_protocol] | Returns the first `req_token` from the receive queue.
receive_admin_message [Netplex_types.processor_hooks] | This function is called when a broadcast admin message is received.
receive_admin_message [Netplex_types.ctrl_message_receiver] | This function is called when a broadcast admin message is received.
receive_message [Netplex_types.processor_hooks] | This function is called when a broadcast message is received.
receive_message [Netplex_types.ctrl_message_receiver] | This function is called when a broadcast message is received.
received_from [Uq_engines.datagram_multiplex_controller] | Returns the socket address of the last received datagram.
recommended_jobs_per_thread [Netplex_workload.dynamic_workload_config] | The number of jobs every thread can execute with normal service quality.
recv_queue_byte_size [Nethttpd_kernel.http_protocol] | Returns the (estimated) size of the input queue in bytes
recv_queue_len [Nethttpd_kernel.http_protocol] | Returns the length of the receive queue (number of tokens)
recvfrom [Uq_engines.wrapped_datagram_socket] | Receive data from the (unconnected) socket.
register_lever [Netplex_types.controller] | `let id = register_lever f`: It is possible to register a function `f` in the controller, and run it over the internal RPC interface from any container.
register_readable [Uq_lwt.lwt_backend] |
register_timer [Uq_lwt.lwt_backend] |
register_writable [Uq_lwt.lwt_backend] |
reject_body [Nethttpd_reactor.http_reactive_request] | Call this method to unlock the body channels.
release [Netmcore.compute_resource] | Notify the manager that the resource is not used any longer by this process.
remote_socket_addr [Nethttpd_types.request_info] | The socket address of the client.
remote_socket_addr [Nethttpd_types.v_extended_environment] | These are always the physical IP addresses and ports of the two endpoints of the current connection.
remote_socket_addr [Nethttpd_types.extended_environment] |
remove [Netsys_pollset.pollset] | Remove a descriptor from the set (if it is member)
remove [Netfs.stream_fs] | Removes the file or symlink.
remove [Http_fs.http_stream_fs] |
remove_resource [Unixqueue_select.sb_event_system] |
remove_resource [Unixqueue.event_system] |
rename [Netfs.stream_fs] | Renames the file.
rename [Http_fs.http_stream_fs] |
reopen [Netplex_types.logger] | Reopen the log files
repr [Netsys_oothr.condition] | May be used internally be the implementation
repr [Netsys_oothr.mutex] | May be used internally be the implementation
repr [Netsys_oothr.thread] | May be used internally be the implementation
repr [Netmcore.compute_resource] | the resource detail
representation [Netcgi1_compat.Netcgi_types.cgi_argument] |
representation [Netcgi.cgi_argument] | The representation of the argument.
representation [Netcgi_common.cgi_argument] |
req_method [Nethttpd_reactor.internal_environment] |
req_state [Nethttpd_engine.http_request_notification] | Returns the request processing state which is ``Received_request` at the moment when this notification is delivered.
req_state [Nethttpd_engine.http_request_header_notification] | Returns the request processing state which is ``Received_header` at the moment when this notification is delivered.
request [Netcgi_apache.cgi] | The underlying apache request structure.
request_body [Http_client.http_call] | The whole body of the request.
request_body_rejected [Nethttpd_types.v_extended_environment] | so far known, or false
request_body_rejected [Nethttpd_types.full_info] | Whether the request body was rejected
request_header [Http_client.http_call] | The whole header of the request.
request_method [Nethttpd_types.request_info] | The method like `GET`.
request_method [Http_client.http_call] | The HTTP method as string
request_method [Netcgi1_compat.Netcgi_types.cgi_activation] |
request_method [Netcgi.cgi] | The HTTP method used to make the request.
request_method [Netcgi_common.cgi] |
request_notification [Ftp_client.ftp_client_pi] | as in `Uq_engines.engine`
request_notification [Uq_engines.async_in_channel] | After the notification has been requested, the passed function is be called whenever `can_input` changes its value (or might change its value).
request_notification [Uq_engines.async_out_channel] | After the notification has been requested, the passed function is be called whenever `can_output` changes its value (or might change its value).
request_notification [Uq_engines.engine_mixin] |
request_notification [Uq_engines.engine] | Requests notification about state changes.
request_notification [Uq_resolver.engine] |
request_remote_option [Telnet_client.telnet_session] |
request_uri [Nethttpd_types.request_info] | The URI of the client request.
request_uri [Http_client.http_call] | The request URI as string.
reset [Ftp_client.ftp_client] | Aborts all current activities if any, and re-initializes the client
reset [Telnet_client.telnet_session] | Closes the connection immediately and empties all queues.
reset [Http_client.pipeline] | Empties the pipeline and inactivates any open connection.
reset_counters [Http_client.pipeline] |
reset_local_option [Telnet_client.telnet_session] |
reset_remote_option [Telnet_client.telnet_session] |
resolve_parameter [Netplex_types.config_file] |
resolve_section [Netplex_types.config_file] |
resp_queue_len [Nethttpd_kernel.http_protocol] | Returns the length of the internal response queue (number of `http_response` objects that have not yet fully processed)
response [Nethttpd_reactor.internal_environment] |
response_body [Http_client.http_call] | The whole body of the response.
response_body_storage [Http_client.http_call] | How to create the response body.
response_header [Http_client.http_call] | The whole header of the response.
response_protocol [Http_client.http_call] | The HTTP version indicated in the response
response_status [Http_client.http_call] | The decoded code.
response_status_code [Nethttpd_types.error_response_params] | The HTTP status code to response
response_status_code [Nethttpd_types.full_info] | The HTTP status code to response
response_status_code [Http_client.http_call] | The three-digit status code
response_status_text [Http_client.http_call] | The text transmitted along with the code
restart [Netplex_types.socket_controller] | Restarts the containers for this socket service only
restart [Netplex_types.controller] | Initiates a restart of all containers: All threads/processes are terminated and replaced by newly initialized ones.
restart [Uq_engines.poll_engine] | Activate the engine again when it is already in a final state.
restrict_parameters [Netplex_types.config_file] |
restrict_subsections [Netplex_types.config_file] |
retr [Netpop.client] | Retrieves a message from the server.
rmdir [Netfs.stream_fs] | Removes an empty directory
rmdir [Http_fs.http_stream_fs] |
ro [Netmime.mime_header] | whether the header is read-only or not
ro [Netcgi1_compat.Netcgi_types.cgi_argument] | Irrelevant: there are no methods to mutate an argument.
ro [Netmime.mime_body] | whether this body is read-only or not
ro [Netcgi.rw_cgi_argument] |
ro [Netcgi_common.rw_cgi_argument] |
role [Netcgi_fcgi.cgi] | A FastCGI application can fulfill each of the following three roles:
rollback_work [Netchannels.trans_out_obj_channel] | Empties the transaction buffer
root_addr [Netplex_types.config_file] |
root_name [Netplex_types.config_file] |
route [Netaddress.mailbox] | The route to the mailbox
rset [Netsmtp.client] | Reset the current transaction
rset [Netpop.client] | Unmarks any messages that have previously been marked as deleted.
run [Netsys_posix.post_fork_handler] |
run [Ftp_client.ftp_client_pi] | Starts the event system; same as `Unixqueue.run`
run [Ftp_client.ftp_client] | Starts the event system; same as `Unixqueue.run`
run [Telnet_client.telnet_session] | Run the event system
run [Http_client.pipeline] | Runs through the requests in the pipeline.
run [Unixqueue_select.sb_event_system] |
run [Unixqueue.event_system] |
S
same_call [Http_client.http_call] | This method returns a new object that will perform the same call as this object (this function is called "reload" in browsers).
schedule_accept_body [Nethttpd_engine.http_request_header_notification] | Schedules that the request body is accepted.
schedule_finish [Nethttpd_engine.http_request_notification] | Schedules that the request is finished.
schedule_finish [Nethttpd_engine.http_request_header_notification] | Schedules that the request is finished.
schedule_reject_body [Nethttpd_engine.http_request_header_notification] | Schedules that the request body is rejected.
scram_credentials [Netmech_scram_gssapi.server_key_verifier] | Returns the triple
     (salted_password, salt, iteration_count)
for a user, or raises `Not_found`.
self [Netsys_oothr.mtprovider] | In a multi-threaded program: Returns the currently running thread.
send [Nethttpd_kernel.http_response] | Add token to the end of the send queue
send_abort [Ftp_client.ftp_client_pi] | Sends immediately an `ABOR` command, even when a data transfer is in progress.
send_admin_message [Netplex_types.controller] | `send_message destination msgname msgargs`: Sends an admin message to `destination`.
send_file [Nethttpd_types.v_extended_environment] | Sends the output header with a file as body.
send_message [Netplex_types.container] | `send_message service_pattern msg_name msg_arguments`: Sends a message to all services and message receivers matching `service_pattern`.
send_message [Netplex_types.controller] | `send_message destination msgname msgargs`: Sends a message to `destination`.
send_output_header [Netcgi1_compat.Netcgi_env.cgi_environment] |
send_output_header [Netcgi.cgi_environment] | This method will encode and send the output header to the output channel.
send_output_header [Netcgi_common.cgi_environment] |
send_queue_empty [Nethttpd_kernel.http_response] | Return whether the send queue is empty.
send_synch [Telnet_client.telnet_session] | At the next output oppurtunity, a Synch sequence is sent to the remote peer.
send_to [Uq_engines.datagram_multiplex_controller] | Sets the socket address of the next datagram to send.
sendto [Uq_engines.wrapped_datagram_socket] | Send data over the (unconnected) socket
serialized [Uq_engines.serializer_t] | `let se = serialized f`: Waits until all the previous engines reach a final state, and then runs `e = f esys`.
server_accepts [Rpc_client.auth_session] | Called if the server accepts the credentials.
server_addr [Rpc_server.auth_details] |
server_address [Uq_engines.server_endpoint_acceptor] | The contact address under which the clients can establish new connections with this server.
server_rejects [Rpc_client.auth_session] | Called if the server rejects the credentials or the verifier (Auth_xxx).
server_socket_addr [Nethttpd_types.request_info] | The socket address of this server.
server_socket_addr [Nethttpd_types.v_extended_environment] |
server_socket_addr [Nethttpd_types.extended_environment] |
services [Netplex_types.netplex_config] |
services [Netplex_types.controller] | The list of controlled services
set [Netcgi_modtpl.template] | Set a variable in the template.
set_accept_encoding [Http_client.http_call] | Sets the `Accept-Encoding` field in the request header, and includes all decompression algorithms registered in `Netcompression`.
set_arguments [Netcgi1_compat.Netcgi_types.cgi_activation] |
set_callback [Nethttpd_kernel.http_response] | The function will be called when either `set_state` changes the state, or when the send queue becomes empty.
set_callback [Telnet_client.telnet_session] | Sets the callback function.
set_channel_binding [Http_client.http_call] | Sets the channel binding.
set_chunked_request [Http_client.http_call] | Configures that the request is transmitted using chunked encoding.
set_connection [Telnet_client.telnet_session] | Sets the host name and the port of the remote server to contact.
set_connection_cache [Http_client.pipeline] | Set the connection cache.
set_connection_state [Http_client_conncache.connection_cache] | Sets the state of the file descriptor.
set_event_system [Telnet_client.telnet_session] | Sets the event system to use.
set_event_system [Http_client.pipeline] | Sets the event system.
set_exception_handler [Telnet_client.telnet_session] | Sets the exception handler.
set_expect_handshake [Http_client.http_call] | Configures that a handshake is done before sending the request body.
set_fields [Netmime.mime_header] |
set_header [Netcgi1_compat.Netcgi_types.cgi_activation] | Added `?content_length` for user convenience and deprecated `?set_cookie` in favor of `?set_cookies` for coherence e.g.
set_header [Netcgi.cgi] | Sets the header (removing any previous one).
set_header [Netcgi_common.cgi] |
set_input_state [Netcgi1_compat.Netcgi_env.cgi_environment] | Not the user business.
set_max_level [Netplex_types.controller_config] | Set the maximum global log level
set_max_response_body_length [Http_client.http_call] | Sets a new maximum length.
set_multiple_output_header_field [Netcgi1_compat.Netcgi_env.cgi_environment] |
set_multiple_output_header_field [Netcgi.cgi_environment] | Sets multiple values of a field of the response header.
set_multiple_output_header_field [Netcgi_common.cgi_environment] |
set_options [Telnet_client.telnet_session] | Set the configuration options.
set_options [Http_client.pipeline] | Get/Set the available options for the HTTP engine.
set_output_header_field [Netcgi1_compat.Netcgi_env.cgi_environment] |
set_output_header_field [Netcgi.cgi_environment] | Sets the value of a field of the response header.
set_output_header_field [Netcgi_common.cgi_environment] |
set_output_header_fields [Netcgi1_compat.Netcgi_env.cgi_environment] |
set_output_header_fields [Netcgi.cgi_environment] | Sets the complete response header at once.
set_output_header_fields [Netcgi_common.cgi_environment] |
set_output_state [Netcgi1_compat.Netcgi_env.cgi_environment] | Not the user business.
set_proxy [Http_client.pipeline] | `set_proxy name port`: sets that an HTTP proxy `name` listening on `port` is to be used
set_proxy_auth [Http_client.pipeline] | sets user and password for the proxy.
set_proxy_enabled [Http_client.http_call] | Sets the proxy mode
set_proxy_from_environment [Http_client.pipeline] | Inspect the environment variables `http_proxy` and `no_proxy` and set the proxy options from them.
set_realm [Http_client.basic_auth_method] |
set_reconnect_mode [Http_client.http_call] | Sets the reconnect mode
set_redirect_mode [Http_client.http_call] | Sets the redirect mode
set_redirection_header [Netcgi1_compat.Netcgi_types.cgi_activation] |
set_redirection_header [Netcgi.cgi] | Sets the header such that a redirection to the specified URL is performed.
set_redirection_header [Netcgi_common.cgi] |
set_req_header [Http_client.http_call] |
set_request_body [Http_client.http_call] | Replaces the whole body object
set_request_device [Http_client.http_call] | Sets that the request data is read from the passed device instead of taking it from a body object.
set_request_header [Http_client.http_call] | Replaces the whole ``Base` header object
set_request_uri [Http_client.http_call] | Sets the request URI.
set_response_body_storage [Http_client.http_call] | Sets how to create the response body
set_socks5_proxy [Ftp_client.ftp_client] | Sets that a SOCKS version 5 proxy is used at this host and port.
set_socks5_proxy [Http_client.pipeline] | Sets that a SOCKS version 5 proxy is used at this host and port.
set_state [Nethttpd_kernel.http_response] | Sets the state
set_state [Uq_engines.engine_mixin] |
set_status [Netcgi1_compat.Netcgi_env.cgi_environment] |
set_status [Netcgi.cgi_environment] | Sets the response status.
set_status [Netcgi_common.cgi_environment] |
set_timeout [Rpc_transport.rpc_multiplex_controller] | If there is no read or write activity for the passed number of seconds, the `notify` callback is invoked.
set_transport_proxy [Http_client.pipeline] | `set_transport_proxy id host port auth ptype`: Sets a special proxy for the transport identified by `id`.
set_transport_proxy_from_environment [Http_client.pipeline] | Like `set_proxy_from_environment`, this method inspects environment variables and configures the proxy settings.
set_value [Netcgi1_compat.Netcgi_types.cgi_argument] | Dealing with the arguments is the task of an higher order library.
set_value [Netmime.mime_body] | Sets the value.
set_value [Netcgi.rw_cgi_argument] |
set_value [Netcgi_common.rw_cgi_argument] |
set_var [Netplex_types.container] | Sets the value of a container variable
setup [Unixqueue_select.sb_event_system] |
setup_e [Http_client.transport_channel_type] | `setup fd cb tmo tmo_x host port esys`: Create or configure a communication circuit over the file descriptor `fd` that can be driven by the returned multiplex controller object.
setup_e [Https_client.transport_channel_type] |
shut_down [Uq_engines.wrapped_datagram_socket] | Close the descriptor, shuts down any further needed resources
shut_down [Uq_engines.server_endpoint_acceptor] | The server endpoint is shut down such that no further connections are possible.
shutdown [Netplex_types.workload_manager] | Called by the controller to notify the manager about a shutdown
shutdown [Netplex_types.container] | Initiates a shutdown of the container.
shutdown [Netplex_types.processor_hooks] | A user-supplied function that is called when a shutdown notification arrives.
shutdown [Netplex_types.socket_controller] | Closes the socket service forever, and initiates a shutdown of all containers serving this type of service.
shutdown [Netplex_types.socket_service] | Shuts down the master sockets
shutdown [Netplex_types.controller] | Initiates a shutdown of all containers.
shutdown [Nethttpd_kernel.http_protocol] | Shuts the socket down.
shutting_down [Uq_engines.multiplex_controller] | True iff the shutdown is in progress
signal [Netsys_oothr.condition] | In a multi-threaded program: Signal one process that the condition holds.
signal [Uq_engines.signal_engine] |
single_threaded [Netsys_oothr.mtprovider] | Whether this is a single-threaded program.
size [Netfs.stream_fs] | Returns the size of a file.
size [Http_fs.http_stream_fs] |
skip [Netstream.in_obj_stream] | Skip the n bytes of the stream.
so_keepalive [Netplex_types.protocol] | Whether to set the keep-alive socket option
socket_directory [Netplex_types.controller_config] | The directory where Unix domain sockets are created.
socket_domain [Uq_engines.wrapped_datagram_socket] |
socket_protocol [Uq_engines.wrapped_datagram_socket] |
socket_service [Netplex_types.container] |
socket_service_config [Netplex_types.socket_service] | The configuration
socket_service_name [Netplex_types.container] |
socket_type [Uq_engines.wrapped_datagram_socket] |
sockets [Netplex_types.socket_service] | A `socket_service` consists of a list of supported protocols which are identified by a name.
source [Netcgi_modtpl.template] | Return the original source code for the template.
source [Unixqueue_select.sb_event_system] |
spec [Netaddress.mailbox] | The formal address specification
ssl_accepting [Uq_ssl.ssl_multiplex_controller] | Whether the initial SSL handshake is in progress that makes this socket a server.
ssl_connecting [Uq_ssl.ssl_multiplex_controller] | Whether the initial SSL handshake is in progress that makes this socket a client.
ssl_socket [Uq_ssl.ssl_multiplex_controller] |
ssl_socket_state [Uq_ssl.ssl_multiplex_controller] | Returns the socket state: ``Unset`: A fresh socket, ``Client`: A socket playing the SSL client role, ``Server`: A socket playing the SSL server role, ``Unclean`: The socket state is unclean. The socket is no longer usable., ``Clean`: The SSL connection has been cleanly shut down.
start [Netplex_types.container] | Internal Method.
start_containers [Netplex_types.socket_controller] |
start_mem_reading [Uq_engines.multiplex_controller] | Same as `start_reading`, but puts the data into a `memory` buffer.
start_mem_writing [Uq_engines.multiplex_controller] | Same as `start_writing`, but takes the data from a `memory` buffer.
start_reading [Rpc_transport.rpc_multiplex_controller] | Start reading from the connection.
start_reading [Uq_engines.multiplex_controller] | Start reading from the connection.
start_shutting_down [Rpc_transport.rpc_multiplex_controller] | Start shutting down the connection.
start_shutting_down [Uq_engines.multiplex_controller] | Start shutting down the connection.
start_ssl_accepting [Uq_ssl.ssl_multiplex_controller] | Makes the socket an SSL server socket by initiating the handshake.
start_ssl_connecting [Uq_ssl.ssl_multiplex_controller] | Makes the socket an SSL client socket by initiating the handshake.
start_thread [Netplex_types.parallelizer] | `start_thread f l_close l_share name logger`: Starts a new thread or process and calls `f thread` in that context.
start_writing [Rpc_transport.rpc_multiplex_controller] | Starts writing the message.
start_writing [Uq_engines.multiplex_controller] | Start writing to the connection.
start_writing_eof [Uq_engines.multiplex_controller] | Start writing the EOF marker to the connection.
startup_directory [Netplex_types.container] | The current directory at Netplex startup time (same view as controller)
startup_directory [Netplex_types.socket_service] | The current directory at Netplex startup time (same view as controller)
startup_directory [Netplex_types.controller] | The current directory at startup time
startup_timeout [Netplex_types.socket_service_config] | After this many seconds the container must have finished the `post_start_hook`.
stat [Netpop.client] | Returns information about the current mailbox as tuple `(count,size,ext)` where `count` is the number of messages in the mailbox, `size` is the size of the mailbox in octets, and `ext` is any server extension data.
state [Rpc_client.auth_protocol] | The state of the authentication protocol: ``Emit`: The client needs to emit another token, ``Receive xid`: The client waits for another token (with session identifier `xid`), ``Done session`: The protocol is finished and `session` can be used for authenticating, ``Error`: Something went wrong.
state [Netpop.client] | Current state of this session.
state [Netplex_types.socket_controller] | The current state
state [Nethttpd_kernel.http_response] | Reports the state.
state [Ftp_client.ftp_client_pi] | The state in the sense of `Uq_engines`.
state [Uq_engines.engine_mixin] |
state [Uq_engines.engine] | Returns the state of the engine
state [Uq_resolver.engine] |
status [Http_client.http_call] | The condensed status
stop_containers [Netplex_types.socket_controller] |
store [Netmime.mime_body_ro] | Where the body is actually stored.
store [Netcgi1_compat.Netcgi_types.cgi_argument] |
store [Netcgi.cgi_argument] | Tells whether the argument is stored in memory (as a string) or as a file (the argument of ``File` being the filename).
store [Netcgi_common.cgi_argument] |
string_param [Netplex_types.config_file] |
supported_ptypes [Netplex_kit.v_processor] |
supported_ptypes [Netplex_types.processor] | The supported parallelization types
supports_half_open_connection [Uq_engines.multiplex_controller] | Whether the underlying transport mechanism can close the write side of the connection only (half-open connection).
supports_mdtm [Ftp_client.ftp_client_pi] | Whether the ``MDTM` command is supported.
supports_mlst [Ftp_client.ftp_client_pi] | Whether the ``MLST` and ``MLSD` commands are supported
supports_size [Ftp_client.ftp_client_pi] | Whether the ``SIZE` command is supported.
supports_tvfs [Ftp_client.ftp_client_pi] | Whether TVFS filenames are supported
supports_utf8 [Ftp_client.ftp_client_pi] | Whether the UTF-8 extension is understood by the server (RFC 2640)
symlink [Netfs.stream_fs] | `symlink flags oldpath newpath`: Creates a symlink.
symlink [Http_fs.http_stream_fs] |
sys_id [Netplex_types.par_thread] | Returns a system-dependent identifier for the thread: ``Thread id`: The `id` as returned by `Thread.id`, ``Process id`: The `id` is the process ID
sys_id [Netplex_types.controller] | The thread running the controller
system [Netplex_types.container] | An RPC client that can be used to send messages to the controller.
system_monitor [Netplex_types.container] | The thread monitor protecting the `system` RPC client
system_shutdown [Netplex_types.processor_hooks] | A user-supplied function that is called when a system shutdown notification arrives.
T
table [Netcgi_modtpl.template] | Set a table in the template.
tcp_nodelay [Netplex_types.protocol] | Whether to set the TCP_NODELAY option
test [Netfs.stream_fs] | Returns whether the test is true.
test [Http_fs.http_stream_fs] |
test_coverage [Nethttpd_kernel.http_protocol] | For testing: returns a list of tokens indicating into which cases the program ran.
test_list [Netfs.stream_fs] | Similar to `test` but this function performs all tests in the list at once, and returns a bool for each test.
test_list [Http_fs.http_stream_fs] |
timeout [Nethttpd_kernel.http_protocol] | Process a timeout condition as `cycle` does
to_channel [Netcgi_modtpl.template] | Write the template to a channel.
to_string [Netcgi_modtpl.template] | Return the template as a string.
top [Netpop.client] | Returns the message header plus a limited number of lines of the message body.
transfer_encoding [Nethttpd_kernel.http_response] | Returns the selected transfer encoding.
translate [Ftp_fs.ftp_stream_fs] | Translates a path into a URL
translate [Http_fs.http_stream_fs] | Translates a path into a URL
tree [Netplex_types.config_file] |
try_lock [Netsys_oothr.mutex] | In a multi-threaded program: Tries to immediately lock the mutex, and returns whether the lock could be obtained.
typ [Netmcore.compute_resource] | which type of resource
U
uidl [Netpop.client] | Returns the unique identifier(s) for an optional message number or for all messages in the current mailbox.
unlock [Netsys_oothr.mutex] | In a multi-threaded program: Unlocks a mutex.
unlock [Nethttpd_reactor.internal_environment] |
unwrap [Netgssapi.gss_api] | Note that the `output_message` can be a buffer of different type (string vs.
update [Telnet_client.telnet_session] | If there are commands in the output queue, the event system is signaled that this client wants to do network I/O.
update_argument [Netcgi1_compat.Netcgi_types.cgi_activation] |
update_detail [Netplex_types.container] | Update the detail string output for the `netplex.connections` admin message
update_field [Netmime.mime_header] |
update_multiple_argument [Netcgi1_compat.Netcgi_types.cgi_activation] |
update_multiple_field [Netmime.mime_header] |
url [Netcgi1_compat.Netcgi_types.cgi_activation] |
url [Netcgi.cgi] | Returns the URL of the current CGI-like script.
url [Netcgi_common.cgi] | The following environment properties must be available for this method to work properly (please make sure your connector provides them; the CGI spec make them compulsory anyway): `cgi_server_name`, `cgi_server_port`, `cgi_script_name`, `cgi_path_info`
user [Netpop.client] | Specifies the name of the mailbox the client would like to open using plain-text authentication.
user [Http_client.key] | The user name
user_agent [Netcgi1_compat.Netcgi_env.cgi_environment] |
user_agent [Netcgi.cgi_environment] | This is a convenience method that returns the `"User-agent"` field of the HTTP request header.
user_agent [Netcgi_common.cgi_environment] |
V
value [Netmime.mime_body_ro] | The `value` method returns the _decoded_ body, i.e.
value [Netcgi1_compat.Netcgi_types.cgi_argument] |
value [Netcgi.cgi_argument] | The value of the argument, after all transfer encodings have been removed.
value [Netcgi_common.cgi_argument] |
var [Netplex_types.container] | Returns the value of a container variable or `Not_found`.
verifier [Rpc_server.auth_details] |
verify_mic [Netgssapi.gss_api] |
version [Rpc_server.auth_details] |
W
wait [Netsys_oothr.condition] | In a multi-threaded program: Wait for the condition to be true and use the mutex to protect this situation.
wait [Netsys_pollset.pollset] | Wait for events, and return the output events matching the event mask.
waiting_for_next_message [Nethttpd_kernel.http_protocol] | Whether the kernel is currently waiting for the beginning of a new arriving HTTP request.
want [Netstream.in_obj_stream] | Increases the length of the window such that the length is at least the passed number of bytes or that the window reaches EOF (whatever happens first).
want_another_block [Netstream.in_obj_stream] | The same as: `want block_size`
watch_shutdown [Netplex_types.par_thread] | Called by the controller if it thinks the container is down.
when_blocking [Unixqueue_select.sb_event_system] |
when_blocking [Unixqueue.event_system] |
window [Netstream.in_obj_stream] | The look-ahead window.
window_at_eof [Netstream.in_obj_stream] | Whether the window is at eof
window_length [Netstream.in_obj_stream] | Returns the length of the window
workload_hook [Netplex_types.processor_hooks] | A user-supplied function that is called when the workload changes, i.e.
wrap [Netgssapi.gss_api] | `output_message_preferred_type`: see `unwrap`
wrap_size_limit [Netgssapi.gss_api] |
write [Netfs.stream_fs] | `write flags filename`: Opens (and optionally creates) the `filename` for writing, and returns the output stream.
write [Http_fs.http_stream_fs] | Additional flag: ``Header h`: Set these headers in the submitted PUT request
write_file [Netfs.stream_fs] | `write_file flags filename localfile`: Opens the file `filename` for writing, and copies the contents of the `localfile` to it.
write_file [Http_fs.http_stream_fs] | Additional flag: ``Header h`: Set these headers in the submitted PUT request
writing [Rpc_transport.rpc_multiplex_controller] | True iff there is a writer
writing [Uq_engines.multiplex_controller] | True iff there is a writer
wrote_eof [Uq_engines.multiplex_controller] | Whether the EOF marker has been written
X
xid [Rpc_server.auth_details] |
Y
yield [Netsys_oothr.mtprovider] | In a multi-threaded program: gives a hint that another thread should better run now.