Enum DeviceState 

#[non_exhaustive]
pub enum DeviceState {
    Connecting,
    Running,
    NeedsLogin(Url),
    NeedsMachineAuth,
    Reauthenticating,
    Expired,
    Failed(RegistrationError),
}

The control-plane lifecycle state of a device.

Published by the control runner as it brings the node up and maintains the netmap stream. A consumer watches this to drive UI (“connecting…”, “needs login”, “expired”) and to distinguish a permanent failure from a transient one without inspecting logs.

#[non_exhaustive]: more lifecycle states may be added (as Reauthenticating was), so an embedder matching on this must include a wildcard arm and treat an unknown state conservatively (e.g. as “still coming up”) rather than failing to compile on a fork upgrade. (Same-crate matches are unaffected — #[non_exhaustive] only forces the wildcard on out-of-crate consumers.)

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Connecting

The runtime has spawned and is registering / establishing the control session. The initial state of every device.

Running

Registered and the netmap stream is live — the node is up.

NeedsLogin(Url)

Control requires interactive authentication (no usable auth key): the node is waiting for a human to authorize it at the carried URL. Transient — registration retries until authorized.

NeedsMachineAuth

The node is registered with a valid key but awaiting admin approval on an approval-gated tailnet, and control offered no interactive auth URL (so, unlike NeedsLogin, there is nothing for a human to open — an admin must approve the node out of band). Transient — treated like Connecting by the waiters (wait_until_running keeps waiting, never settling on it); the runtime polls registration and, once an admin approves, auto-transitions to Running with no re-registration (Go’s ipn.State::NeedsMachineAuth → Starting). No browse_to_url is derived from it (there is no URL).

Reauthenticating

The node key expired and an automatic, non-interactive re-authentication is in progress: the runtime is rotating the node key and re-registering with the stored auth key (Go doLogin). Transient — treated like Connecting by the waiters (wait_until_running keeps waiting, never settling on it), and the next good self-node flips the state back to Running. No browse_to_url is derived from it (the recovery is non-interactive, unlike NeedsLogin). Entered only when an auth key is retained, auto-reauth is enabled, and Tailnet Lock enforcement is NOT active; otherwise the runtime falls through to Expired. See the runtime’s expiry_action for the decision matrix.

Expired

The node key has expired (control reported the self-node’s key expiry is in the past). The node must re-authenticate to continue. Surfaced from the netmap self-node, not registration.

Failed(RegistrationError)

Registration hard-failed with a permanent reason (e.g. a bad/expired/unknown auth key). The control runner stops; this carries the typed reason. Not retried.

Trait Implementations

impl Clone for DeviceState

fn clone(&self) -> DeviceState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeviceState

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

Formats the value using the given formatter.

impl Eq for DeviceState

impl PartialEq for DeviceState

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