Struct DistributedRWLock 

pub struct DistributedRWLock { /* private fields */ }

Distributed read-write lock for coordinating operations across multiple processes

This implementation uses etcd atomic transactions to prevent race conditions:

• Write locks are exclusive (no readers or writers can coexist)
• Read locks are shared (multiple readers allowed, but no writers)
• All lock operations use atomic compare-and-set to ensure correctness
• Locks are bound to leases for automatic cleanup on client failure

Implementations

impl DistributedRWLock

pub fn new(lock_prefix: String) -> Self

Create a new distributed RWLock with the given prefix

The lock will create keys under:

• v1/{prefix}/writer for the write lock
• v1/{prefix}/readers/{reader_id} for read locks

pub async fn try_write_lock<'a>( &'a self, etcd_client: &'a Client, ) -> Option<WriteLockGuard<'a>>

Try to acquire exclusive write lock (non-blocking)

Returns Some(WriteLockGuard) if acquired, None if readers exist or lock unavailable. The guard automatically releases the lock when dropped.

Implementation strategy:

1. Atomically create writer key if it doesn’t exist
2. Immediately check if any readers exist
3. If readers found, rollback (delete writer key) and return None

Note: There is still a small race window (sub-millisecond) where a reader could acquire a lock between steps 2-3.

pub async fn read_lock_with_wait<'a>( &'a self, etcd_client: &'a Client, reader_id: &str, timeout: Option<Duration>, ) -> Result<ReadLockGuard<'a>>

Acquire shared read lock with polling retry

Polls every 100ms until write lock is released, then atomically acquires read lock. The guard automatically releases the lock when dropped. Uses atomic transaction to prevent race with writer - the check for no write lock and creation of read lock happen in a single atomic operation.

Arguments

• etcd_client - The etcd client
• reader_id - Unique identifier for this reader
• timeout - Optional timeout, defaults to 5 seconds

Trait Implementations

impl Clone for DistributedRWLock

fn clone(&self) -> DistributedRWLock

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.