Struct Store 

pub struct Store { /* private fields */ }

A local LFS object store rooted at <lfs_dir> (typically .git/lfs).

May reference any number of alternate stores — typically the LFS objects of a git clone --shared source — and will materialize a hit from one of them into the local store on demand. See Store::with_references.

Implementations

impl Store

pub fn new(lfs_dir: impl Into<PathBuf>) -> Self

Create a store rooted at the given LFS directory. The directory is not created eagerly; subdirectories are created on demand as objects land.

pub fn with_references(self, refs: impl IntoIterator<Item = PathBuf>) -> Self

Attach alternate lfs/objects/ directories that the store may hardlink-or-copy from when a local lookup misses. Used by git clone --shared setups so the new repo can read the source’s existing LFS objects without re-downloading.

Pass git_lfs_git::lfs_alternate_dirs (<git-dir>/objects/info/alternates resolved to LFS-objects dirs) at construction.

pub fn root(&self) -> &Path

Root LFS directory.

pub fn tmp_dir(&self) -> PathBuf

Directory holding temp files for in-flight inserts.

pub fn incomplete_dir(&self) -> PathBuf

Directory holding partial / in-progress downloads. Files are named <oid>.part and persist across process invocations so a later attempt can pick up where a prior one left off (issuing a Range: request). Mirrors upstream’s incomplete/ layout.

pub fn incomplete_path(&self, oid: Oid) -> PathBuf

Path to the partial-download file for oid. The file may not exist; the caller is responsible for creating + writing it.

pub fn commit_partial(&self, oid: Oid, partial: &Path) -> Result<()>

Atomically move a fully-downloaded partial file into its final object-path location. The caller is responsible for confirming the file’s bytes hash to oid first; this is a pure rename. Clobbers any existing file at the destination — see insert_verified for the rationale.

pub fn cleanup_tmp_objects(&self)

Sweep <root>/tmp/objects/ (upstream’s path for in-flight download temp files: <oid>-<random>) and remove any whose leading 64-char OID is already complete in the store.

Best-effort — the dir not existing, or any individual remove failing, is silently ignored. Intended to run once per command invocation, before the command’s main work, so an interrupted prior run doesn’t leak temp files indefinitely (matches upstream’s lfs.cleanupTempFiles startup task).

pub fn object_path(&self, oid: Oid) -> PathBuf

Where the object with this OID lives on disk.

For Oid::EMPTY this returns the platform null device, mirroring upstream’s behavior so callers can open an empty object without special-casing.

pub fn contains(&self, oid: Oid) -> bool

true if this object is present locally as a regular file. The empty OID is always considered present. If the local copy is missing but an alternate store has the object, materializes it locally first.

pub fn contains_with_size(&self, oid: Oid, size: u64) -> bool

true if the object is present and its on-disk size matches size. Used to detect partial/corrupted local copies. Like contains, will fault in a matching alternate-store object on demand.

pub fn each_object(&self) -> Result<Vec<(Oid, u64)>>

Walk every object file in the store, yielding (oid, size_on_disk).

Traverses the sharded objects/<aa>/<bb>/<oid> layout. Filenames that don’t parse as 64-char SHA-256 hex are silently skipped, as are unexpected directories. The store directory not existing is not an error — the result is just empty.

Used by git lfs prune and (eventually) fsck --orphaned.

pub fn open(&self, oid: Oid) -> Result<File>

Open an object for reading. Errors with io::ErrorKind::NotFound if the object isn’t in the store. Faults in from a reference store if needed.

pub fn insert(&self, src: &mut impl Read) -> Result<(Oid, u64), StoreError>

Stream src into the store, computing SHA-256 as we go. Returns the resulting OID and byte count.

This is the clean-filter path: we don’t know the OID until after the content is hashed.

If the resulting OID is already present locally, the temp file is dropped without persisting. The store is content-addressed, so an existing file at that path is necessarily the same bytes; skipping tmp.persist here preserves any hardlink already at the destination (a rename swaps a fresh inode in, which would break the link to the alternate-store source).

pub fn insert_verified( &self, expected: Oid, src: &mut impl Read, ) -> Result<u64, StoreError>

Stream src into the store, requiring the resulting hash to equal expected. On mismatch, returns StoreError::HashMismatch and the temp file is dropped without being committed.

This is the download path: we know the OID upfront and must verify what the server sent.

Trait Implementations

impl Clone for Store

fn clone(&self) -> Store

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Store

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

Formats the value using the given formatter.