Enum Error 

#[non_exhaustive]
pub enum Error {
    Io(Error),
    NotActive,
    StageRefused(StageError),
    Config(String),
    Disabled,
    InvalidPublicKey,
    ManifestSignature(String),
    ManifestParse(Error),
    ManifestInvalid(String),
    Http(Error),
    HttpStatus {
        status: u16,
        url: String,
    },
    ResponseTooLarge {
        url: String,
        limit: u64,
    },
    ArchiveSize {
        declared: u64,
        actual: u64,
    },
    ArchiveSha256 {
        declared: String,
        actual: String,
    },
    Extract(ExtractError),
}

Errors surfaced by the hot-update plugin.

Every verification gate in the update pipeline is a hard stop with its own variant — a failed signature, hash, or size check aborts the update; there is no warn-and-continue path anywhere in this module.

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.

Io(Error)

NotActive

The plugin was not initialized: either install() was not called on the context, or .plugin(init(handle)) was not registered, or initialization failed at boot (in which case the app serves the embedded bundle — the fail-safe floor).

StageRefused(StageError)

A staging request was refused by the state machine gates.

Config(String)

Invalid plugins.hot-update configuration. Raised from the plugin’s setup hook, so it aborts app startup — config ships inside the store binary and must be caught on the developer’s first run.

Disabled

check/download was invoked while the plugin is disabled by config (plugins.hot-update.enabled is false).

InvalidPublicKey

A configured trusted public key is not valid minisign key material. This is a hard stop even when other keys in the list would verify: silently skipping a malformed trust anchor would weaken the key list without anyone noticing.

ManifestSignature(String)

The manifest signature failed: undecodable .minisig data, or no key in the trusted list verified the manifest bytes.

ManifestParse(Error)

The signed manifest bytes are not valid JSON for the manifest schema.

ManifestInvalid(String)

The manifest parsed but declares nonsensical values (malformed sha256, zero or over-cap archive size).

Http(Error)

Transport-level HTTP failure (connect, TLS, read).

HttpStatus

The update server answered with a non-success status.

Fields

status: u16

url: String

ResponseTooLarge

A response body exceeded its sanity cap (manifest or signature).

Fields

url: String

limit: u64

ArchiveSize

The downloaded archive’s byte count diverged from the signed manifest’s archive.size (short body, or a stream that kept going).

Fields

declared: u64

actual: u64

ArchiveSha256

The downloaded archive’s sha256 diverged from the signed manifest.

Fields

declared: String

actual: String

Extract(ExtractError)

Archive extraction was refused (hostile entry) or failed.

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 Error

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<ExtractError> for Error

fn from(source: ExtractError) -> Self

Converts to this type from the input type.

impl From<StageError> for Error

fn from(source: StageError) -> Self

Converts to this type from the input type.

impl Serialize for Error

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.