Enum RefStoreError 

#[non_exhaustive]
pub enum RefStoreError {
    ReflogRewriteStale {
        name: String,
    },
    LockHeld {
        name: String,
    },
    ExpectedMismatch {
        name: String,
        expected: Expected,
        actual: Option<RawRef>,
    },
    NameUnavailable {
        reason: RefnameUnavailable,
    },
    DuplicateUpdate {
        name: String,
    },
    SymrefLoop,
    NotFound {
        name: String,
    },
    Corrupt(String),
    GitDirPathIo {
        path: String,
        operation: GitDirPathOperation,
        os_error: i32,
    },
    InvalidRefName {
        name: String,
    },
    InvalidSymrefTarget {
        name: String,
        target: String,
    },
    NullOid {
        name: String,
    },
    MissingObject {
        name: String,
        oid: ObjectId,
    },
    NotACommit {
        name: String,
        oid: ObjectId,
        kind: ObjectKind,
    },
    ObjectLookup {
        name: String,
        oid: ObjectId,
        source: BackendError,
    },
    InvalidReflog(SignatureError),
    Backend(BackendError),
    Hook(ReferenceTransactionHookErr),
}

Failure modes for reference store reads and transactions.

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.

ReflogRewriteStale

Reflog contents changed between a snapshot and a locked super::RefStore::rewrite_reflog re-read. Callers that compare against an earlier snapshot should retry.

Fields

name: String

Ref whose log no longer matched the expected prefix.

LockHeld

Another writer holds a lock this transaction needs.

For per-ref backends (files) that is the lock of name itself; for a backend with one writer slot for the whole store (super::MemoryRefStore, a database with a single write transaction) it means that slot is busy, whichever refs the holder updates. Transient: crate::refs::prepare_with_lock_wait retries it.

Fields

name: String

A ref of the failed transaction: the locked ref, or the transaction’s first ref when the whole store is locked. Always one of the failed transaction’s own refs.

ExpectedMismatch

Compare-and-swap or existence check failed for an update.

Fields

name: String

Ref that failed the check.

expected: Expected

What the caller required.

actual: Option<RawRef>

What was observed (None when the ref is absent).

NameUnavailable

A ref name cannot be created because of a directory/file conflict.

Fields

reason: RefnameUnavailable

Structured conflict reason (Git refs_verify_refname_available style).

DuplicateUpdate

The same ref name appears more than once in one transaction.

Fields

name: String

Duplicate ref name.

SymrefLoop

Symbolic reference resolution exceeded crate::refs::SYMREF_MAXDEPTH.

NotFound

The ref (or the target at the end of its symbolic chain) does not exist.

Fields

name: String

Name of the missing ref: the requested name, or the dangling symbolic target.

Corrupt(String)

Stored data for a ref or reflog is malformed.

GitDirPathIo

Filesystem I/O on a git-directory path during ref store work.

Fields

path: String

Display path such as .git/refs/heads/main or .git/worktrees/wt/HEAD.lock.

operation: GitDirPathOperation

What the operation was trying to do when I/O failed.

os_error: i32

Raw OS error code from the failing I/O call.

InvalidRefName

Ref name is not safe to store (traversal, illegal component, etc.).

Every backend checks update names and both sides of reflog and case-only renames in super::RefStore::prepare, before taking locks.

Fields

name: String

The rejected ref name.

InvalidSymrefTarget

A symbolic ref would point at a target Git refuses (outside refs/ for HEAD, not safe to store, or the same name as the ref being updated).

Fields

name: String

The ref being updated.

target: String

The symbolic target that was rejected.

NullOid

An update would store the all-zero (null) object id as a direct ref value.

The null id names no object, so Git treats such a ref as broken. Delete a ref with new_value: None instead. Reflog-only updates (super::RefUpdateFlags::log_only) may still carry the null id.

Fields

name: String

The ref the update targeted.

MissingObject

An update would point a ref at an object the repository does not store.

Raised by the stores a crate::repo::Repository hands out (see super::RefStore::prepare); the bare backends do not look at objects. Set super::RefUpdateFlags::skip_oid_verification to write such a ref on purpose.

Fields

name: String

The ref the update targeted.

oid: ObjectId

The object id the update would store.

NotACommit

An update would point a branch (refs/heads/…) or HEAD at something other than a commit.

Checked alongside Self::MissingObject. Tags, remote-tracking and other refs may name any object.

Fields

name: String

The branch or HEAD the update targeted.

oid: ObjectId

The object id the update would store.

kind: ObjectKind

What oid actually is.

ObjectLookup

Looking up the object an update would store failed (unreadable pack, I/O, a failing custom object store), so the update could not be checked.

Fields

name: String

The ref the update targeted.

oid: ObjectId

The object id the update would store.

source: BackendError

The object database error, downcastable to crate::error::Error.

InvalidReflog(SignatureError)

Reflog identity or message would forge or corrupt a log line.

Backend(BackendError)

A custom backend’s own storage failed (database, network, …).

Built-in backends never return this; their I/O failures stay typed elsewhere.

Hook(ReferenceTransactionHookErr)

A reference-transaction hook refused or could not run on the prepared phase.

Implementations

impl RefStoreError

pub fn backend(err: impl Error + Send + Sync + 'static) -> Self

Wrap a custom backend’s storage error as Self::Backend.

Trait Implementations

impl Clone for RefStoreError

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RefStoreError

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

Formats the value using the given formatter.

impl Display for RefStoreError

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

Formats the value using the given formatter.

impl Eq for RefStoreError

impl Error for RefStoreError

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<BackendError> for RefStoreError

fn from(err: BackendError) -> Self

Converts to this type from the input type.

impl From<RefStoreError> for Error

fn from(err: RefStoreError) -> Self

Converts to this type from the input type.

impl From<RefnameUnavailable> for RefStoreError

fn from(reason: RefnameUnavailable) -> Self

Converts to this type from the input type.

impl From<SignatureError> for RefStoreError

fn from(source: SignatureError) -> Self

Converts to this type from the input type.

impl PartialEq for RefStoreError

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RefStoreError