Struct rings_node::processor::Processor

pub struct Processor {
    pub swarm: Arc<Swarm>,
    pub stabilization: Arc<Stabilization>,
}

Processor for rings-node jsonrpc server

Fields

swarm: Arc<Swarm>

a swarm instance

stabilization: Arc<Stabilization>

a stabilization instance,

Implementations

impl Processor

pub fn generate_signature(secret_key: &SecretKey) -> String

Generate Signature for Authorization

pub fn verify_signature(signature: &[u8], public_key: &PublicKey) -> Result<bool>

verify signature will throw error when signature is illegal

pub fn did(&self) -> Did

Get current did

pub async fn create_offer(&self) -> Result<(Arc<Transport>, Encoded)>

Create an Offer and waiting for connection. The process of manually handshake is:

1. PeerA: create_offer
2. PeerA: send the handshake info to PeerB.
3. PeerB: answer_offer
4. PeerB: send the handshake info to PeerA.
5. PeerA: accept_answer.

pub async fn connect_peer_via_http(
    &self,
    peer_url: &str
) -> Result<Arc<Transport>>

Connect peer with remote rings-node jsonrpc server.

• peer_url: the remote rings-node jsonrpc server url.

pub async fn answer_offer(
    &self,
    ice_info: &str
) -> Result<(Arc<Transport>, Encoded)>

Answer an Offer. The process of manually handshake is:

1. PeerA: create_offer
2. PeerA: send the handshake info to PeerB.
3. PeerB: answer_offer
4. PeerB: send the handshake info to PeerA.
5. PeerA: accept_answer.

pub async fn connect_with_did(
    &self,
    did: Did,
    wait_for_open: bool
) -> Result<Peer>

Connect peer with web3 did. There are 3 peers: PeerA, PeerB, PeerC.

1. PeerA has a connection with PeerB.
2. PeerC has a connection with PeerB.
3. PeerC can connect PeerA with PeerA’s web3 address.

pub async fn accept_answer(&self, transport_id: &str, ice: &str) -> Result<Peer>

Accept an answer of a connection. The process of manually handshake is:

1. PeerA: create_offer
2. PeerA: send the handshake info to PeerB.
3. PeerB: answer_offer
4. PeerB: send the handshake info to PeerA.
5. PeerA: accept_answer.

pub async fn list_peers(&self) -> Result<Vec<Peer>>

List all peers.

pub async fn get_peer(&self, did: Did) -> Result<Peer>

Get peer by remote did

pub async fn disconnect(&self, did: Did) -> Result<()>

Disconnect a peer with web3 did.

pub async fn list_pendings(&self) -> Result<Vec<Arc<Transport>>>

List all pending transport.

pub async fn close_pending_transport(&self, transport_id: &str) -> Result<()>

Close pending transport

pub async fn send_message(&self, destination: &str, msg: &[u8]) -> Result<Uuid>

Send custom message to a did.

pub async fn send_http_request_message<U, T>(
    &self,
    destination: &str,
    name: U,
    method: Method,
    url: U,
    timeout: T,
    headers: &[(U, U)],
    body: Option<Bytes>
) -> Result<Uuid>where
    U: ToString,
    T: Into<Timeout>,

send http request message to node

• destination: did of destination
• url: ipfs url
• timeout: timeout in millisecond

pub async fn send_simple_text_message(
    &self,
    destination: &str,
    text: &str
) -> Result<Uuid>

send simple text message

• destination: did of destination
• text: text message

pub async fn storage_check_cache(&self, did: Did) -> Option<VirtualNode>

check local cache of dht

pub async fn storage_fetch(&self, did: Did) -> Result<()>

fetch virtual node from DHT

pub async fn storage_store(&self, vnode: VirtualNode) -> Result<()>

store virtual node on DHT

pub async fn storage_append_data(&self, topic: &str, data: Encoded) -> Result<()>

append data to a virtual node on DHT

pub async fn register_service(&self, name: &str) -> Result<()>

register service

Trait Implementations

impl Clone for Processor

fn clone(&self) -> Processor

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl From<(Arc<Swarm>, Arc<Stabilization>)> for Processor

fn from((swarm, stabilization): (Arc<Swarm>, Arc<Stabilization>)) -> Self

Converts to this type from the input type.

impl Metadata for Processor