Struct HttpClientBuilder

source

pub struct HttpClientBuilder<L = Identity> { /* private fields */ }

Expand description

HTTP client builder.

§Examples


use jsonrpsee_http_client::{HttpClientBuilder, HeaderMap, HeaderValue};

#[tokio::main]
async fn main() {
    // Build custom headers used for every submitted request.
    let mut headers = HeaderMap::new();
    headers.insert("Any-Header-You-Like", HeaderValue::from_static("42"));

    // Build client
    let client = HttpClientBuilder::default()
         .set_headers(headers)
         .build("http://localhost")
         .unwrap();

    // use client....
}

Implementations§

source §

impl<L> HttpClientBuilder<L>

source

pub fn max_request_size(self, size: u32) -> Self

Set the maximum size of a request body in bytes. Default is 10 MiB.

source

pub fn max_response_size(self, size: u32) -> Self

Set the maximum size of a response in bytes. Default is 10 MiB.

source

pub fn request_timeout(self, timeout: Duration) -> Self

Set request timeout (default is 60 seconds).

source

pub fn max_concurrent_requests(self, max_concurrent_requests: usize) -> Self

Set the maximum number of concurrent requests. Default disabled.

source

pub fn with_custom_cert_store(self, cfg: CustomCertStore) -> Self

Force to use the rustls native certificate store.

Since multiple certificate stores can be optionally enabled, this option will force the native certificate store to be used.

§Optional

This requires the optional tls feature.

§Example

use jsonrpsee_http_client::{HttpClientBuilder, CustomCertStore};
use rustls::{
    client::danger::{self, HandshakeSignatureValid, ServerCertVerified},
    pki_types::{CertificateDer, ServerName, UnixTime},
    Error,
};

#[derive(Debug)]
struct NoCertificateVerification;

impl rustls::client::danger::ServerCertVerifier for NoCertificateVerification {
    fn verify_server_cert(
        &self,
        _: &CertificateDer<'_>,
        _: &[CertificateDer<'_>],
        _: &ServerName<'_>,
        _: &[u8],
        _: UnixTime,
    ) -> Result<ServerCertVerified, Error> {
        Ok(ServerCertVerified::assertion())
    }

    fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
        vec![rustls::SignatureScheme::ECDSA_NISTP256_SHA256]
    }

    fn verify_tls12_signature(
        &self,
        _: &[u8],
        _: &CertificateDer<'_>,
        _: &rustls::DigitallySignedStruct,
    ) -> Result<rustls::client::danger::HandshakeSignatureValid, Error> {
        Ok(HandshakeSignatureValid::assertion())
    }

    fn verify_tls13_signature(
        &self,
        _: &[u8],
        _: &CertificateDer<'_>,
        _: &rustls::DigitallySignedStruct,
    ) -> Result<HandshakeSignatureValid, Error> {
        Ok(HandshakeSignatureValid::assertion())
    }
}

let tls_cfg = CustomCertStore::builder()
   .dangerous()
   .with_custom_certificate_verifier(std::sync::Arc::new(NoCertificateVerification))
   .with_no_client_auth();

// client builder with disabled certificate verification.
let client_builder = HttpClientBuilder::new().with_custom_cert_store(tls_cfg);