Struct RemoteInfo

pub struct RemoteInfo {
    pub node_id: NodeId,
    pub relay_url: Option<RelayUrlInfo>,
    pub addrs: Vec<DirectAddrInfo>,
    pub conn_type: ConnectionType,
    pub latency: Option<Duration>,
    pub last_used: Option<Duration>,
}

Details about a remote iroh-net node which is known to this node.

Having details of a node does not mean it can be connected to, nor that it has ever been connected to in the past. There are various reasons a node might be known: it could have been manually added via Endpoint::add_node_addr, it could have been added by some discovery mechanism, the node could have contacted this node, etc.

Fields

node_id: NodeId

The globally unique identifier for this node.

relay_url: Option<RelayUrlInfo>

Relay server information, if available.

addrs: Vec<DirectAddrInfo>

The addresses at which this node might be reachable.

Some of these addresses might only be valid for networks we are not part of, but the remote node might be a part of.

conn_type: ConnectionType

The type of connection we have to the node, either direct or over relay.

latency: Option<Duration>

The latency of the current network path to the remote node.

last_used: Option<Duration>

Time elapsed time since last we have sent to or received from the node.

This is the duration since any data (payload or control messages) was sent or receive from the remote node. Note that sending to the remote node does not imply the remote node received anything.

Implementations

impl RemoteInfo

pub fn last_received(&self) -> Option<Duration>

Get the duration since the last activity we received from this endpoint on any of its direct addresses.

pub fn has_send_address(&self) -> bool

Whether there is a possible known network path to the remote node.

Note that this does not provide any guarantees of whether any network path is usable.

pub fn sources(&self) -> Vec<(Source, Duration)>

Returns a deduplicated list of Sources merged from all address in the RemoteInfo.

Deduplication is on the (Source, Duration) tuple, so you will get multiple Sources for each Source variant, if different addresses were discovered from the same Source at different times.

The list is sorted from least to most recent Source.

Trait Implementations

impl Clone for RemoteInfo

fn clone(&self) -> RemoteInfo

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RemoteInfo

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RemoteInfo

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<RemoteInfo> for NodeAddr

fn from(info: RemoteInfo) -> Self

Converts to this type from the input type.

impl PartialEq for RemoteInfo

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RemoteInfo

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for RemoteInfo

impl StructuralPartialEq for RemoteInfo