jsonrpc-derive
cargo install jsonrpc-derive

jsonrpc-derive

Rust JSON-RPC implementation

by paritytech

15.1.0 (see all)License:MIT
cargo install jsonrpc-derive
Readme

Parity JSON-RPC

Rust implementation of JSON-RPC 2.0 Specification. Transport-agnostic core and transport servers for http, ipc, websockets and tcp.

New! Support for clients.

Documentation

Sub-projects

Examples

Basic Usage (with HTTP transport)

use jsonrpc_http_server::jsonrpc_core::{IoHandler, Value, Params};
use jsonrpc_http_server::ServerBuilder;

fn main() {
    let mut io = IoHandler::default();
    io.add_method("say_hello", |_params: Params| async {
        Ok(Value::String("hello".to_owned()))
    });

    let server = ServerBuilder::new(io)
        .threads(3)
        .start_http(&"127.0.0.1:3030".parse().unwrap())
        .unwrap();

    server.wait();
}

Basic usage with derive

use jsonrpc_core::Result;
use jsonrpc_derive::rpc;

#[rpc]
pub trait Rpc {
    /// Adds two numbers and returns a result
    #[rpc(name = "add")]
    fn add(&self, a: u64, b: u64) -> Result<u64>;
}

pub struct RpcImpl;
impl Rpc for RpcImpl {
    fn add(&self, a: u64, b: u64) -> Result<u64> {
        Ok(a + b)
    }
}

fn main() {
    let mut io = jsonrpc_core::IoHandler::new();
    io.extend_with(RpcImpl.to_delegate())
}

Client support

use jsonrpc_core_client::transports::local;
use jsonrpc_core::{BoxFuture, IoHandler, Result};
use jsonrpc_core::futures::{self, future, TryFutureExt};
use jsonrpc_derive::rpc;

/// Rpc trait
#[rpc]
pub trait Rpc {
    /// Returns a protocol version
    #[rpc(name = "protocolVersion")]
    fn protocol_version(&self) -> Result<String>;

    /// Adds two numbers and returns a result
    #[rpc(name = "add", alias("callAsyncMetaAlias"))]
    fn add(&self, a: u64, b: u64) -> Result<u64>;

    /// Performs asynchronous operation
    #[rpc(name = "callAsync")]
    fn call(&self, a: u64) -> BoxFuture<Result<String>>;
}

struct RpcImpl;

impl Rpc for RpcImpl {
    fn protocol_version(&self) -> Result<String> {
        Ok("version1".into())
    }

    fn add(&self, a: u64, b: u64) -> Result<u64> {
        Ok(a + b)
    }

    fn call(&self, _: u64) -> BoxFuture<Result<String>> {
        Box::pin(future::ready(Ok("OK".to_owned())))
    }
}

fn main() {
    let mut io = IoHandler::new();
    io.extend_with(RpcImpl.to_delegate());

    let (client, server) = local::connect::<gen_client::Client, _, _>(io);
    let fut = client.add(5, 6).map_ok(|res| println!("5 + 6 = {}", res));
    futures::executor::block_on(async move { futures::join!(fut, server) })
        .0
        .unwrap();
}

GitHub Stars

576

LAST COMMIT

8mos ago

MAINTAINERS

2

CONTRIBUTORS

76

OPEN ISSUES

60

OPEN PRs

6
VersionTagPublished
15.1.0
2yrs ago
15.0.0
2yrs ago
14.2.2
2yrs ago
14.2.1
2yrs ago
No alternatives found
No tutorials found
Add a tutorial