Struct LeaderCachedKvBackend 

pub struct LeaderCachedKvBackend {
    check_leader: CheckLeaderRef,
    store: KvBackendRef,
    cache: ResettableKvBackendRef,
    version: AtomicUsize,
    name: String,
}

A cache dedicated to a Leader node, in order to cache some metadata.

To use this cache, the following constraints must be followed:

1. The leader node can create this metadata.
2. The follower node can create this metadata. The leader node can lazily retrieve the corresponding data through the caching loading mechanism.
3. Only the leader node can update this metadata, as the cache cannot detect modifications made to the data on the follower node.
4. Only the leader node can delete this metadata for the same reason mentioned above.

Fields

check_leader: CheckLeaderRef

store: KvBackendRef

cache: ResettableKvBackendRef

version: AtomicUsize

name: String

Implementations

impl LeaderCachedKvBackend

pub fn new(check_leader: CheckLeaderRef, store: KvBackendRef) -> Self

pub fn with_always_leader(store: KvBackendRef) -> Self

With a leader checker which always returns true when checking, mainly used in test scenarios.

pub async fn load(&self) -> Result<()>

The caller MUST ensure during the loading, there are no mutation requests reaching the LeaderCachedKvStore.

fn is_leader(&self) -> bool

async fn invalid_key(&self, key: Vec<u8>) -> Result<()>

async fn invalid_keys(&self, keys: Vec<Vec<u8>>) -> Result<()>

fn get_version(&self) -> usize

fn create_new_version(&self) -> usize

fn validate_version(&self, version: usize) -> bool

Trait Implementations

impl KvBackend for LeaderCachedKvBackend

fn name(&self) -> &str

fn as_any(&self) -> &dyn Any

fn range<'life0, 'async_trait>( &'life0 self, req: RangeRequest, ) -> Pin<Box<dyn Future<Output = Result<RangeResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn put<'life0, 'async_trait>( &'life0 self, req: PutRequest, ) -> Pin<Box<dyn Future<Output = Result<PutResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn batch_put<'life0, 'async_trait>( &'life0 self, req: BatchPutRequest, ) -> Pin<Box<dyn Future<Output = Result<BatchPutResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn batch_get<'life0, 'async_trait>( &'life0 self, req: BatchGetRequest, ) -> Pin<Box<dyn Future<Output = Result<BatchGetResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn compare_and_put<'life0, 'async_trait>( &'life0 self, req: CompareAndPutRequest, ) -> Pin<Box<dyn Future<Output = Result<CompareAndPutResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

CAS: Compares the value at the key with the given value, and if they are equal, puts the new value at the key.

fn delete_range<'life0, 'async_trait>( &'life0 self, req: DeleteRangeRequest, ) -> Pin<Box<dyn Future<Output = Result<DeleteRangeResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn batch_delete<'life0, 'async_trait>( &'life0 self, req: BatchDeleteRequest, ) -> Pin<Box<dyn Future<Output = Result<BatchDeleteResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<Option<KeyValue>, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

fn put_conditionally<'life0, 'async_trait>( &'life0 self, key: Vec<u8>, value: Vec<u8>, if_not_exists: bool, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Sync + 'async_trait,

Puts a value at a key. If if_not_exists is true, the operation ensures the key does not exist before applying the PUT operation. Otherwise, it simply applies the PUT operation without checking for the key’s existence.

fn exists<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Check if the key exists, not returning the value. If the value is large, this method is more efficient than get.

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 [u8], prev_kv: bool, ) -> Pin<Box<dyn Future<Output = Result<Option<KeyValue>, Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Returns previous key-value pair if prev_kv is true.

impl ResettableKvBackend for LeaderCachedKvBackend

fn reset(&self)

fn as_kv_backend_ref(self: Arc<Self>) -> KvBackendRef<Self::Error>

Upcast as KvBackendRef. Since https://github.com/rust-lang/rust/issues/65991 is not yet stable.

impl TxnService for LeaderCachedKvBackend

type Error = Error

fn txn<'life0, 'async_trait>( &'life0 self, txn: Txn, ) -> Pin<Box<dyn Future<Output = Result<TxnResponse>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn max_txn_ops(&self) -> usize

Maximum number of operations permitted in a transaction.