Struct Mutex

pub struct Mutex<Key: Clone + Send + Sync + Serialize + 'static>(/* private fields */);

A distributed lock that acts like std::sync::Mutex.

Implementations

impl<Key: Clone + Send + Sync + Serialize + 'static> Mutex<Key>

pub async fn new(database: &Database, collection: &str) -> Result<Self, Error>

Constructs a new Mutex.

Errors

When mongodb::Collection::create_index errors.

pub async fn new_uninit(database: &Database, collection: &str) -> Self

Create Mutex without initializing the lock.

This should be used when the lock is already initialized; possibly by another process.

pub async fn lock_default( &self, key: Key, ) -> Result<MutexGuard<'_, Key>, MutexLockError>

Calls Mutex::lock with DEFAULT_TIMEOUT and DEFAULT_WAIT.

Errors

When Mutex::lock errors.

pub async fn lock( &self, timeout: Duration, wait: Duration, key: Key, ) -> Result<MutexGuard<'_, Key>, MutexLockError>

Attempts to lock the given key using the given lock collection.

Since the Mongodb Rust driver doesn’t fully support change streams see https://github.com/mongodb/mongo-rust-driver/issues/1230 a busy polling approach is used where it will attempt to acquire the lock for timeout sleeping wait in between attempts.

In this sense it is like:

let lock = tokio::sync::Mutex::new(());
let timeout = Duration::from_secs(1);
let sleep = Duration::from_millis(100);
let start = Instant::now();
let guard = loop {
    match lock.try_lock() {
        Ok(guard) => break guard,
        Err(err) if start.elapsed() > timeout => return Err(()),
        Err(_) => tokio::time::sleep(sleep).await,
    }
};
// Do some work.

Errors

When:

• Timing out.
• mongodb::Collection::insert_one errors.

Trait Implementations

impl<Key: Debug + Clone + Send + Sync + Serialize + 'static> Debug for Mutex<Key>

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

Formats the value using the given formatter.