Enum ExitNodeSelector 

pub enum ExitNodeSelector {
    StableId(StableId),
    Ip(IpAddr),
    Name(String),
}

How this node selects which peer to use as its exit node (--exit-node in the Go client).

Mirrors the Go client’s --exit-node, which accepts a tailnet IP, a MagicDNS name, or a stable node ID, and resolves it to a StableNodeID (resolveExitNodeIPLocked). We keep the selector unresolved and re-run ExitNodeSelector::resolve against the live peer set on every route rebuild, so an IP- or name-based selection follows the peer as the netmap changes (e.g. the exit node re-registers under a new stable id).

A selector can be parsed from a string with str::parse/FromStr, auto-detecting the variant the way the Go CLI’s --exit-node does: a value that parses as an IP address becomes ExitNodeSelector::Ip, anything else becomes ExitNodeSelector::Name. Stable-id selection is available only by constructing ExitNodeSelector::StableId directly (it is not auto-detected, since a stable id is otherwise indistinguishable from a hostname).

Variants

StableId(StableId)

Select the peer with this exact stable node id.

Ip(IpAddr)

Select the peer whose tailnet address is this IP.

Name(String)

Select the peer matching this bare hostname or MagicDNS name (case-insensitive, optional trailing dot), as per Node::matches_name.

Implementations

impl ExitNodeSelector

pub fn resolve<'a>( &self, peers: impl Iterator<Item = &'a Node>, ) -> Option<StableId>

Resolve this selector to the stable id of the matching peer, if any, given the current set of peers.

Resolution is deterministic: if a selector somehow matches more than one peer (e.g. two peers sharing a MagicDNS name during a transient netmap state), the peer with the smallest StableId is chosen. This matters because both the outbound route table and the inbound source filter resolve independently; a deterministic tiebreak guarantees they pick the same peer, preserving the cryptokey-routing coupling that prevents source-spoofing.

Returns None when no peer matches (a stale/typo’d selector). Callers treat None as fail-closed: no peer is granted a default route, so internet-bound traffic is dropped.

Trait Implementations

impl Clone for ExitNodeSelector

fn clone(&self) -> ExitNodeSelector

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExitNodeSelector

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExitNodeSelector

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ExitNodeSelector

impl FromStr for ExitNodeSelector

fn from_str(s: &str) -> Result<Self, Self::Err>

Parse a selector from a string, auto-detecting IP vs. name (matching the Go CLI’s --exit-node). Parsing never fails: a non-IP string is taken as a MagicDNS name.

type Err = Infallible

The associated error which can be returned from parsing.

impl PartialEq for ExitNodeSelector

fn eq(&self, other: &ExitNodeSelector) -> 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 ExitNodeSelector

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 ExitNodeSelector