Struct PeerConnection 

pub struct PeerConnection { /* private fields */ }

Request handle for an active peer connection

Implementations

impl PeerConnection

pub fn strong_count(&self) -> usize

Number of strong handles currently outstanding on this connection (shared across all clones). Used by reapers to decide whether the peer is currently pinned by a strong owner.

pub fn is_strongly_held(&self) -> bool

true if any clone of this connection is currently being held as a strong reference.

pub fn is_strong(&self) -> bool

true if this handle is the strong kind (i.e. it contributes to strong_count).

pub fn clone_strong(&self) -> Self

Returns a new strong clone of this connection. Increments the shared strong counter, regardless of whether the source handle is itself strong.

pub fn clone_weak(&self) -> Self

Returns a new weak clone of this connection. Does not touch the strong counter even if the source handle is strong.

pub fn clone_with(&self, kind: RefKind) -> Self

Returns a clone whose ref-kind is determined by kind. Convenience wrapper used by the connectivity layer to honour caller-requested RefKind without branching at the call site.

pub fn peer_node_id(&self) -> &NodeId

pub fn peer_features(&self) -> PeerFeatures

pub fn direction(&self) -> ConnectionDirection

pub fn known_address(&self) -> Option<&Multiaddr>

pub fn address(&self) -> &Multiaddr

pub fn id(&self) -> ConnectionId

pub fn is_connected(&self) -> bool

pub fn on_disconnect(&self) -> impl Future<Output = ()> + 'static

Returns a owned future that resolves on disconnection

pub fn age(&self) -> Duration

pub fn substream_count(&self) -> usize

pub fn handle_count(&self) -> usize

pub async fn open_substream( &mut self, protocol_id: &ProtocolId, ) -> Result<NegotiatedSubstream<Substream>, PeerConnectionError>

pub async fn open_framed_substream( &mut self, protocol_id: &ProtocolId, max_frame_size: usize, ) -> Result<CanonicalFraming<Substream>, PeerConnectionError>

pub async fn disconnect( &mut self, minimized: Minimized, requester: &str, ) -> Result<(), PeerConnectionError>

Immediately disconnects the peer connection. This can only fail if the peer connection worker is shut down (and the peer is already disconnected)

pub async fn disconnect_if_unused( &mut self, minimized: Minimized, expected_rpc: usize, expected_substreams: usize, requester: &str, ) -> Result<(), PeerConnectionError>

Request to disconnect the peer connection if unused by other services.

pub fn set_force_disconnect_rpc_clients_when_clone_drops(&mut self)

Forcefully disconnect all RPC clients when any clone is dropped - if not set (the default behaviour) all RPC clients will be disconnected when the last instance is dropped. i.e. when self.handle_counter == 1

Trait Implementations

impl Clone for PeerConnection

fn clone(&self) -> Self

Clones preserve the source handle’s strength (Arc-like). A clone of a strong handle is itself strong and bumps the shared strong counter; a clone of a weak handle is weak. Use PeerConnection::clone_strong / PeerConnection::clone_weak to switch kinds explicitly.

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

Performs copy-assignment from source.

impl Debug for PeerConnection

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

Formats the value using the given formatter.

impl Display for PeerConnection

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

Formats the value using the given formatter.

impl Drop for PeerConnection

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl PartialEq for PeerConnection

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.