Struct Node

pub struct Node {

    pub node_config: NodeConfig,
    pub storage: Box<dyn DataStorage + Send>,
    pub broker_net: BrokerNetwork,
    pub network_io: BrokerRouter,
    pub timer: Timer,
    pub crypto_storage: CryptoStorage,
    pub stat: Option<Receiver<NetStats>>,
    pub random: Option<RandomBroker>,
    pub gossip: Option<Gossip>,
    pub ping: Option<Ping>,
    pub webproxy: Option<WebProxy>,
    pub dht_router: Option<DHTRouter>,
    pub dht_storage: Option<DHTStorage>,
}

The node structure holds it all together. It is the main structure of the project.

Fields

node_config: NodeConfig

The node configuration

storage: Box<dyn DataStorage + Send>

Storage to be used

broker_net: BrokerNetwork

Network broker

network_io: BrokerRouter

Network IO broker

timer: Timer

Timer broker

crypto_storage: CryptoStorage

Storing all the signers and ACEs

stat: Option<Receiver<NetStats>>

Stores the connection data

random: Option<RandomBroker>

Handles a random number of connections

gossip: Option<Gossip>

Gossip-events sent and received

ping: Option<Ping>

Pings all connected nodes and informs about failing nodes

webproxy: Option<WebProxy>

Answers GET requests from another node

dht_router: Option<DHTRouter>

Sets up a dht routing system using Kademlia

dht_storage: Option<DHTStorage>

Decentralized storage system using DHTRouting

Implementations

impl Node

pub async fn start( storage: Box<dyn DataStorage + Send>, node_config: NodeConfig, broker_net: BrokerNetwork, ) -> Result<Self, NodeError>

Create new node by loading the config from the storage. This also initializes the network and starts listening for new messages from the signalling server and from other nodes. The actual logic is handled in Logic.

pub async fn request_list(&mut self) -> Result<(), NodeError>

Requests a list of all connected nodes

pub fn nodes_info(&self, ids: Vec<NodeID>) -> Result<Vec<NodeInfo>, NodeError>

Returns all NodeInfos that are stored locally. All ids that do not have a corresponding NodeInfo in the local storage are dropped.

pub fn nodes_connected(&self) -> Result<Vec<NodeInfo>, NodeError>

Gets the current list of connected nodes - these are the nodes that this node is currently connected to, and can be shorter than the list of all nodes in the system.

pub fn nodes_online(&self) -> Result<Vec<NodeInfo>, NodeError>

Returns all currently online nodes in the whole system. Every node will only connect to a subset of these nodes, which can be get with nodes_connected.

pub fn nodes_info_all(&self) -> Result<HashMap<NodeID, NodeInfo>, NodeError>

Returns a list of known nodes from the local storage

pub async fn add_chat_message(&mut self, msg: String) -> Result<(), NodeError>

Adds a new chat message that will be broadcasted to the system.

pub fn get_config( storage: Box<dyn DataStorage>, ) -> Result<NodeConfig, NodeError>

Static method Fetches the config

pub fn set_config( storage: Box<dyn DataStorage>, config: &str, ) -> Result<(), NodeError>

Updates the config of the node