use std::os::raw::c_int;
pub const LOCK_EX: c_int = 2;
pub const LOCK_NB: c_int = 4;
pub const LOCK_UN: c_int = 8;
extern "C" {
pub fn flock(fd: c_int, operation: c_int) -> c_int;
}
use std::fs::File;
use std::io;
use std::os::unix::io::{AsRawFd, RawFd};
use crate::flock::{flock, LOCK_EX, LOCK_NB, LOCK_UN};
pub struct FileLock {
file: File,
}
pub struct FileLockGuard<'a> {
_file: &'a File,
fd: RawFd,
}
impl FileLock {
pub fn new(file: File) -> Self {
FileLock { file }
}
pub fn acquire(&self) -> io::Result<FileLockGuard<'_>> {
self.lock_with(LOCK_EX)
}
pub fn try_acquire(&self) -> io::Result<FileLockGuard<'_>> {
self.lock_with(LOCK_EX | LOCK_NB)
}
fn lock_with(&self, op: i32) -> io::Result<FileLockGuard<'_>> {
let fd = self.file.as_raw_fd();
let rc = unsafe { flock(fd, op) };
if rc != 0 {
return Err(io::Error::last_os_error());
}
Ok(FileLockGuard { _file: &self.file, fd })
}
}
impl<'a> Drop for FileLockGuard<'a> {
fn drop(&mut self) {
unsafe {
// Best-effort release; a destructor cannot propagate errors.
let _ = flock(self.fd, LOCK_UN);
}
}
}
mod flock;
mod lock;
use std::fs::OpenOptions;
use std::io::{self, Write};
use lock::FileLock;
fn main() -> io::Result<()> {
let file = OpenOptions::new()
.create(true)
.write(true)
.open("/tmp/pipeline.lock")?;
let lock = FileLock::new(file);
{
let guard = lock.acquire()?;
run_critical_section()?;
println!("work done, releasing at end of scope");
drop(guard); // explicit for clarity; would drop here anyway
}
match lock.try_acquire() {
Ok(_guard) => println!("re-acquired without contention"),
Err(e) => eprintln!("still locked: {}", e),
}
Ok(())
}
fn run_critical_section() -> io::Result<()> {
let mut stdout = io::stdout();
writeln!(stdout, "holding exclusive lock")?;
Ok(())
}
This snippet shows the RAII (Resource Acquisition Is Initialization) pattern applied to an advisory file lock, where acquiring the lock produces a guard whose Drop implementation releases it automatically when the guard leaves scope. The core idea is that ownership tracks the lock's lifetime: as long as the guard value lives, the lock is held; the moment it is dropped — normally, via early return, or during an unwinding panic — the destructor runs and the lock is freed. This eliminates the classic bug of forgetting to unlock, or leaking a lock on an error path.
In flock.rs, the FFI declarations pull in flock from libc along with the LOCK_EX, LOCK_UN, and LOCK_NB constants. Wrapping raw C calls behind a tiny extern block keeps the unsafe surface small and explicit. The flock syscall places an advisory lock on an open file descriptor, so the lock is tied to the descriptor rather than the path, which matters for the guard design.
In lock.rs, FileLock owns a File and exposes acquire, which blocks, and try_acquire, which uses LOCK_NB to fail fast when the lock is contended. Both return a FileLockGuard that borrows the lock, so the borrow checker prevents a second acquisition while the guard exists. The guard holds only &'a File and a RawFd, keeping it cheap to move. Its Drop impl calls flock(fd, LOCK_UN) exactly once; the return value is deliberately ignored because a destructor cannot propagate errors and must not panic. Using as_raw_fd rather than closing the File ensures the descriptor stays valid for the parent FileLock.
A subtle point is unlock-on-panic: because Rust runs destructors during stack unwinding, the lock is released even if the guarded critical section panics, which a manual unlock() call would miss. The trade-off is that advisory locks only coordinate cooperating processes and are not enforced by the kernel against arbitrary writers.
In main.rs, a nested scope demonstrates the lifetime: the guard is created inside a block, the critical section runs, and the lock is provably released at the closing brace before the next try_acquire runs. This is exactly when a developer reaches for RAII guards — any resource with a clear paired acquire/release that must survive early returns and panics.
Related snips
struct Config<'a> {
name: &'a str,
value: &'a str,
}
fn parse_config(line: &str) -> Config {Lifetime annotations for flexible borrowing in structs
use crossbeam::channel::unbounded;
use std::thread;
fn main() {
let (tx, rx) = unbounded();Crossbeam for advanced concurrent data structures
// Creating a Promise
const myPromise = new Promise((resolve, reject) => {
const success = true;
setTimeout(() => {
if (success) {Promises and async/await patterns for asynchronous JavaScript
use tracing::{info, instrument};
#[instrument]
fn process_request(user_id: u64) {
info!(user_id, "Processing request");
// Work happens heretracing for structured logging and distributed tracing
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();Channels (mpsc) for message passing between threads
use clap::Parser;
#[derive(Parser, Debug)]
#[command(author, version, about)]
struct Args {
#[arg(short, long)]clap for CLI argument parsing with derive macros
Share this code
Here's the card — post it anywhere.
