Struct ServerBuilder 

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

Available on crate feature rpc only.

Builder to configure and create a JSON-RPC server.

Implementations

impl Builder<Identity, Identity>

pub fn new() -> Builder<Identity, Identity>

Create a default server builder.

pub fn with_config(config: ServerConfig) -> Builder<Identity, Identity>

Create a server builder with the given ServerConfig.

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

pub fn set_config( self, cfg: ServerConfig, ) -> Builder<HttpMiddleware, RpcMiddleware>

Configure the ServerConfig.

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 as Arc<Mutex>.

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

To add middleware RpcServiceBuilder exposes a few different layer APIs that are wrapped on top of the [tower::ServiceBuilder].

When the server is started these layers are wrapped in the RpcService and that’s why the service APIs is not exposed.

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

use jsonrpsee_server::{
    middleware::rpc::{
        Batch, MethodResponse, Notification, Request, RpcService, RpcServiceBuilder,
        RpcServiceT,
    },
    ServerBuilder,
};

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

impl<S> RpcServiceT for MyMiddleware<S>
where
    S: RpcServiceT + Clone + Send + Sync + 'static,
{
    fn call<'a>(&self, req: Request<'a>) -> impl Future<Output = MethodResponse> + Send + 'a {
        tracing::info!("MyMiddleware processed call {}", req.method);
        let count = self.count.clone();
        let service = self.service.clone();

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

    fn batch<'a>(&self, batch: Batch<'a>) -> impl Future<Output = MethodResponse> + Send + 'a {
        self.service.batch(batch)
    }

    fn notification<'a>(
        &self,
        notif: Notification<'a>,
    ) -> impl Future<Output = MethodResponse> + Send + 'a {
        self.service.notification(notif)
    }
}

// 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 = ServerBuilder::default().set_rpc_middleware(m);

pub fn set_http_middleware<T>( self, http_middleware: 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

use std::{net::SocketAddr, time::Duration};

#[tokio::main]
async fn main() {
    let builder = tower::ServiceBuilder::new().timeout(Duration::from_secs(2));

    let server = jsonrpsee_server::ServerBuilder::new()
        .set_http_middleware(builder)
        .build("127.0.0.1:0".parse::<SocketAddr>().unwrap())
        .await
        .unwrap();
}

pub async fn build( self, addrs: impl ToSocketAddrs, ) -> Result<Server<HttpMiddleware, RpcMiddleware>, Error>

Finalize the configuration of the server. Consumes the Builder.

#[tokio::main]
async fn main() {
    let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
    let occupied_addr = listener.local_addr().unwrap();
    let addrs: &[std::net::SocketAddr] = &[occupied_addr, "127.0.0.1:0".parse().unwrap()];
    assert!(jsonrpsee_server::ServerBuilder::default().build(occupied_addr).await.is_err());
    assert!(jsonrpsee_server::ServerBuilder::default().build(addrs).await.is_ok());
}

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.