Method request

backend/src/lib.rs:310–353

(
        &self,
        target_role: Option<Role>,
        pl: &S,
        ans: &mut D,
        async_resp: Option<Receiver<Vec<u8>>>,
    )

    }

    async fn request<S, D>(
        &self,
        target_role: Option<Role>,
        pl: &S,
        ans: &mut D,
        async_resp: Option<Receiver<Vec<u8>>>,
    ) -> Result<()>
    where
        S: ?Sized + serde::ser::Serialize + BasePayloadProvider,
        D: serde::de::DeserializeOwned + BasePayloadResultProvider,
    {
        let bp = pl.base_payload().clone();

        let mut be_req_log = stream::BackendInterfacesRequest {
            time: Some(Utc::now().into()),
            sender_id: hex::encode(&bp.sender_id),
            receiver_id: hex::encode(&bp.receiver_id),
            transaction_id: bp.transaction_id,
            message_type: format!("{:?}", bp.message_type),
            ..Default::default()
        };

        let span = span!(Level::INFO, "request", message_type = ?bp.message_type, sender_id = %be_req_log.sender_id, receiver_id = %be_req_log.receiver_id, transaction_id = bp.transaction_id);

        let res = self
            ._request(target_role, pl, ans, async_resp, &mut be_req_log)
            .instrument(span)
            .await;

        if let Err(e) = &res {
            be_req_log.request_error = format!("{:#}", e);
        }

        if let Some(tx) = &self.config.request_log_sender {
            // We use try_send here as we don't want to delay the response in case
            // there is no channel capacity. This would also log an error, proving
            // feedback that there is a channel capacity issue.
            if let Err(e) = tx.try_send(be_req_log) {
                error!(error = %e, "Sending request-log to stream error");
            }
        }

        res
    }

    async fn _request<S, D>(
        &self,