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.engine] |
Forces that the engine aborts operation.
|
| abort_rw [Rpc_transport.rpc_multiplex_controller] |
Aborts the current reader and/or writer forever.
|
| accept [Uq_engines.server_socket_acceptor] |
Instantiates an engine that accepts connections on the listening
socket.
|
| accept_body [Nethttpd_reactor.http_reactive_request] |
Call this method to unlock the body channels.
|
| add [Ftp_client.ftp_client] |
Adds an FTP method to the queue of methods to execute.
|
| add [Http_client.pipeline] |
Adds the call to the end of the pipeline.
|
| 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.event_system] | |
| add_cmd [Ftp_client.ftp_client_pi] |
Add another command to the queue.
|
| add_event [Unixqueue.event_system] | |
| add_handler [Unixqueue.event_system] | |
| add_key [Http_client.key_ring] |
Adds a key to the ring
|
| add_resource [Unixqueue.event_system] | |
| add_service [Netplex_types.controller] |
Adds a new service.
|
| 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] | |
| 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_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] |
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.
|
| block_size [Netstream.in_obj_stream] |
The block size of the stream
|
| bool_param [Netplex_types.config_file] | |
C | |
| 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_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_writing [Uq_engines.multiplex_controller] |
Cancels the write job.
|
| 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 [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 [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.
|
| 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] | |
| clear [Http_client.key_ring] |
Deletes all keys from this key ring
|
| clear [Unixqueue.event_system] | |
| close [Nethttpd_reactor.http_reactor] |
Closes the file descriptor with a reliable method.
|
| close_connection [Nethttpd_kernel.http_response] |
Returns whether the connection should be closed after this response.
|
| 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.
|
| 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_error [Nethttpd_reactor.http_processor_config] |
The function logs an error message.
|
| 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_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 until new data arrives.
|
| 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).
|
| connect [Ftp_client.ftp_method] |
The host and port the FTP method wants to be connected to.
|
| connect [Uq_engines.client_socket_connector] |
Instantiates an engine that connects to the socket 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_state [Netplex_types.socket_controller] | |
| 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.
|
| controller_config [Netplex_types.netplex_config] | |
| 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] | |
| 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_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_processor [Netplex_types.processor_factory] | |
| create_session [Http_client.auth_handler] |
Create a new authentication session.
|
| create_workload_manager [Netplex_types.workload_manager_factory] | |
| 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] | |
| debug_log [Unixqueue.event_system] | |
| 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
|
| 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.
|
| 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] | |
| 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.
|
| 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] | |
| 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 [Http_client.pipeline] |
Returns the event system
|
| event_system [Uq_engines.multiplex_controller] |
Returns the event system
|
| event_system [Uq_engines.engine] |
Returns the event system the engine is attached to
|
| execute [Ftp_client.ftp_method] |
This method is called when the
ftp_client_pi is connected and
the queue of commands is empty.
|
| exists_resource [Unixqueue.event_system] | |
| exn_log [Unixqueue.event_system] | |
| expn [Netsmtp.client] |
Expand command :
expn list will try to expand the Mailing list
list.
|
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] | |
| 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] | |
| 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.
|
| front_token [Nethttpd_kernel.http_response] |
The first token of the queue, represented as
data_chunk.
|
| ftp_state [Ftp_client.ftp_client_pi] |
Returns the current ftp_state
|
G | |
| 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_host [Http_client.http_call] |
The host name of the content server, extracted from the URI
|
| get_local_option [Telnet_client.telnet_session] | |
| get_options [Telnet_client.telnet_session] |
Get the configuration options.
|
| get_options [Http_client.pipeline] | |
| get_path [Http_client.http_call] |
The path extracted from the URI
|
| 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.
|
| 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.
|
I | |
| 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.
|
| inactivity_timeout [Netplex_workload.dynamic_workload_config] |
After this number of seconds a free thread can be terminated
|
| 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.
|
| 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_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_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 [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_key [Http_client.key_handler] |
The method is called when a new session must be authenticated.
|
| int_param [Netplex_types.config_file] | |
| invalidate [Http_client.auth_session] |
The session is notified that authentication failed.
|
| 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.event_system] | |
| is_served [Http_client.http_call] | true if request/response cycle(s) have been finished, i.e.
|
J | |
| job [Shell_uq.job_handler_engine_type] |
Returns the called job
|
| job_instance [Shell_uq.job_handler_engine_type] |
Returns the job instance
|
K | |
| keys [Http_client.key_ring] |
List of all known keys
|
L | |
| 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_socket_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.
|
| log [Netplex_types.container] |
Sends a log message to the controller.
|
| log [Netplex_types.logger] | |
| 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_files [Netplex_log.multi_file_config] |
Triples
(component, max_level, file) .
|
| 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.
|
| 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.logger] | |
| max_threads [Netplex_workload.dynamic_workload_config] |
The manager does not start more threads than this number
|
| 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.
|
| 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_socket_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 | |
| 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 [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.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_linger [Nethttpd_kernel.http_protocol] |
Returns
true when a lingering close operation is needed to reliably shut
down the socket.
|
| new_group [Unixqueue.event_system] | |
| new_session [Rpc_client.auth_method] |
Begin a new session
|
| new_wait_id [Unixqueue.event_system] | |
| next_credentials [Rpc_client.auth_session] |
Returns (cred_flavour, cred_data, verifier_flavor, verifier_date)
|
| next_request [Nethttpd_reactor.http_reactor] |
Tries to read the next request.
|
| no_proxy [Http_client.http_call] |
Same as
set_proxy_enabled false
|
| 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] | |
| once [Unixqueue.event_system] | |
| 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 [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_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 [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 [Netcgi1_compat.Netcgi_env.cgi_environment] |
Not the user business.
|
| output_string [Netchannels.compl_out_channel] |
Writes exactly the passed string
|
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
|
| 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.
|
| 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.
|
| print [Netplex_types.config_file] | |
| print [Nethttpd_types.http_service] |
Outputs the definition term to a formatter
|
| private_api [Http_client.http_call] | |
| 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_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
|
| 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
|
| proxy_enabled [Http_client.http_call] |
Returns the proxy mode
|
| 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
|
Q | |
| queue_events [Unixqueue.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_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
|
| reading [Rpc_transport.rpc_multiplex_controller] |
True iff there is a reader
|
| reading [Uq_engines.multiplex_controller] |
True iff there is a reader
|
| 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 [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_message [Netplex_types.processor_hooks] |
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.
|
| reject_body [Nethttpd_reactor.http_reactive_request] |
Call this method to unlock the body channels.
|
| 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_resource [Unixqueue.event_system] | |
| reopen [Netplex_types.logger] | |
| 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_body [Http_client.http_call] |
The whole body of the request
|
| request_header [Http_client.http_call] |
The whole header of the request.
|
| 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 [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_remote_option [Telnet_client.telnet_session] | |
| request_uri [Http_client.http_call] |
The request URI as string.
|
| 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 [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.
|
| 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 [Ftp_client.ftp_client] |
Starts the event system; same as
Unixqueue.run
|
| run [Ftp_client.ftp_client_pi] |
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.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.
|
| 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_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 matching service_pattern.
|
| 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
|
| server_accepts [Rpc_client.auth_session] |
Called if the server accepts the credentials.
|
| server_address [Uq_engines.server_socket_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.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_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_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_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_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.logger] | |
| 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 a 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_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_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_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.event_system] | |
| shut_down [Uq_engines.wrapped_datagram_socket] |
Close the descriptor, shuts down any further needed resources
|
| shut_down [Uq_engines.server_socket_acceptor] |
The server socket 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.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
|
| skip [Netstream.in_obj_stream] |
Skip the n bytes of the stream.
|
| skip_message [Rpc_transport.rpc_multiplex_controller] |
Skips the current/next received message, i.e.
|
| 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_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 [Unixqueue.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_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 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.
|
| 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 [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
|
| 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).
|
| 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
|
| system [Netplex_types.container] |
An RPC client that can be used to send messages to the controller.
|
| system_handler [Shell_uq.system_handler_engine_type] |
Returns the
system_handler.
|
T | |
| test_coverage [Nethttpd_kernel.http_protocol] |
For testing: returns a list of tokens indicating into which cases the program
ran.
|
| timeout [Nethttpd_kernel.http_protocol] |
Process a timeout condition as
cycle does
|
| 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.
|
| tree [Netplex_types.config_file] | |
U | |
| uidl [Netpop.client] |
Returns the unique identifier(s) for an optional message number
or for all messages in the current mailbox.
|
| unlock [Nethttpd_reactor.internal_environment] | |
| 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_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.
|
W | |
| 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.
|
| 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
|
| 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
|
