jsonlrpc 0.2.2

A JSON-RPC 2.0 library that streams JSON objects in JSON Lines format
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

jsonlrpc
========

[![jsonlrpc](https://img.shields.io/crates/v/jsonlrpc.svg)](https://crates.io/crates/jsonlrpc)
[![Documentation](https://docs.rs/jsonlrpc/badge.svg)](https://docs.rs/jsonlrpc)
[![Actions Status](https://github.com/sile/jsonlrpc/workflows/CI/badge.svg)](https://github.com/sile/jsonlrpc/actions)
![License](https://img.shields.io/crates/l/jsonlrpc)

A [JSON-RPC 2.0] library that streams JSON objects in [JSON Lines] format.

[JSON-RPC 2.0]: https://www.jsonrpc.org/specification
[JSON Lines]: https://jsonlines.org/

Examples
--------

RPC client:
```rust
use std::net::TcpStream;
use jsonlrpc::{RpcClient, RequestId, RequestObject, ResponseObject, JsonRpcVersion};

// Connect to a JSON-RPC server.
let server_addr = spawn_rpc_server_thread(); // See below
let socket = TcpStream::connect(server_addr).expect("failed to connect to server");
let mut client = RpcClient::new(socket);

// Send a request to the server.
let request = RequestObject {
    jsonrpc: JsonRpcVersion::V2,
    id: Some(RequestId::Number(1)),
    method: "foo".to_string(),
    params: None,
};
let response = client.call(&request).expect("failed to RPC call");

// Check the response.
let Some(ResponseObject::Ok { result, id, .. }) = response else {
    panic!("expected ok response, got notification or err response")
};
assert_eq!(id, RequestId::Number(1));
```

RPC server:
```rust
use std::net::{SocketAddr, TcpListener};
use jsonlrpc::{JsonlStream, JsonRpcVersion, RequestObject, ResponseObject};

fn spawn_server_thread() -> SocketAddr {
    let listener = TcpListener::bind("127.0.0.1:0").expect("failed to bind to address");
    let addr = listener.local_addr().expect("failed to get local address");

    std::thread::spawn(move || {
        for stream in listener.incoming() {
            let stream = stream.expect("failed to accept incoming connection");
            let mut stream = JsonlStream::new(stream);
            std::thread::spawn(move || {
                let request: RequestObject = stream.read_value().expect("failed to read request");
                let response = ResponseObject::Ok {
                    jsonrpc: JsonRpcVersion::V2,
                    id: request.id.expect("expected request id"),
                    result: serde_json::Value::String(request.method),
                };
                stream.write_value(&response).expect("failed to write response");
            });
        }
    });

    addr
}
```