Struct jsonrpsee_http_server::RpcModule

pub struct RpcModule<Context> { /* fields omitted */ }

Sets of JSON-RPC methods can be organized into a “module“s that are in turn registered on the server or, alternatively, merged with other modules to construct a cohesive API. RpcModule wraps an additional context argument that can be used to access data during call execution.

Implementations

impl<Context> RpcModule<Context> where
    Context: 'static + Send + Sync, 

pub fn new(ctx: Context) -> RpcModule<Context>

Create a new module with a given shared Context.

pub fn register_method<R, F>(
    &mut self,
    method_name: &'static str,
    callback: F
) -> Result<(), Error> where
    F: Fn(RpcParams<'_>, &Context) -> Result<R, CallError> + Send + Sync + 'static,
    Context: Send + Sync + 'static,
    R: Serialize, 

Register a new synchronous RPC method, which computes the response with the given callback.

pub fn register_async_method<R, F>(
    &mut self,
    method_name: &'static str,
    callback: F
) -> Result<(), Error> where
    F: Fn(RpcParams<'_>, Arc<Context>) -> Pin<Box<dyn Future<Output = Result<R, CallError>> + 'static + Send, Global>> + Copy + Send + Sync + 'static,
    R: Serialize + Send + Sync + 'static, 

Register a new asynchronous RPC method, which computes the response with the given callback.

pub fn register_subscription<F>(
    &mut self,
    subscribe_method_name: &'static str,
    unsubscribe_method_name: &'static str,
    callback: F
) -> Result<(), Error> where
    F: Fn(RpcParams<'_>, SubscriptionSink, Arc<Context>) -> Result<(), Error> + Send + Sync + 'static,
    Context: Send + Sync + 'static, 

Register a new RPC subscription that invokes callback on every subscription request. The callback itself takes three parameters: - RpcParams: JSONRPC parameters in the subscription request. - SubscriptionSink: A sink to send messages to the subscriber. - Context: Any type that can be embedded into the RpcContextModule.

Examples

use jsonrpsee_utils::server::rpc_module::RpcModule;

let mut ctx = RpcModule::new(99_usize);
ctx.register_subscription("sub", "unsub", |params, mut sink, ctx| {
    let x: usize = params.one()?;
    std::thread::spawn(move || {
        let sum = x + (*ctx);
        sink.send(&sum)
    });
    Ok(())
});

pub fn into_methods(self) -> Methods

Convert a module into methods. Consumes self.

pub fn merge<Context2>(
    &mut self,
    other: RpcModule<Context2>
) -> Result<(), Error>

Merge two RpcModule’s by adding all Methods other into self. Fails if any of the methods in other is present already.

Trait Implementations

impl<Context> Debug for RpcModule<Context> where
    Context: Debug, 

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

Formats the value using the given formatter.