Struct Builder

pub struct Builder<HttpMiddleware, RpcMiddleware> { /* private fields */ }

Builder to configure and create a JSON-RPC server

Implementations

impl<HttpMiddleware, RpcMiddleware> Builder<HttpMiddleware, RpcMiddleware>

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

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

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

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

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

Set the maximum size of a log

pub const fn max_connections(self, max: u32) -> Self

Set the maximum number of connections allowed. Default is 100.

pub const fn max_subscriptions_per_connection(self, max: u32) -> Self

Set the maximum number of connections allowed. Default is 1024.

pub const fn set_message_buffer_capacity(self, c: u32) -> Self

The server enforces backpressure which means that n messages can be buffered and if the client can’t keep with up the server.

This capacity is applied per connection and applies globally on the connection which implies all JSON-RPC messages.

For example if a subscription produces plenty of new items and the client can’t keep up then no new messages are handled.

If this limit is exceeded then the server will “back-off” and only accept new messages once the client reads pending messages.

Panics

Panics if the buffer capacity is 0.

pub fn custom_tokio_runtime(self, rt: Handle) -> Self

Configure a custom [tokio::runtime::Handle] to run the server on.

Default: [tokio::spawn]

pub fn set_id_provider<I: IdProvider + 'static>(self, id_provider: I) -> Self

Configure custom subscription ID provider for the server to use to when getting new subscription calls.

You may choose static dispatch or dynamic dispatch because IdProvider is implemented for Box<T>.

Default: [RandomIntegerIdProvider].

Examples

use jsonrpsee::server::RandomStringIdProvider;
use reth_ipc::server::Builder;

// static dispatch
let builder1 = Builder::default().set_id_provider(RandomStringIdProvider::new(16));

// or dynamic dispatch
let builder2 = Builder::default().set_id_provider(Box::new(RandomStringIdProvider::new(16)));

pub fn set_http_middleware<T>( self, service_builder: ServiceBuilder<T>, ) -> Builder<T, RpcMiddleware>

Configure a custom [tower::ServiceBuilder] middleware for composing layers to be applied to the RPC service.

Default: No tower layers are applied to the RPC service.

Examples

#[tokio::main]
async fn main() {
    let builder = tower::ServiceBuilder::new();
    let server = reth_ipc::server::Builder::default()
        .set_http_middleware(builder)
        .build("/tmp/my-uds".into());
}

pub fn set_rpc_middleware<T>( self, rpc_middleware: RpcServiceBuilder<T>, ) -> Builder<HttpMiddleware, T>

Enable middleware that is invoked on every JSON-RPC call.

The middleware itself is very similar to the tower middleware but it has a different service trait which takes &self instead &mut self which means that you can’t use built-in middleware from tower.

Another consequence of &self is that you must wrap any of the middleware state in a type which is Send and provides interior mutability such Arc<Mutex>.

The builder itself exposes a similar API as the [tower::ServiceBuilder] where it is possible to compose layers to the middleware.

use std::{
    net::SocketAddr,
    sync::{
        atomic::{AtomicUsize, Ordering},
        Arc,
    },
    time::Instant,
};

use futures_util::future::BoxFuture;
use jsonrpsee::{
    server::{middleware::rpc::RpcServiceT, ServerBuilder},
    types::Request,
    MethodResponse,
};
use reth_ipc::server::{Builder, RpcServiceBuilder};

#[derive(Clone)]
struct MyMiddleware<S> {
    service: S,
    count: Arc<AtomicUsize>,
}

impl<'a, S> RpcServiceT<'a> for MyMiddleware<S>
where
    S: RpcServiceT<'a> + Send + Sync + Clone + 'static,
{
    type Future = BoxFuture<'a, MethodResponse>;

    fn call(&self, req: Request<'a>) -> Self::Future {
        tracing::info!("MyMiddleware processed call {}", req.method);
        let count = self.count.clone();
        let service = self.service.clone();

        Box::pin(async move {
            let rp = service.call(req).await;
            // Modify the state.
            count.fetch_add(1, Ordering::Relaxed);
            rp
        })
    }
}

// Create a state per connection
// NOTE: The service type can be omitted once `start` is called on the server.
let m = RpcServiceBuilder::new().layer_fn(move |service: ()| MyMiddleware {
    service,
    count: Arc::new(AtomicUsize::new(0)),
});
let builder = Builder::default().set_rpc_middleware(m);

pub fn build(self, endpoint: String) -> IpcServer<HttpMiddleware, RpcMiddleware>

Finalize the configuration of the server. Consumes the Builder.

Trait Implementations

impl<HttpMiddleware: Debug, RpcMiddleware: Debug> Debug for Builder<HttpMiddleware, RpcMiddleware>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Builder<Identity, Identity>

fn default() -> Self

Returns the “default value” for a type.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.