Enum Error 

#[non_exhaustive]
pub enum Error {
    Device(Error),
    Registration(RegistrationError),
    InvalidControlUrl(ParseError),
    InvalidAddr {
        addr: String,
        source: AddrParseError,
    },
    AddrFamilyMismatch {
        addr: String,
        want: &'static str,
    },
    UnsupportedNetwork {
        network: String,
    },
    InvalidNetwork {
        network: String,
    },
    Store(Error),
    State(Error),
    Logout(LogoutError),
    Loopback(Error),
}

The unified error for Server’s lifecycle surface (start/up/dial/listen/…).

Go returns a single opaque error everywhere; this fork returns typed errors. Error is the Go-shaped unification for the lifecycle path only — the specialized calls that already carry rich typed errors keep them, wrapped so a lazy-start failure stays distinct from the engine error: Server::listen_funnel → ListenFunnelError (over ts_control::FunnelError), Server::listen_service → ListenServiceError (over ServiceError).

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.

Device(Error)

The wrapped Device/engine returned an error.

Registration(RegistrationError)

Registration did not reach Running (Go Up failure). Carries the typed, actionable reason (permanent vs transient vs needs-login) — richer than Go’s status blob.

InvalidControlUrl(ParseError)

Server::control_url was set but is not a valid URL.

InvalidAddr

A Go-style network, addr string could not be parsed into a SocketAddr.

Fields

addr: String

The offending address string.

source: AddrParseError

The parse failure.

AddrFamilyMismatch

A family-pinned listen network ("tcp4"/"tcp6") was given an explicit host literal of the other address family — e.g. Server::listen("tcp4", "[::1]:80"). Go’s net.Listen rejects the same mismatch (tcp4 binds only IPv4 addresses, tcp6 only IPv6). A bare ":port" never trips this: it is filled with the family’s own wildcard host first.

Fields

addr: String

The offending address string, whose family differs from the network’s.

want: &'static str

The address family the …4/…6 network required: "IPv4" (tcp4) or "IPv6" (tcp6).

UnsupportedNetwork

A Go-style dial network string was not one of the supported "tcp"/"tcp4"/"tcp6"/"udp"/"udp4"/"udp6" (Go’s Dial likewise rejects an unknown network). Reported by Server::dial at the facade boundary, before the device is started.

Fields

network: String

The offending network string.

InvalidNetwork

The Go-style network string was not one the call accepts. Server::listen takes a stream network ("tcp", "tcp4", "tcp6"); Server::listen_packet a packet network ("udp", "udp4", "udp6"). An unknown string, or the wrong transport for the call (e.g. "udp" passed to listen), lands here — mirroring Go’s net.Listen/net.ListenPacket rejecting a bad network with net.UnknownNetworkError.

Fields

network: String

The offending network string.

Store(Error)

The StateStore backing Server::dir/Server::store failed an I/O operation.

State(Error)

The persisted node identity could not be (de)serialized.

Logout(LogoutError)

A Server::logout call failed.

Loopback(Error)

The loopback proxy / in-process LocalAPI HTTP server hit an I/O error (binding its 127.0.0.1 listener, or a LocalClient request to it).

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl From<Error> for Error

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for ListenFunnelError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for ListenServiceError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<LogoutError> for Error

fn from(source: LogoutError) -> Self

Converts to this type from the input type.

impl From<RegistrationError> for Error

fn from(source: RegistrationError) -> Self

Converts to this type from the input type.