Struct round_based::async_runtime::AsyncProtocol

pub struct AsyncProtocol<SM, I, O, W = BlindWatcher> { /* fields omitted */ }

This is supported on crate feature async-runtime only.

Executes protocol in async environment using tokio backend

In the most simple setting, you just provide protocol initial state, stream of incoming messages, and sink for outgoing messages, and you’re able to easily execute it:

fn incoming() -> impl Stream<Item=Result<Msg<M>, Error>> + FusedStream + Unpin {
    // ...
}
fn outgoing() -> impl Sink<Msg<M>, Error=Error> + Unpin {
    // ...
}
let output: State::Output = AsyncProtocol::new(State::initial(), incoming(), outgoing())
    .run().await?;
// ...

Note that if the protocol has some cryptographical assumptions on transport channel (e.g. messages should be ecrypted, authenticated), then stream and sink must meet these assumptions (e.g. encrypt, authenticate messages)

Implementations

impl<SM, I, O> AsyncProtocol<SM, I, O, BlindWatcher>

pub fn new(state: SM, incoming: I, outgoing: O) -> Self

Constructs new protocol executor from initial state, channels of incoming and outgoing messages

impl<SM, I, O, W> AsyncProtocol<SM, I, O, W>

pub fn set_watcher<WR>(self, watcher: WR) -> AsyncProtocol<SM, I, O, WR>

Sets new protocol watcher

Protocol watcher looks after protocol execution. See list of observable events in ProtocolWatcher trait.

Default watcher: BlindWatcher that does nothing with received events. For development purposes it’s convenient to pick StderrWatcher.

impl<SM, I, O, IErr, W> AsyncProtocol<SM, I, O, W> where
    SM: StateMachine,
    SM::Err: Send,
    SM: Send + 'static,
    I: Stream<Item = Result<Msg<SM::MessageBody>, IErr>> + FusedStream + Unpin,
    O: Sink<Msg<SM::MessageBody>> + Unpin,
    W: ProtocolWatcher<SM>, 

pub async fn run(
    &mut self
) -> Result<SM::Output, Error<SM::Err, IErr, O::Error>>

Executes the protocol

Returns protocol output or first occurred critical error