Method request

plugins/lsps-plugin/src/core/transport.rs:114–146

(
        &self,
        peer_id: &PublicKey,
        request: &RequestObject<P>,
    )

#[async_trait]
impl<S: MessageSender> Transport for MultiplexedTransport<S> {
    async fn request<P, R>(
        &self,
        peer_id: &PublicKey,
        request: &RequestObject<P>,
    ) -> Result<JsonRpcResponse<R>>
    where
        P: Serialize + Send + Sync,
        R: DeserializeOwned + Send,
    {
        let id = request.id.as_ref().ok_or(Error::MissingId)?;
        let payload = serde_json::to_vec(request)?;

        // Register pending before sending
        let rx = self.pending().insert(id.clone()).await;

        // Send via backend
        if let Err(e) = self.sender.send(peer_id, &payload).await {
            self.pending.remove(id).await;
            return Err(e);
        };

        let response_bytes = tokio::time::timeout(self.timeout, rx)
            .await
            .map_err(|_| {
                let pending = self.pending.clone();
                let id = id.clone();
                tokio::spawn(async move { pending.remove(&id).await });
                Error::Timeout
            })?
            .map_err(|_| Error::Internal("channel closed unexpectedly".into()))?;

        Ok(serde_json::from_slice(&response_bytes)?)
    }
}

#[cfg(test)]