Struct Server 

struct Server<K> {

    conf: NetConf<K>,
    role: Role,
    ibound: Sender<(K, Bytes, Option<OwnedSemaphorePermit>)>,
    obound: Receiver<Command<K>>,
    peers: HashMap<K, Peer>,
    index: BiHashMap<K, PublicKey>,
    task2key: HashMap<Id, K>,
    connecting: HashMap<K, ConnectTask>,
    active: HashMap<K, IoTask>,
    handshake_tasks: JoinSet<Result<(TcpStream, TransportState), NetworkError>>,
    connect_tasks: JoinSet<(TcpStream, TransportState)>,
    io_tasks: JoinSet<Result<(), NetworkError>>,
    ping_interval: Interval,
    metrics: Arc<NetworkMetrics<K>>,
}

The Server is accepting connections and also establishing and maintaining connections with all parties.

Fields

conf: NetConf<K>

role: Role

This server’s role.

ibound: Sender<(K, Bytes, Option<OwnedSemaphorePermit>)>

MPSC sender for messages received over a connection to a party.

(see Network for the accompanying receiver).

obound: Receiver<Command<K>>

MPSC receiver for server task instructions.

(see Network for the accompanying sender).

peers: HashMap<K, Peer>

All parties of the network and their addresses.

index: BiHashMap<K, PublicKey>

Bi-directional mapping of signing key and X25519 keys to identify remote parties.

task2key: HashMap<Id, K>

Find the public key given a tokio task ID.

connecting: HashMap<K, ConnectTask>

Currently active connect attempts.

active: HashMap<K, IoTask>

Currently active connections (post handshake).

handshake_tasks: JoinSet<Result<(TcpStream, TransportState), NetworkError>>

Tasks performing a handshake with a remote party.

connect_tasks: JoinSet<(TcpStream, TransportState)>

Tasks connecting to a remote party and performing a handshake.

io_tasks: JoinSet<Result<(), NetworkError>>

Active I/O tasks, exchanging data with remote parties.

ping_interval: Interval

Interval at which to ping peers.

metrics: Arc<NetworkMetrics<K>>

For gathering network metrics.

Implementations

impl<K> Server<K>

where K: Eq + Ord + Clone + Display + Hash + Send + Sync + 'static,

async fn run(self, listener: TcpListener) -> Result<Empty, NetworkError>

Runs the main loop of this network node.

This function:

• Tries to connect to each remote peer in the committee.
• Handles tasks that have been completed or terminated.
• Processes new messages we received on the network.

fn on_connect_task_end(&mut self, id: Id)

Handles a completed connect task.

fn on_io_task_end(&mut self, id: Id)

Handles a completed I/O task.

This function will get the public key of the task that was terminated and then cleanly removes the associated I/O task data and re-connects to the peer node it was interacting with.

fn spawn_connect(&mut self, k: K)

Spawns a new connection task to a peer identified by public key.

This function will look up the x25519 public key of the ed25519 key and the remote address and then spawn a connection task.

fn spawn_handshake(&mut self, s: TcpStream)

Spawns a new Noise responder handshake task using the IK pattern.

This function will create the responder handshake machine using its own private key and then spawn a task that awaits an initiator handshake to which it will respond.

fn spawn_io(&mut self, k: K, s: TcpStream, t: TransportState, b: Arc<Semaphore>)

Spawns a new I/O task for handling communication with a remote peer over a TCP connection using the noise framework to create an authenticated secure link.

fn lookup_peer(&self, t: &TransportState) -> Option<(K, &Peer)>

Get the public key of a party by their static X25519 public key.

fn is_valid_ip(&self, k: &K, s: &TcpStream) -> bool

Check if the socket’s peer IP address corresponds to the configured one.

Trait Implementations

impl<K: Debug> Debug for Server<K>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.