21 stable releases (7 major)

✓ Uses Rust 2018 edition

14.1.0 Apr 14, 2020
14.0.5 Nov 28, 2019
14.0.3 Oct 25, 2019
13.2.0 Sep 13, 2019
7.0.1 Jun 14, 2017

#37 in Encoding

Download history 3469/week @ 2020-01-25 3812/week @ 2020-02-01 4338/week @ 2020-02-08 4289/week @ 2020-02-15 4161/week @ 2020-02-22 4280/week @ 2020-02-29 4372/week @ 2020-03-07 5934/week @ 2020-03-14 7155/week @ 2020-03-21 8713/week @ 2020-03-28 7729/week @ 2020-04-04 9840/week @ 2020-04-11 11756/week @ 2020-04-18 10143/week @ 2020-04-25 14993/week @ 2020-05-02 16654/week @ 2020-05-09

24,044 downloads per month
Used in 43 crates (6 directly)

MIT license

105KB
3K SLoC

Ruby HTML 1.5K SLoC // 0.1% comments Rust 1K SLoC // 0.1% comments

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.

Build Status Build Status

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::new();
	io.add_method("say_hello", |_params: Params| {
		Ok(Value::String("hello".to_string()))
	});

	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, u64, 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::futures::future::{self, Future, FutureResult};
use jsonrpc_core::{Error, IoHandler, Result};
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) -> FutureResult<String, Error>;
}

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) -> FutureResult<String, Error> {
		future::ok("OK".to_owned())
	}
}

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

	let fut = {
		let (client, server) = local::connect::<gen_client::Client, _, _>(io);
		client.add(5, 6).map(|res| println!("5 + 6 = {}", res)).join(server)
	};
	fut.wait().unwrap();
}

Dependencies

~6MB
~125K SLoC