Struct reth::rpc::builder::auth::IpcServerBuilder

pub struct IpcServerBuilder<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, ) -> Builder<HttpMiddleware, RpcMiddleware>

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

pub const fn max_response_body_size( self, size: u32, ) -> Builder<HttpMiddleware, RpcMiddleware>

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

pub const fn max_log_length( self, size: u32, ) -> Builder<HttpMiddleware, RpcMiddleware>

Set the maximum size of a log

pub const fn max_connections( self, max: u32, ) -> Builder<HttpMiddleware, RpcMiddleware>

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

pub const fn max_subscriptions_per_connection( self, max: u32, ) -> Builder<HttpMiddleware, RpcMiddleware>

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

pub const fn set_message_buffer_capacity( self, c: u32, ) -> Builder<HttpMiddleware, RpcMiddleware>

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, ) -> Builder<HttpMiddleware, RpcMiddleware>

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

Default: [tokio::spawn]

pub fn set_id_provider<I>( self, id_provider: I, ) -> Builder<HttpMiddleware, RpcMiddleware>

where I: IdProvider + 'static,

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, RpcMiddleware> Debug for Builder<HttpMiddleware, RpcMiddleware>

where HttpMiddleware: Debug, RpcMiddleware: Debug,

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

Formats the value using the given formatter.

impl Default for Builder<Identity, Identity>

fn default() -> Builder<Identity, Identity>

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.