Enum Error 

#[non_exhaustive]
pub enum Error {
    Unaskable {
        what: String,
        detail: String,
    },
    Bus {
        op: &'static str,
        target: String,
        source: BoxedCause,
    },
    Io {
        path: PathBuf,
        source: Error,
    },
    Malformed {
        what: String,
        detail: String,
        source: Option<BoxedCause>,
    },
    Internal(String),
}

Why a fleet operation could not answer.

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.

Unaskable

The caller’s input was refused; nothing was attempted. A selector that is not a key expression, a name outside a closed vocabulary, a window of zero seconds, a hostname where an origin belongs.

This is the variant that carries RFC 13 §1’s “the question could not be asked”, and the only one a caller fixes by changing what it passed.

Fields

what: String

What was refused, as the caller named it — a selector, a flag value, an id.

detail: String

Why. This crate’s own words, or a one-line parse refusal inlined from whatever produced it (see the module doc on rendering).

Bus

A bus operation failed: a declare, a get, a put, an undeclare.

The question was asked and the fabric did not carry it. Distinct from Unaskable because retrying is meaningful.

Fields

op: &'static str

The operation, phrased so that {op} {target} reads as the thing that failed — subscribe v1/**, declare queryable …, failed to open the Zenoh session. It is a label, not a zenoh API name.

target: String

What it was against — a key expression, a selector, an origin.

source: BoxedCause

Io

Local filesystem I/O — a .zrec, a registry directory, a config.

Carries the path where there is one, and the io::ErrorKind is reachable through source: “no such directory” and “permission denied” are different answers to give a user.

The path may be empty, and the Display says so rather than rendering to nothing: a writer generic over W: Write (the .zrec sink) genuinely does not know where its bytes are going. An error whose Display is the empty string is not a smaller error — it is a blank Error: line and a blank Caused by: under it.

Fields

path: PathBuf

source: Error

Malformed

Bytes arrived and could not be read as what they claim to be — a .zrec header, a served slice, a reply payload.

Not the caller’s fault and not the fabric’s: a peer said something this build cannot parse.

Fields

what: String

detail: String

This crate’s own words — short, because the parser’s own message rides underneath as the source.

source: Option<BoxedCause>

Internal(String)

An invariant of this crate did not hold.

Every construction site is a place the old code said “a bug in blob_*” or “tasks outlived the run”. Kept as a variant rather than a panic because an explorer that has found a bug in its own engine should still be able to report it rather than die mid-sweep.

Implementations

impl Error

pub fn is_unaskable(&self) -> bool

The caller’s input was refused and nothing was attempted — RFC 13 §1’s “the question could not be asked”.

zenctl maps this to its reserved exit 2. It is a method rather than a matches! at the call site so the mapping has one home, the way judgement_exit_code does for verdicts.

pub fn unaskable(what: impl Into<String>, detail: impl Into<String>) -> Error

An input this crate refuses.

pub fn unaskable_from( what: impl Into<String>, cause: impl Into<BoxedCause>, ) -> Error

An input this crate refuses, explained by the error that refused it — a key-expression parse, a number that would not parse.

pub fn bus( op: &'static str, target: impl Into<String>, cause: impl Into<BoxedCause>, ) -> Error

A bus operation that failed.

pub fn malformed(what: impl Into<String>, detail: impl Into<String>) -> Error

Bytes that did not read as what they claimed to be.

pub fn malformed_from( what: impl Into<String>, cause: impl Into<BoxedCause>, ) -> Error

Likewise, keeping the parser’s own error underneath — where a span or a line number is worth reaching for.

pub fn malformed_with( what: impl Into<String>, detail: impl Into<String>, cause: impl Into<BoxedCause>, ) -> Error

malformed_from where the caller has a better sentence than “does not parse” — is not a header, is not a slice.

pub fn io(path: impl Into<PathBuf>, source: Error) -> Error

Local I/O against a named path.

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<KeyError> for Error

A key this crate built or was handed does not parse.

fn from(e: KeyError) -> Error

Converts to this type from the input type.

impl From<SliceError> for Error

A served slice that does not parse is a peer saying something unreadable, never a local mistake — RFC 08 §6’s introspect reply.

fn from(e: SliceError) -> Error

Converts to this type from the input type.