Enum CatalogError 

pub enum CatalogError {
    AlreadyExists {
        name_version: String,
    },
    InvalidNameVersion {
        name_version: String,
        reason: String,
    },
    InvalidBlockName {
        name: 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.

InvalidBlockName

The name handed to cuttlefish block new isn’t legal as a directory basename on every platform this project supports, or wouldn’t survive as the crate-name component of cf-block-<name> under the Rust authoring path. Distinct from InvalidNameVersion: a block name never has an @version half, so reusing that variant’s “is not a name@version” wording here would misdescribe the failure.

Fields

name: String

The name 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 kind was determined (by magic bytes for Block/ Bundle, or by .rhai extension for Script), but its contents could not be read: a wasm-magic file whose module body is truncated or otherwise invalid, a bundle-magic file whose manifest JSON fails to parse, or a .rhai file with no (or an unparseable) //! signature: ... header comment — Script has no magic bytes at all, so this variant is not solely about magic-byte-recognized artifacts. Distinct from CorruptIndex (that’s the catalog’s own bookkeeping file, not an input artifact) and from UnrecognizedArtifact (that’s the artifact’s kind not being identifiable at all — neither magic bytes nor a recognized extension).

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.