Struct MetaIoHandler

Source

pub struct MetaIoHandler<T: Metadata, S: Middleware<T> = Noop> { /* private fields */ }

Expand description

Request handler

By default compatible only with jsonrpc v2

Implementations§

Source §

impl<T: Metadata> MetaIoHandler<T>

Source

pub fn with_compatibility(compatibility: Compatibility) -> Self

Creates new MetaIoHandler compatible with specified protocol version.

Source §

impl<T: Metadata, S: Middleware<T>> MetaIoHandler<T, S>

Source

pub fn new(compatibility: Compatibility, middleware: S) -> Self

Creates new MetaIoHandler

Source

pub fn with_middleware(middleware: S) -> Self

Creates new MetaIoHandler with specified middleware.

Examples found in repository ?

examples/middlewares.rs (line 34)

33pub fn main() {
34	let mut io = MetaIoHandler::with_middleware(MyMiddleware::default());
35
36	io.add_method_with_meta("say_hello", |_params: Params, meta: Meta| async move {
37		Ok(Value::String(format!("Hello World: {}", meta.0)))
38	});
39
40	let request = r#"{"jsonrpc": "2.0", "method": "say_hello", "params": [42, 23], "id": 1}"#;
41	let response = r#"{"jsonrpc":"2.0","result":"Hello World: 5","id":1}"#;
42
43	let headers = 5;
44	assert_eq!(
45		io.handle_request_sync(request, Meta(headers)),
46		Some(response.to_owned())
47	);
48}

Source

pub fn add_alias(&mut self, alias: &str, other: &str)

Adds an alias to a method.

Source

pub fn add_sync_method<F>(&mut self, name: &str, method: F)
where F: RpcMethodSync,

Adds new supported synchronous method.

A backward-compatible wrapper.

Examples found in repository ?

examples/basic.rs (line 6)

3fn main() {
4	let mut io = IoHandler::new();
5
6	io.add_sync_method("say_hello", |_: Params| Ok(Value::String("Hello World!".to_owned())));
7
8	let request = r#"{"jsonrpc": "2.0", "method": "say_hello", "params": [42, 23], "id": 1}"#;
9	let response = r#"{"jsonrpc":"2.0","result":"hello","id":1}"#;
10
11	assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
12}

Source

pub fn add_method<F>(&mut self, name: &str, method: F)
where F: RpcMethodSimple,

Adds new supported asynchronous method.

Examples found in repository ?

examples/async.rs (lines 7-9)

3fn main() {
4	futures_executor::block_on(async {
5		let mut io = IoHandler::new();
6
7		io.add_method("say_hello", |_: Params| async {
8			Ok(Value::String("Hello World!".to_owned()))
9		});
10
11		let request = r#"{"jsonrpc": "2.0", "method": "say_hello", "params": [42, 23], "id": 1}"#;
12		let response = r#"{"jsonrpc":"2.0","result":"hello","id":1}"#;
13
14		assert_eq!(io.handle_request(request).await, Some(response.to_owned()));
15	});
16}

More examples

Hide additional examples

examples/params.rs (lines 12-15)

9fn main() {
10	let mut io = IoHandler::new();
11
12	io.add_method("say_hello", |params: Params| async move {
13		let parsed: HelloParams = params.parse().unwrap();
14		Ok(Value::String(format!("hello, {}", parsed.name)))
15	});
16
17	let request = r#"{"jsonrpc": "2.0", "method": "say_hello", "params": { "name": "world" }, "id": 1}"#;
18	let response = r#"{"jsonrpc":"2.0","result":"hello, world","id":1}"#;
19
20	assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
21}

Source

pub fn add_notification<F>(&mut self, name: &str, notification: F)
where F: RpcNotificationSimple,

Adds new supported notification

Source

pub fn add_method_with_meta<F>(&mut self, name: &str, method: F)
where F: RpcMethod<T>,

Adds new supported asynchronous method with metadata support.

Examples found in repository ?

examples/meta.rs (lines 10-12)

7pub fn main() {
8	let mut io = MetaIoHandler::default();
9
10	io.add_method_with_meta("say_hello", |_params: Params, meta: Meta| async move {
11		Ok(Value::String(format!("Hello World: {}", meta.0)))
12	});
13
14	let request = r#"{"jsonrpc": "2.0", "method": "say_hello", "params": [42, 23], "id": 1}"#;
15	let response = r#"{"jsonrpc":"2.0","result":"Hello World: 5","id":1}"#;
16
17	let headers = 5;
18	assert_eq!(
19		io.handle_request_sync(request, Meta(headers)),
20		Some(response.to_owned())
21	);
22}

More examples

Hide additional examples

examples/middlewares.rs (lines 36-38)

33pub fn main() {
34	let mut io = MetaIoHandler::with_middleware(MyMiddleware::default());
35
36	io.add_method_with_meta("say_hello", |_params: Params, meta: Meta| async move {
37		Ok(Value::String(format!("Hello World: {}", meta.0)))
38	});
39
40	let request = r#"{"jsonrpc": "2.0", "method": "say_hello", "params": [42, 23], "id": 1}"#;
41	let response = r#"{"jsonrpc":"2.0","result":"Hello World: 5","id":1}"#;
42
43	let headers = 5;
44	assert_eq!(
45		io.handle_request_sync(request, Meta(headers)),
46		Some(response.to_owned())
47	);
48}

Source

pub fn add_notification_with_meta<F>(&mut self, name: &str, notification: F)
where F: RpcNotification<T>,

Adds new supported notification with metadata support.

Source

pub fn extend_with<F>(&mut self, methods: F)
where F: IntoIterator<Item = (String, RemoteProcedure<T>)>,

Extend this MetaIoHandler with methods defined elsewhere.

Source

pub fn handle_request_sync(&self, request: &str, meta: T) -> Option<String>

Handle given request synchronously - will block until response is available. If you have any asynchronous methods in your RPC it is much wiser to use handle_request instead and deal with asynchronous requests in a non-blocking fashion.

Examples found in repository ?

examples/meta.rs (line 19)

7pub fn main() {
8	let mut io = MetaIoHandler::default();
9
10	io.add_method_with_meta("say_hello", |_params: Params, meta: Meta| async move {
11		Ok(Value::String(format!("Hello World: {}", meta.0)))
12	});
13
14	let request = r#"{"jsonrpc": "2.0", "method": "say_hello", "params": [42, 23], "id": 1}"#;
15	let response = r#"{"jsonrpc":"2.0","result":"Hello World: 5","id":1}"#;
16
17	let headers = 5;
18	assert_eq!(
19		io.handle_request_sync(request, Meta(headers)),
20		Some(response.to_owned())
21	);
22}

More examples

Hide additional examples

examples/middlewares.rs (line 45)

33pub fn main() {
34	let mut io = MetaIoHandler::with_middleware(MyMiddleware::default());
35
36	io.add_method_with_meta("say_hello", |_params: Params, meta: Meta| async move {
37		Ok(Value::String(format!("Hello World: {}", meta.0)))
38	});
39
40	let request = r#"{"jsonrpc": "2.0", "method": "say_hello", "params": [42, 23], "id": 1}"#;
41	let response = r#"{"jsonrpc":"2.0","result":"Hello World: 5","id":1}"#;
42
43	let headers = 5;
44	assert_eq!(
45		io.handle_request_sync(request, Meta(headers)),
46		Some(response.to_owned())
47	);
48}