Struct Flock

pub struct Flock<T: Flockable>(/* private fields */);

Represents an owned flock, which unlocks on drop.

See flock(2) for details on locking semantics.

Implementations

impl<T: Flockable> Flock<T>

pub fn lock(t: T, args: FlockArg) -> Result<Self, (T, Errno)>

Obtain a/an flock.

Example

  let mut file = match Flock::lock(file, FlockArg::LockExclusive) {
      Ok(l) => l,
      Err(_) => return,
  };

  // Do stuff
  let data = "Foo bar";
  _ = file.write(data.as_bytes());
  _ = file.sync_data();

pub fn unlock(self) -> Result<T, (Self, Errno)>

Remove the lock and return the object wrapped within.

Example

fn do_stuff(file: File) -> nix::Result<()> {
    let mut lock = match Flock::lock(file, FlockArg::LockExclusive) {
        Ok(l) => l,
        Err((_,e)) => return Err(e),
    };

    // Do critical section

    // Unlock
    let file = match lock.unlock() {
        Ok(f) => f,
        Err((_, e)) => return Err(e),
    };

    // Do anything else

    Ok(())
}

pub fn relock(&self, arg: FlockArg) -> Result<()>

Relock the file. This can upgrade or downgrade the lock type.

Example

let f: std::fs::File = tempfile().unwrap();
let locked_file = Flock::lock(f, FlockArg::LockExclusive).unwrap();
// Do stuff, then downgrade the lock
locked_file.relock(FlockArg::LockShared).unwrap();

Trait Implementations

impl<T: Debug + Flockable> Debug for Flock<T>

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

Formats the value using the given formatter.

impl<T: Flockable> Deref for Flock<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Flockable> DerefMut for Flock<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Flockable> Drop for Flock<T>

fn drop(&mut self)

Executes the destructor for this type.