24 stable releases (10 major)

18.0.0 Jul 20, 2021
17.1.0 Jun 7, 2021
17.0.0 Jan 20, 2021
16.0.0 Dec 14, 2020
8.0.0 Nov 21, 2017

#2 in #rpcimpl

Download history 52/week @ 2023-11-01 22/week @ 2023-11-08 42/week @ 2023-11-15 69/week @ 2023-11-22 88/week @ 2023-11-29 20/week @ 2023-12-06 44/week @ 2023-12-13 40/week @ 2023-12-20 64/week @ 2023-12-27 10/week @ 2024-01-03 17/week @ 2024-01-10 44/week @ 2024-01-17 44/week @ 2024-01-24 34/week @ 2024-01-31 15/week @ 2024-02-07 224/week @ 2024-02-14

348 downloads per month
Used in snarkos-rpc

MIT license

120KB
3K SLoC

Parity JSON-RPC

NOTE: This crate is no longer actively developed; please have a look at our jsonrpsee crate if you're looking for an actively maintained JSON RPC implementation.

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();
}

lib.rs:

An utility package to test jsonrpc-core based projects.

use jsonrpc_derive::rpc;
use jsonrpc_test as test;

use jsonrpc_core::{Result, Error, IoHandler};

#[rpc]
pub trait Test {
   #[rpc(name = "rpc_some_method")]
   fn some_method(&self, a: u64) -> Result<u64>;
}


struct Dummy;
impl Test for Dummy {
   fn some_method(&self, x: u64) -> Result<u64> {
       Ok(x * 2)
   }
}

fn main() {
  // Initialize new instance of test environment
  let rpc = test::Rpc::new(Dummy.to_delegate());

  // make a request and verify the response as a pretty-printed string
  assert_eq!(rpc.request("rpc_some_method", &[5]), r#"10"#);

  // You can also test RPC created without macros:
  let rpc = {
    let mut io = IoHandler::new();
    io.add_sync_method("rpc_test_method", |_| {
       Err(Error::internal_error())
    });
    test::Rpc::from(io)
  };

  assert_eq!(rpc.request("rpc_test_method", &()), r#"{
  "code": -32603,
  "message": "Internal error"
}"#);
}

Dependencies

~4–6MB
~140K SLoC