Enum ErrorClass 

pub enum ErrorClass {
    Retryable,
    Permanent,
    Ambiguous,
}

Classification of errors encountered during publishing.

Error classification determines whether a publish attempt should be retried. Some errors are permanent (retrying won’t help) while others are transient (likely to succeed on retry).

Example

use shipper::types::ErrorClass;

// Network issues, rate limiting - worth retrying
let retryable = ErrorClass::Retryable;

// Invalid credentials, version conflict - won't succeed on retry
let permanent = ErrorClass::Permanent;

// Unclear - may or may not be retryable
let ambiguous = ErrorClass::Ambiguous;

Classification is a hint, not truth

This enum is produced by parsing cargo’s stdout/stderr — a human-facing log that is explicitly not a stable machine protocol. Pattern-matching on cargo text gives Shipper a fast first-pass signal, but it must never be treated as the final word on what actually happened:

• ErrorClass::Permanent and ErrorClass::Retryable are still hints — they drive retry scheduling, but every retry attempt re-checks the registry before and after the next cargo publish.
• ErrorClass::Ambiguous is the dangerous case. Cargo’s publish flow uploads to the registry first and polls the index afterwards; the poll can time out without affecting the upload. So a non-zero cargo exit can coexist with a successful upload. Ambiguous outcomes MUST be reconciled against registry truth before any further action — never blind-retry. See ReconciliationOutcome and the reconciliation flow in shipper::engine::parallel::reconcile.

The authoritative classification for Ambiguous outcomes comes from querying the registry (sparse index + API) after the fact. Cargo stderr is a signal; the registry is the source of truth.

Classification Heuristics (hints)

Shipper uses various heuristics to classify errors:

• HTTP 429 (Too Many Requests) → Retryable
• HTTP 401/403 (Auth errors) → Permanent
• HTTP 409 (Version conflict) → Permanent
• Network timeouts → Retryable
• Unknown errors → Ambiguous (triggers registry reconciliation)

Variants

Retryable

Permanent

Ambiguous

Trait Implementations

impl Clone for ErrorClass

fn clone(&self) -> ErrorClass

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ErrorClass

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ErrorClass

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ErrorClass

fn eq(&self, other: &ErrorClass) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ErrorClass

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ErrorClass

impl StructuralPartialEq for ErrorClass