Struct ProtosocketServer

pub struct ProtosocketServer<Connector: ServerConnector> { /* private fields */ }

A protosocket::Connection is an IO driver. It directly uses tokio’s io wrapper of mio to poll the OS’s io primitives, manages read and write buffers, and vends messages to & from connections. Connections send messages to the ConnectionServer through an mpsc channel, and they receive inbound messages via a reactor callback.

Protosockets are monomorphic messages: You can only have 1 kind of message per service. The expected way to work with this is to use prost and protocol buffers to encode messages. Of course you can do whatever you want, as the telnet example shows.

Protosocket messages are not opinionated about request & reply. If you are, you will need to implement such a thing. This allows you freely choose whether you want to send fire-&-forget messages sometimes; however it requires you to write your protocol’s rules. You get an inbound iterable of batches and an outbound stream of per connection - you decide what those mean for you!

A ProtosocketServer is a future: You spawn it and it runs forever.

Implementations

impl<Connector: ServerConnector> ProtosocketServer<Connector>

pub async fn new( address: SocketAddr, runtime: Handle, connector: Connector, ) -> Result<Self>

Construct a new ProtosocketServer listening on the provided address. The address will be bound and listened upon with SO_REUSEADDR set. The server will use the provided runtime to spawn new tcp connections as protosocket::Connections.

pub fn set_max_buffer_length(&mut self, max_buffer_length: usize)

Set the maximum buffer length for connections created by this server after the setting is applied.

pub fn set_max_queued_outbound_messages( &mut self, max_queued_outbound_messages: usize, )

Set the maximum queued outbound messages for connections created by this server after the setting is applied.

Trait Implementations

impl<Connector: ServerConnector> Future for ProtosocketServer<Connector>

type Output = Result<(), Error>

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.