Trait ConnectionService 

pub trait ConnectionService: Unpin + 'static {
    type Request: Message;
    type Response: Message;

    // Required method
    fn new_rpc(
        &mut self,
        initiating_message: Self::Request,
        responder: RpcResponder<'_, Self::Response>,
    );

    // Provided method
    fn poll(self: Pin<&mut Self>, _context: &mut Context<'_>) -> ControlFlow<()> { ... }
}

A connection service receives rpcs from clients and sends responses.

Each client connection gets a ConnectionService. You put your per-connection state in your ConnectionService implementation.

Every interaction with a client is done via an RPC. You are called with the initiating message from the client, and you return the kind of response future that is used to complete the RPC.

A ConnectionService is executed in the context of an RPC connection server, which is a future. This means you get &mut self when you are called with a new rpc. You can use simple mutable state per-connection; but if you need to share state between connections or elsewhere in your application, you will need to use an appropriate state sharing mechanism.

Required Associated Types

type Request: Message

The type of request message, These messages initiate rpcs.

type Response: Message

The type of response message, These messages complete rpcs, or are streamed from them.

Required Methods

fn new_rpc( &mut self, initiating_message: Self::Request, responder: RpcResponder<'_, Self::Response>, )

Called with an initiating message from the client, the Reponder is how you send your response.

If you drop the responder, the rpc is cancelled. If you send a response, the rpc is completed.

If you want to, you can Send the responder into a task, e.g., via tokio::spawn, and complete the rpc from there. The client will wait until the responder is dropped or a response is sent, in theory.

Provided Methods

fn poll(self: Pin<&mut Self>, _context: &mut Context<'_>) -> ControlFlow<()>

Optional poll to allow the connection to push work forward internally.

You can use this to drive connection state machines (e.g., FuturesUnordered), or whatever else you need to do with your connection between reading from the network and writing to it.

Implementors