Struct LockFile 

pub struct LockFile { /* private fields */ }

Exclusive lock file created by this process.

Drop without Self::commit or Self::commit_to removes the lock file when this handle created it. Foreign lock files are never removed.

Implementations

impl LockFile

pub fn acquire(target: &Path, wait: LockWait) -> Result<Self, LockError>

Create target exclusively (O_CREAT|O_EXCL), optionally waiting per wait.

target is the lock file path (for example refs/heads/main.lock), not the file being updated. Persist staged bytes with Self::commit_to (or Self::commit after Self::with_commit_target).

Errors

Returns LockError::Held when the lock exists and the wait budget is exhausted, or LockError::Io for other failures.

pub fn acquire_with_clock( target: &Path, wait: LockWait, clock: Arc<dyn LockClock>, jitter: Arc<dyn LockJitter>, ) -> Result<Self, LockError>

Like Self::acquire, with injectable clock and jitter for unit tests.

pub fn with_commit_target(self, path: &Path) -> Self

Set the destination path used by Self::commit.

pub fn lock_path(&self) -> &Path

Path to the lock file held by this handle.

pub fn as_file(&self) -> Result<&File, LockError>

Borrow the open lock file for writing.

Errors

Returns LockError::Io when the handle was already taken (for example after the open file handle was moved out for index integration).

pub fn as_file_mut(&mut self) -> Result<&mut File, LockError>

Borrow the open lock file mutably for writing.

Errors

Returns LockError::Io when the handle was already taken.

pub fn commit(self) -> Result<(), LockError>

Fsync the lock file, rename it over commit_path from Self::with_commit_target, and disarm drop cleanup.

Errors

Returns LockError::Io when no commit target was configured or rename fails.

pub fn commit_to(self, other_path: &Path) -> Result<(), LockError>

Fsync the lock file and atomically rename it over other_path.

Errors

Returns LockError::Io on sync or rename failure.

pub fn write_holder_pid(&mut self) -> Result<(), LockError>

Record this process as the holder of Self::lock_path in a Git-compatible pid sidecar.

Errors

Returns LockError::Io when the sidecar cannot be written.

pub fn rollback(self)

Release the lock without committing (same as drop).

pub fn detach(self)

Close this handle but leave the lock file on disk (mutex-only locks).

Trait Implementations

impl Drop for LockFile

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Write for LockFile

fn write(&mut self, buf: &[u8]) -> Result<usize>

Writes a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flushes this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.