Struct tcp_message_io::TCPServer

pub struct TCPServer<Q, A, H, F>where
    Q: SerializeMessage,
    A: SerializeMessage,
    H: Fn(Q) -> F + Send + Sync + 'static,
    F: Future<Output = Result<TCPResponse<A>>> + Send + 'static,{ /* private fields */ }

Server to handle TCP requests.

When the .listen() method is called the server starts accepting (possibly simultaneous) connections from any number of clients.

When a client sends a message, the server will invoke the given request handle to process the request, and take an action based on the handler return type (see TCPResponse for a list of possible actions).

If the client closes the connection without warning, the server will simply drop that connection.

If the client sends a malformed message (without or with a wrong length header), the server can potentially read too little data, or hang waiting for data to read.

Implementations

impl<Q, A, H, F> TCPServer<Q, A, H, F>where A: SerializeMessage, Q: SerializeMessage, H: Fn(Q) -> F + Send + Sync + 'static, F: Future<Output = Result<TCPResponse<A>>> + Send + 'static,

pub fn new(host: impl Into<String>, port: u16, handler: H) -> Arc<Self>

Create a new server listening to the given host and port, processing requests with handler.

Does not actually start listening, for that you need to call listen.

The socket will be freed when the struct is dropped.

pub fn with_bad_request_handler( self: Arc<Self>, bad_request_response: fn() -> TCPResponse<A> ) -> Arc<Self>

pub fn with_inactivity_timeout(self: Arc<Self>, timeout_ms: u64) -> Arc<Self>

Instructs the server to quit after the given amount of time without any request.

Note that requests that take longer than the timeout amount, will be dropped in the middle of processing

pub async fn listen(self: Arc<Self>)

Start accepting connections from clients, processing and answering messages.

If multiple servers are started on the same port, this function will panic.