Struct ReftableRefStore 

pub struct ReftableRefStore { /* private fields */ }

On-disk ref storage using the reftable backend (extensions.refStorage = reftable).

Atomicity

Refs live in one reftable stack per location: the common stack in the repository’s git directory, and in a linked worktree a second stack under worktrees/<id>/ for HEAD and other per-worktree refs. A transaction touching one stack commits as a single new table, so readers see all of it or none of it.

A transaction touching both stacks (for example updating HEAD in a linked worktree, which writes the branch in the common stack and logs HEAD in the worktree stack) takes the tables.list lock of every stack in RefStore::prepare, so no other writer can interleave, and all checks pass before anything is written. Commit then writes one table per stack, common stack first. These writes are not atomic together: if a later write fails (an I/O error), PreparedRefTransaction::commit returns the error, the earlier stacks keep their new table, and every remaining lock is released. For a HEAD update this means the branch already points at the new commit with its reflog line, HEAD still resolves to it through the symbolic ref, and only HEAD’s own reflog line is missing.

Implementations

impl ReftableRefStore

pub fn open(git_dir: PathBuf) -> Result<Self>

Open the reftable store for an existing repository git directory.

Errors

Returns Error::Io when the reftable stack cannot be read.

pub fn open_ephemeral() -> Result<Self>

Create a new ephemeral reftable repository (tests).

Errors

Returns an error when initialization fails.

pub fn write_reftable_updates( &self, updates: Vec<ReftableTransactionUpdate>, ) -> Result<(), RefStoreError>

Write low-level reftable transaction updates (used by legacy reftable_* helpers).

Errors

Propagates lock, CAS, and I/O failures from the underlying stack.

Trait Implementations

impl Debug for ReftableRefStore

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

Formats the value using the given formatter.

impl RefStore for ReftableRefStore

fn format(&self) -> RefStorageFormat

Which on-disk or logical format this store uses.

fn read_raw(&self, name: &str) -> Result<Option<RawRef>>

Read the stored value for name without resolving symbolic targets.

fn for_each_ref( &self, prefix: &str, f: &mut dyn FnMut(&RefEntry) -> ControlFlow<()>, ) -> Result<()>

Invoke f for each ref whose name starts with prefix, in sorted name order.

fn for_each_physical_stack_ref( &self, prefix: &str, f: &mut dyn FnMut(&RefEntry) -> ControlFlow<()>, ) -> Result<()>

Walk refs stored in this handle’s physical reftable stack (reftable/ under the store git directory). On the files backend this matches Self::for_each_ref.

fn prepare( &self, txn: RefTransaction, ) -> Result<Box<dyn PreparedRefTransaction + Send + '_>, RefStoreError>

Validate txn, take locks, and return a committable batch.

fn reflog_exists(&self, name: &str) -> Result<bool>

Whether a reflog is present for name.

fn for_each_reflog_entry( &self, name: &str, reverse: bool, f: &mut dyn FnMut(&ReflogEntry) -> ControlFlow<()>, ) -> Result<()>

Iterate reflog entries for name (oldest first unless reverse).

fn create_reflog(&self, name: &str) -> Result<()>

Create an empty reflog file/record for name.

fn delete_reflog(&self, name: &str) -> Result<()>

Remove the reflog for name.

fn replace_reflog(&self, name: &str, entries: Vec<ReflogEntry>) -> Result<()>

Replace the entire reflog (used by expire/delete-entries).

fn rewrite_reflog( &self, name: &str, transform: &mut dyn FnMut(Vec<ReflogEntry>) -> Result<Vec<ReflogEntry>>, ) -> Result<()>

Read a reflog under the backend writer lock, transform it, and write it back atomically.

fn for_each_reflog_ref( &self, f: &mut dyn FnMut(&str) -> ControlFlow<()>, ) -> Result<()>

Invoke f for each ref name that has a reflog, in sorted order.

fn resolve(&self, name: &str) -> Result<ObjectId>

Resolve name to an object id, following symbolic refs.

fn verify_update_targets( &self, updates: &[RefUpdate], ) -> Result<(), RefStoreError>

Check the objects updates would point refs at, without taking any lock or writing.

fn as_files(&self) -> Option<&FilesRefStore>

The files backend behind this store, when it is one.

fn ref_lock_wait(&self) -> LockWait

How long grit-lib retries RefStoreError::LockHeld from Self::prepare.