Struct mz_persist_client::cache::StateCache

pub struct StateCache {
    cfg: Arc<PersistConfig>,
    pub(crate) metrics: Arc<Metrics>,
    states: Arc<Mutex<BTreeMap<ShardId, Arc<OnceCell<Weak<dyn DynState>>>>>>,
    pubsub_sender: Arc<dyn PubSubSender>,
}

A cache of TypedState, shared between all machines for that shard.

This is shared between all machines that come out of the same PersistClientCache, but in production there is one of those per process, so in practice, we have one copy of state per shard per process.

The mutex contention between commands is not an issue, because if two command for the same shard are executing concurrently, only one can win anyway, the other will retry. With the mutex, we even get to avoid the retry if the racing commands are on the same process.

Fields

cfg: Arc<PersistConfig>

metrics: Arc<Metrics>

states: Arc<Mutex<BTreeMap<ShardId, Arc<OnceCell<Weak<dyn DynState>>>>>>

pubsub_sender: Arc<dyn PubSubSender>

Implementations

impl StateCache

pub fn new( cfg: &PersistConfig, metrics: Arc<Metrics>, pubsub_sender: Arc<dyn PubSubSender>, ) -> Self

Returns a new StateCache.

pub(crate) async fn get<K, V, T, D, F, InitFn>( &self, shard_id: ShardId, init_fn: InitFn, diagnostics: &Diagnostics, ) -> Result<Arc<LockingTypedState<K, V, T, D>>, Box<CodecMismatch>>

where K: Debug + Codec, V: Debug + Codec, T: Timestamp + Lattice + Codec64 + Sync, D: Semigroup + Codec64, F: Future<Output = Result<TypedState<K, V, T, D>, Box<CodecMismatch>>>, InitFn: FnMut() -> F,

pub(crate) fn get_state_weak( &self, shard_id: &ShardId, ) -> Option<Weak<dyn DynState>>

Trait Implementations

impl Debug for StateCache

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

Formats the value using the given formatter.