Struct Peer

pub struct Peer {
    own_id: PeerID,
    id: RwLock<Option<PeerID>>,
    peer_pool: Weak<PeerPool>,
    pub(crate) conn: Arc<Connection>,
    stop_chan: (Sender<Result<()>>, Receiver<Result<()>>),
    config: Arc<Config>,
    task_group: TaskGroup,
}

Fields

own_id: PeerID

Own ID

id: RwLock<Option<PeerID>>

Peer’s ID

peer_pool: Weak<PeerPool>

A weak pointer to PeerPool

conn: Arc<Connection>

Holds the peer connection

stop_chan: (Sender<Result<()>>, Receiver<Result<()>>)

This channel is used to send a stop signal to the read loop.

config: Arc<Config>

The Configuration for the P2P network.

task_group: TaskGroup

Managing spawned tasks.

Implementations

impl Peer

pub(crate) fn new( own_id: PeerID, peer_pool: Weak<PeerPool>, conn: Arc<Connection>, config: Arc<Config>, ex: Executor, ) -> Arc<Peer>

Creates a new peer

pub async fn send<T: Encode>(&self, proto_id: ProtocolID, msg: T) -> Result<()>

Send a msg to this peer connection using the specified protocol.

pub async fn recv<P: Protocol>(&self) -> Result<ProtocolEvent>

Receives a new msg from this peer connection.

pub async fn broadcast<T: Encode>(&self, proto_id: &ProtocolID, msg: &T)

Broadcast a message to all connected peers using the specified protocol.

pub fn id(&self) -> Option<PeerID>

Returns the peer’s ID

pub fn own_id(&self) -> &PeerID

Returns own ID

pub fn config(&self) -> Arc<Config>

Returns the Config

pub fn remote_endpoint(&self) -> &Endpoint

Returns the remote endpoint for the peer

pub fn is_inbound(&self) -> bool

Check if the connection is Inbound

pub fn direction(&self) -> &ConnDirection

Returns the direction of the connection, which can be either Inbound or Outbound.

pub(crate) async fn init(self: &Arc<Self>) -> Result<()>

pub(crate) async fn run(self: Arc<Self>) -> Result<()>

Run the peer

pub(crate) async fn shutdown(self: &Arc<Self>) -> Result<()>

Shuts down the peer

async fn run_connect_protocols(self: &Arc<Self>)

Run running the Connect Protocols for this peer connection.

async fn read_loop(&self) -> Result<()>

Run a read loop to handle incoming messages from the peer connection.

fn peer_pool(&self) -> Arc<PeerPool>

Returns PeerPool pointer