Enum CatalogError 

pub enum CatalogError {
    AlreadyExists {
        name_version: String,
    },
    InvalidNameVersion {
        name_version: String,
        reason: String,
    },
    RetiredWithDifferentContent {
        name_version: String,
        previous_hash: String,
        new_hash: String,
    },
    NotFound {
        name_version: String,
        did_you_mean: Vec<String>,
    },
    UnqualifiedName {
        name: String,
    },
    CorruptIndex {
        path: PathBuf,
        reason: String,
    },
    UnrecognizedArtifact {
        path: PathBuf,
        header: Vec<u8>,
    },
    UninspectableArtifact {
        path: PathBuf,
        reason: String,
    },
    MalformedHash {
        hash: String,
    },
    Io(Error),
}

Something went wrong reading, writing, or resolving through the catalog.

Variants

AlreadyExists

name@version was already catalogued; versions are immutable once published.

Fields

name_version: String

The name@version that was already present.

InvalidNameVersion

The identifier handed to add is not a well-formed name@version.

Fields

name_version: String

The identifier that was rejected.

reason: String

Why it was rejected, as a sentence fragment.

RetiredWithDifferentContent

name@version was published, then removed, and is now being re-added with different content. Removing an entry drops it from the index but does not un-publish the identity, so this is still the immutability violation AlreadyExists guards against — just spread over two steps.

Fields

name_version: String

The name@version being re-added.

previous_hash: String

The hash it was published with originally.

new_hash: String

The hash of the artifact now being offered.

NotFound

No entry matches the requested name@version.

Fields

name_version: String

The name@version that was requested.

did_you_mean: Vec<String>

Names within edit distance 2 of the requested one, closest first, capped at 5. Empty when nothing is close.

UnqualifiedName

An unqualified name was used somewhere that requires an exact version (resolving a node reference already recorded inside a bundle’s manifest — see ResolutionContext::Durable).

Fields

name: String

The unqualified name that was rejected.

CorruptIndex

The catalog’s own index.json failed to parse.

Fields

path: PathBuf

Path to the unreadable index file.

reason: String

What went wrong parsing it.

UnrecognizedArtifact

The artifact’s magic bytes match neither a wasm module nor a bundle.

Fields

path: PathBuf

The path that was handed to add.

header: Vec<u8>

The first bytes actually seen.

UninspectableArtifact

The artifact’s magic bytes were recognised, but its contents could not be read: a wasm-magic file whose module body is truncated or otherwise invalid, or a bundle-magic file whose manifest JSON fails to parse. Distinct from CorruptIndex (that’s the catalog’s own bookkeeping file, not an input artifact) and from UnrecognizedArtifact (that’s the magic byte itself not matching anything).

Fields

path: PathBuf

The path that was handed to add, or a synthetic label standing in for one — read_bundle_signature takes a label: &str that need not be a real filesystem path. add always passes a real on-disk path, but pipeline::check calls it with a stage’s display name, which for a Cataloged stage (built by pipeline::resolve_and_load from a bare catalog name, not a filesystem path) is just that bare name.

reason: String

What went wrong reading past the magic bytes.

MalformedHash

An entry’s hash came back from index.json in a shape that isn’t a well-formed sha256 digest (64 lowercase hex digits, optionally prefixed with sha256:) — the exact shape write_blob always produces. index.json is never format-validated on read, so a hand-edited or maliciously crafted index could otherwise smuggle ../ traversal or an absolute path into a filesystem join; this is the guard that rejects it before that ever happens. Distinct from CorruptIndex (that’s index.json failing to parse as JSON at all; this is JSON that parses fine but whose hash field is nonsense).

Fields

hash: String

The invalid hash value, exactly as found in the entry.

Io(Error)

Underlying I/O failure — a plain failure to open/read/write a path, before any catalog-specific logic ever inspects the bytes.

Trait Implementations

impl Debug for CatalogError

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

Formats the value using the given formatter.

impl Display for CatalogError

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

Formats the value using the given formatter.

impl Error for CatalogError

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<CatalogError> for PipelineError

fn from(source: CatalogError) -> Self

Converts to this type from the input type.

impl From<Error> for CatalogError

fn from(source: Error) -> Self

Converts to this type from the input type.