impl<T: Flockable> Flock<T>

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

Obtain a/an flock.

Example

# use std::io::Write;
# use std::fs::File;
# use nix::fcntl::{Flock, FlockArg};
# fn do_stuff(file: File) {
  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();
# }

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

Remove the lock and return the object wrapped within.

Example

# use std::fs::File;
# use nix::fcntl::{Flock, FlockArg};
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(())
}

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

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

Example

# use std::fs::File;
# use nix::fcntl::{Flock, FlockArg};
# use tempfile::tempfile;
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();