Struct ManagedLock

pub struct ManagedLock {
    pub created_at_revision: Revision,
    /* private fields */
}

A Lock instance with automatic lease refresh and lock revocation when dropped.

Fields

created_at_revision: Revision

Implementations

impl ManagedLock

pub fn lease_id(&self) -> i64

pub async fn txn(&self, operations: impl Into<Vec<TxnOp>>) -> TxnResponse

Execute an etcd transaction if and only if the lock is still alive.

pub fn get_revoke_notify(&self) -> ManagedLockRevokeNotify

Get a revoke notify handle to be notified when the lock is revoked.

pub async fn is_alive(&self) -> bool

Check if the lock is still alive.

pub fn get_key(&self) -> Vec<u8>

Get the underlying unique lock key.

pub async fn scope<T, Fut>(&self, fut: Fut) -> Result<T, LockError>

where T: Send + 'static, Fut: Future<Output = T> + Send + 'static,

This function make sure the future is executed within a valid managed lock lifetime.

If the lock is revoked, it will cancel the future and return a LockError::LockRevoked.

Make sure the future returned by the closure is cancel safe.

Examples

use etcd_client::Client;
use rust_etcd_utils::{lease::ManagedLeaseFactory, lock::spawn_lock_manager, ManagedLock};

let etcd = Client::connect(["http://localhost:2379"], None).await.expect("failed to connect to etcd");

let (lock_man_handle, lock_man) = spawn_lock_manager(etcd.clone());

// Do something with the lock manager

let managed_lock: ManagedLock = lock_man.try_lock("test").await.expect("failed to lock");

managed_lock.scope(async move {
   // execute only if my lock is valid
   access_protected_ressource().await;
});

pub async fn scope_with<'a, T, F, Fut>( &'a self, func: F, ) -> Result<T, LockError>

where T: Send + 'a, F: FnOnce(ManagedLockGuard<'a>) -> Fut, Fut: Future<Output = T> + Send + 'a,

Similar to ManagedLock::scope but accept a closure to compute the future to execute against the lock.

pub fn get_managed_lease_weak_ref(&self) -> ManagedLeaseWeak

Get a weak reference to the managed lease.

pub async fn into_revoked_fut(self)

Convert the managed lock into a signal that will be resolved when the lock is revoked.

Trait Implementations

impl Debug for ManagedLock

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

Formats the value using the given formatter.

impl Drop for ManagedLock

fn drop(&mut self)

Executes the destructor for this type.