Struct request_response::RequestResponseInner

pub struct RequestResponseInner<S: Sender<K>, R: Receiver, Req: Request, RS: RecipientSource<K>, DS: DataSource<Req>, K: SignatureKey + 'static> {
    pub(crate) config: RequestResponseConfig,
    pub(crate) sender: S,
    pub(crate) recipient_source: RS,
    pub(crate) data_source: DS,
    pub(crate) active_requests: ActiveRequestsMap<Req>,
    pub(crate) phantom_data: PhantomData<(K, R, Req, DS)>,
}

The inner implementation for the request-response protocol

Fields

config: RequestResponseConfig

The configuration of the protocol

sender: S

The sender to use for the protocol

recipient_source: RS

The recipient source to use for the protocol

data_source: DS

The data source to use for the protocol

active_requests: ActiveRequestsMap<Req>

The map of currently active requests

phantom_data: PhantomData<(K, R, Req, DS)>

Phantom data to help with type inference

Implementations

impl<S: Sender<K>, R: Receiver, Req: Request, RS: RecipientSource<K>, DS: DataSource<Req>, K: SignatureKey + 'static> RequestResponseInner<S, R, Req, RS, DS, K>

pub async fn request_indefinitely( self: &Arc<Self>, public_key: &K, private_key: &K::PrivateKey, estimated_request_ttl: Duration, request: Req, ) -> Result<Req::Response, RequestError>

Request something from the protocol indefinitely until we get a response or there was a critical error (e.g. the request could not be signed)

Errors

• If the request was invalid
• If there was a critical error (e.g. the channel was closed)

pub async fn request( self: &Arc<Self>, request_message: RequestMessage<Req, K>, timeout_duration: Duration, ) -> Result<Req::Response, RequestError>

Request something from the protocol and wait for the response. This function will join with an existing request for the same data (determined by Blake3 hash), however both will make requests until the timeout is reached

Errors

• If the request times out
• If the channel is closed (this is an internal error)
• If the request we sign is invalid

pub(crate) async fn receiving_task(self: Arc<Self>, receiver: R)

The task responsible for receiving messages from the receiver and handling them

pub(crate) fn handle_request( self: &Arc<Self>, request_message: RequestMessage<Req, K>, outgoing_responses: &mut OutgoingResponses, )

Handle a request sent to us

pub(crate) fn handle_response( self: &Arc<Self>, response: ResponseMessage<Req>, incoming_responses: &mut IncomingResponses, )

Handle a response sent to us