[−][src]Trait tokio_proto::streaming::multiplex::ServerProto

pub trait ServerProto<T: 'static>: 'static {
    type Request: 'static;
    type RequestBody: 'static;
    type Response: 'static;
    type ResponseBody: 'static;
    type Error: From<Error> + 'static;
    type Transport: Transport<Self::RequestBody, Item = Frame<Self::Request, Self::RequestBody, Self::Error>, SinkItem = Frame<Self::Response, Self::ResponseBody, Self::Error>>;
    type BindTransport: IntoFuture<Item = Self::Transport, Error = Error>;
    fn bind_transport(&self, io: T) -> Self::BindTransport;
}

A streaming, multiplexed server protocol.

The T parameter is used for the I/O object used to communicate, which is supplied in bind_transport.

For simple protocols, the Self type is often a unit struct. In more advanced cases, Self may contain configuration information that is used for setting up the transport in bind_transport.

Considerations

There are some difficulties with implementing back pressure in the case that the wire protocol does not support a means by which backpressure can be signaled to the peer.

The problem is the potential for deadlock:

The server is busy processing requests on this connection, and stops reading frames from its transport.
Meanwhile, the processing logic is blocked waiting for another frame that is currently pending on the socket.

To deal with this, once the connection's frame buffer is filled, a timeout is set. If no further frames are able to be read before the timeout expires, the connection is killed.

Associated Types

`type Request: 'static`

Request headers.

`type RequestBody: 'static`

Request body chunks.

`type Response: 'static`

Response headers.

`type ResponseBody: 'static`

Response body chunks.

`type Error: From<Error> + 'static`

Errors, which are used both for error frames and for the service itself.

`type Transport: Transport<Self::RequestBody, Item = Frame<Self::Request, Self::RequestBody, Self::Error>, SinkItem = Frame<Self::Response, Self::ResponseBody, Self::Error>>`

The frame transport, which usually take T as a parameter.

`type BindTransport: IntoFuture<Item = Self::Transport, Error = Error>`

A future for initializing a transport from an I/O object.

In simple cases, Result<Self::Transport, Self::Error> often suffices.

Loading content...

Required methods

`fn bind_transport(&self, io: T) -> Self::BindTransport`

Build a transport from the given I/O object, using self for any configuration.

Loading content...

Implementors

Loading content...