Struct jsonrpsee_core::server::rpc_module::Methods

source ·

pub struct Methods { /* private fields */ }

Expand description

Reference-counted, clone-on-write collection of synchronous and asynchronous methods.

Implementations§

source §

impl Methods

source

pub fn new() -> Self

Creates a new empty Methods.

source

pub fn initialize_resources(self, resources: &Resources) -> Result<Self, Error>

Initialize resources for all methods in this collection. This method has no effect if called more than once.

source

pub fn merge(&mut self, other: impl Into<Methods>) -> Result<(), Error>

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

source

pub fn method(&self, method_name: &str) -> Option<&MethodCallback>

Returns the method callback.

source

pub fn method_with_name( &self, method_name: &str ) -> Option<(&'static str, &MethodCallback)>

Returns the method callback along with its name. The returned name is same as the method_name, but its lifetime bound is 'static.

source

pub async fn call<Params: ToRpcParams, T: DeserializeOwned>( &self, method: &str, params: Params ) -> Result<T, Error>

Helper to call a method on the RPC module without having to spin up a server.

The params must be serializable as JSON array, see ToRpcParams for further documentation.

Returns the decoded value of the result field in JSON-RPC response if successful.

Examples

#[tokio::main]
async fn main() {
    use jsonrpsee::RpcModule;

    let mut module = RpcModule::new(());
    module.register_method("echo_call", |params, _| {
        params.one::<u64>().map_err(Into::into)
    }).unwrap();

    let echo: u64 = module.call("echo_call", [1_u64]).await.unwrap();
    assert_eq!(echo, 1);
}

source

pub async fn raw_json_request( &self, request: &str ) -> Result<(MethodResponse, UnboundedReceiver<String>), Error>

Make a request (JSON-RPC method call or subscription) by using raw JSON.

Returns the raw JSON response to the call and a stream to receive notifications if the call was a subscription.

Examples

#[tokio::main]
async fn main() {
    use jsonrpsee::RpcModule;
    use jsonrpsee::types::Response;
    use futures_util::StreamExt;

    let mut module = RpcModule::new(());
    module.register_subscription("hi", "hi", "goodbye", |_, mut sink, _| {
        sink.send(&"one answer").unwrap();
        Ok(())
    }).unwrap();
    let (resp, mut stream) = module.raw_json_request(r#"{"jsonrpc":"2.0","method":"hi","id":0}"#).await.unwrap();
    let resp = serde_json::from_str::<Response<u64>>(&resp.result).unwrap();
    let sub_resp = stream.next().await.unwrap();
    assert_eq!(
        format!(r#"{{"jsonrpc":"2.0","method":"hi","params":{{"subscription":{},"result":"one answer"}}}}"#, resp.result),
        sub_resp
    );
}

Helper to create a subscription on the RPC module without having to spin up a server.

The params must be serializable as JSON array, see ToRpcParams for further documentation.

Returns Subscription on success which can used to get results from the subscriptions.

Examples

#[tokio::main]
async fn main() {
    use jsonrpsee::{RpcModule, types::EmptyServerParams};

    let mut module = RpcModule::new(());
    module.register_subscription("hi", "hi", "goodbye", |_, mut sink, _| {
        sink.send(&"one answer").unwrap();
        Ok(())
    }).unwrap();

    let mut sub = module.subscribe("hi", EmptyServerParams::new()).await.unwrap();
    // In this case we ignore the subscription ID,
    let (sub_resp, _sub_id) = sub.next::<String>().await.unwrap().unwrap();
    assert_eq!(&sub_resp, "one answer");
}