Struct RealIndexLock 

pub struct RealIndexLock { /* private fields */ }

What: A real index.lock created by this process. Why: Holding the identity lets the release prove the file is still the one created.

In TS you’d write (pseudocode):

type RealIndexLock = { lockPath: string; identity: LockIdentity; installIndex(source): Promise<void> };

Implementations

impl RealIndexLock

pub fn identity(&self) -> &LockIdentity

What: The identity recorded for the lock. Why: The landing journal stores it.

In TS you’d write (pseudocode):

lock.identity

pub fn assert_identity(&self) -> Result<(), String>

What: Whether the lock path still names the file this process created. Why: A release or install must not act on a replaced lock.

In TS you’d write (pseudocode):

await assertLockIdentity({ lockPath, identity });

pub fn release(self) -> Result<(), String>

What: Release the lock and this process’s PID file, refusing a lock that was replaced. Why: A replaced lock belongs to another process and stays in place.

In TS you’d write (pseudocode):

await lock[Symbol.asyncDispose]();

pub fn install(self, post_index: &Path) -> Result<(), RecoveryError>

What: Install a computed index through the held lock, consuming the lock, then remove this process’s PID file. Why: installIndex: the bytes are written into the lock this process created, the lock is linked under a private name beside the post-index, and that name is renamed over the real index, so the new index keeps the lock’s owner. The lock is not released here on failure: once the landing record is durable, recovery completes the install through the same lock.

In TS you’d write (pseudocode):

await lock.installIndex(postIndexPath);

pub fn release_after_landing(self) -> Result<(), String>

What: Release a lock a landing leaves without installing: the lock is removed only while it is still the file this process created, and the PID file goes either way. Why: The incumbent’s disposal warns when the lock is gone or another owner’s now and still removes its own PID file, and throws only for an operating-system error.

In TS you’d write (pseudocode):

await lock[Symbol.asyncDispose]();

Trait Implementations

impl Debug for RealIndexLock

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

Formats the value using the given formatter.

impl Eq for RealIndexLock

impl PartialEq for RealIndexLock

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RealIndexLock