sn_node_rpc_client 0.1.95

Safe Node RPC Client
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

# Safenode RPC Client

This crate provides a client for the RPC protocol for interacting with `safenode`. It wraps the Protobuf-generated code and types such that users of the RPC protocol don't need to redefine that code.

It also provides a binary which is a CLI for interacting with a running `safenode` instance via the protocol.

## RPC Actions

The `RpcActions` trait defines the protocol that is currently available for interacting with `safenode`:
```
node_info: Returns information about the node, such as its peer ID and version.
network_info: Retrieves network-related information, such as the peers currently connected to the node.
record_addresses: Provides a list of the node's record addresses.
gossipsub_subscribe: Subscribes to a specific topic on the gossipsub network.
gossipsub_unsubscribe: Unsubscribes from a given topic on the gossipsub network.
gossipsub_publish: Publishes a message to a specified topic on the gossipsub network.
restart_node: Requests the node to restart.
stop_node: Requests the node to stop its operations.
update_node: Updates the node with provided parameters.
```

Users of the crate can program against the trait rather than the `RpcClient` implementation.

This can facilitate behaviour-based unit testing, like so:
```
use mockall::mock;
use mockall::predicate::*;

mock! {
    pub RpcClient {}
    #[async_trait]
    impl RpcClientInterface for RpcClient {
        async fn node_info(&self) -> RpcResult<NodeInfo>;
        async fn network_info(&self) -> RpcResult<NetworkInfo>;
        async fn record_addresses(&self) -> Result<Vec<RecordAddress>>;
        async fn gossipsub_subscribe(&self, topic: &str) -> Result<()>;
        async fn gossipsub_unsubscribe(&self, topic: &str) -> Result<()>;
        async fn gossipsub_publish(&self, topic: &str, message: &str) -> Result<()>;
        async fn node_restart(&self, delay_millis: u64) -> Result<()>;
        async fn node_stop(&self, delay_millis: u64) -> Result<()>;
        async fn node_update(&self, delay_millis: u64) -> Result<()>;
    }
}
```

## Binary Usage

Run `cargo run -- <ADDR> <command>` to connect to a node. Provide the address of the node's RPC service, e.g. 127.0.0.1:12001. Followed by the command to execute. Some of the commands available are:

- `info`: Retrieve information about the node itself
- `netinfo`: Retrieve information about the node's connections to the network
- `events`: Start listening for node events
- `transfers`: Start listening for transfers events
- `subscribe`: Subscribe to a given Gossipsub topic
- `unsubscribe`: Unsubscribe from a given Gossipsub topic
- `publish`: Publish a msg on a given Gossipsub topic
- `restart`: Restart the node after the specified delay
- `stop`: Stop the node after the specified delay
- `update`: Update to latest `safenode` released version, and restart it

For more information about each command, run `cargo run -- <command> --help`.