Struct SelfNetwork 

pub struct SelfNetwork {
    pub online: bool,
    pub home_relay: Option<String>,
    pub relays: Vec<RelayInfo>,
    pub direct_addrs: Vec<String>,
    pub last_change_epoch: Option<i64>,
    pub identity_conflict_epoch: Option<i64>,
}

The status.self_network block (#90): THIS node’s own reachability posture — the first question in every “my message never arrived” investigation, previously unanswerable from either side of the API. Self-facing only: everything here is the node’s own information (relay URLs come from its own config, sanitized; direct addresses already ride its invites).

online is iroh’s own semantics — a home-relay connection is established. In relay_mode = "disabled" it is ALWAYS false with an empty relays list: that is a configuration, not an outage — render it as “LAN-only”, never as a health warning.

Additive-only.

Default is {online: false, relays: []} — which is exactly the shape above meaning “deliberately LAN-only” (#148). The porcelain reads it that way and SUPPRESSES the “no relay connection” line for it. So a fixture built with ..Default::default() claims a healthy LAN-only posture, not an unknown one. There is no third value for a bool; the honest way to say “nobody looked” is StatusResult.self_network: None, which is what a defaulted StatusResult gives you.

Fields

online: bool

A home-relay connection is established (iroh’s online definition). The signal #53’s set_relays never had: when this goes false on a relay-enabled node, the relay set is the thing to look at.

home_relay: Option<String>

The CONNECTED home relay’s URL, sanitized to scheme + host + port (operator-supplied relay URLs can carry userinfo tokens; status output gets screenshotted). None when no relay is connected.

relays: Vec<RelayInfo>

Every known home relay and its current connection state. Empty when no relays are configured, or before the endpoint has selected any.

direct_addrs: Vec<String>

This endpoint’s direct (non-relay) socket addresses — its own dialable coordinates.

last_change_epoch: Option<i64>

When the daemon’s watcher last observed a TRANSITION (epoch seconds) — a change of online, home_relay, or a relay’s connection state; direct_addrs drift alone does not stamp (nor emit a frame). OMITTED (not null) until the first observed transition after boot, and from a point-in-time computation with no watcher running.

identity_conflict_epoch: Option<i64>

When the relay last reported that ANOTHER endpoint is presenting this node’s identity (#134, epoch seconds), or absent if never — the overwhelmingly common case.

Two nodes booted from COPIES of one mesh root share an endpoint id. The relay can serve only one, so the displaced node’s peers simply go unreachable with nothing saying why; diagnosing that cost a downstream real time. This is that missing “why”.

Sticky, and a timestamp rather than a flag. The condition is announced once, as the displaced connection is dropped — it is not a state the relay keeps reporting — so a self-clearing flag would read false by the time anyone called status. Judge staleness from the epoch, exactly as with last_change_epoch.

Absence is not proof of uniqueness. Detection needs an IdentityConflictLayer in the process’s tracing subscriber: the standalone daemon installs one at boot, but an EMBEDDED node cannot (a subscriber is global and the host owns it) and reports None until the host installs it. Never render absence as “identity verified unique”.

Additive: #[serde(default, skip_serializing_if = "Option::is_none")]. api_minor >= 32.

Trait Implementations

impl Clone for SelfNetwork

fn clone(&self) -> SelfNetwork

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SelfNetwork

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

Formats the value using the given formatter.

impl Default for SelfNetwork

fn default() -> SelfNetwork

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SelfNetwork

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for SelfNetwork

impl PartialEq for SelfNetwork

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for SelfNetwork

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SelfNetwork