Struct ProcessLock 

pub struct ProcessLock(/* private fields */);

An exclusive OS file lock, released when this value is dropped.

Every participant must use the same persistent path in an application-owned directory. Neither this type nor a caller may unlink or replace the lock file: another process could still hold a lock on the original inode. Keep this guard alive through endpoint cleanup and the work it protects. Use separate paths for daemon ownership and upgrade serialization.

Implementations

impl ProcessLock

pub fn try_acquire(path: impl AsRef<Path>) -> Result<Option<Self>>

Acquire without waiting, creating the file if necessary.

Returns Ok(None) only for contention; filesystem and locking failures remain errors. The parent directory must already exist.

pub fn acquire_until( path: impl AsRef<Path>, deadline: Instant, ) -> Result<Option<Self>>

Acquire, waiting until deadline for the holder to release the lock.

Opens the file as Self::try_acquire does. Returns Ok(None) if the lock is still held at the deadline; a deadline already passed still gets one attempt, and no later attempt is made after it. The OS signals no release, so contention is rechecked after a pause that grows to 50 ms.

pub fn acquire_private_until( path: impl AsRef<Path>, deadline: Instant, ) -> Result<Option<Self>>

Self::acquire_until for a lock file private to this user.

Refuses a lock file that is a symlink, or a junction on Windows. On Unix the file must also belong to the effective user, and its mode becomes 0600. Either refusal is PermissionDenied. Directories on the path are not checked: keep the lock in a private application-owned directory. On Windows nothing about access is checked: a new file inherits the directory’s ACL, but an existing lock file keeps its own, so the caller must secure a lock file it did not create.

pub fn try_from_file(file: File) -> Result<Option<Self>>

Lock an already-open file. This preserves a consumer’s secure open policy.

pub fn is_held(path: impl AsRef<Path>) -> Result<bool>

Observe an existing lock without creating a file. Only contention is true.

The check takes the lock and releases it at once. A process that tries to acquire it during that moment sees contention.

pub fn wait_released_until( path: impl AsRef<Path>, deadline: Instant, ) -> Result<bool>

Wait until no process holds the lock, or deadline passes. True once it is free; a missing lock file is free, and none is created.

Like Self::is_held, each check takes the lock for a moment, and the lock is not kept: another process may take it before the caller acts. Failing to open the file is an error, not a release.

Trait Implementations

impl Debug for ProcessLock

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

Formats the value using the given formatter.

impl Drop for ProcessLock

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.