Trait Reading

pub trait Reading: P2P
where
    Self: Clone + Send + Sync + 'static,
{
    type Message: Send;
    type Codec: Decoder<Item = Self::Message, Error = Error> + Send;

    const MESSAGE_QUEUE_DEPTH: usize = 1_024usize;
    const INITIAL_BUFFER_SIZE: usize = 1_048_576usize;

    // Required methods
    fn codec(&self, addr: SocketAddr, side: ConnectionSide) -> Self::Codec;
    fn process_message<'life0, 'async_trait>(
        &'life0 self,
        source: SocketAddr,
        message: Self::Message,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;

    // Provided method
    fn enable_reading<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
}

Can be used to specify and enable reading, i.e. receiving inbound messages. If the Handshake protocol is enabled too, it goes into force only after the handshake has been concluded.

Each inbound message is isolated by the user-supplied Reading::Codec, creating a Reading::Message, which is immediately queued (with a Reading::MESSAGE_QUEUE_DEPTH limit) to be processed by Reading::process_message. The configured fatal IO errors result in an immediate disconnect (in order to e.g. avoid accidentally reading “borked” messages).

Provided Associated Constants

const MESSAGE_QUEUE_DEPTH: usize = 1_024usize

The depth of per-connection queues used to process inbound messages; the greater it is, the more inbound messages the node can enqueue, but setting it to a large value can make the node more susceptible to DoS attacks.

The default value is 1024.

const INITIAL_BUFFER_SIZE: usize = 1_048_576usize

The initial size of a per-connection buffer for reading inbound messages. Can be set to the maximum expected size of the inbound message in order to only allocate it once.

The default value is 1024KiB.

Required Associated Types

type Message: Send

The final (deserialized) type of inbound messages.

type Codec: Decoder<Item = Self::Message, Error = Error> + Send

The user-supplied Decoder used to interpret inbound messages.

Required Methods

fn codec(&self, addr: SocketAddr, side: ConnectionSide) -> Self::Codec

Creates a Decoder used to interpret messages from the network. The side param indicates the connection side from the node’s perspective.

fn process_message<'life0, 'async_trait>( &'life0 self, source: SocketAddr, message: Self::Message, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Processes an inbound message. Can be used to update state, send replies etc.

Provided Methods

fn enable_reading<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Prepares the node to receive messages.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors