Struct CachingStoreManager

pub struct CachingStoreManager<T> { /* private fields */ }

Wrap each Store produced by the inner StoreManager in an asynchronous, write-behind cache.

This serves two purposes:

• Improve performance with slow and/or distant stores

• Provide a relaxed consistency guarantee vs. what a fully synchronous store provides

The latter is intended to prevent guests from coming to rely on the synchronous consistency model of an existing implementation which may later be replaced with one providing a more relaxed, asynchronous (i.e. “eventual”) consistency model. See also https://www.hyrumslaw.com/ and https://xkcd.com/1172/.

This implementation provides a “read-your-writes”, asynchronous consistency model such that values are immediately available for reading as soon as they are written as long as the read(s) hit the same cache as the write(s). Reads and writes through separate caches (e.g. separate guest instances or separately-opened references to the same store within a single instance) are not guaranteed to be consistent; not only is cross-cache consistency subject to scheduling and/or networking delays, a given tuple is never refreshed from the backing store once added to a cache since this implementation is intended for use only by short-lived guest instances.

Note that, because writes are asynchronous and return immediately, durability is not guaranteed. I/O errors may occur asynchronously after the write operation has returned control to the guest, which may result in the write being lost without the guest knowing. In the future, a separate write-durable function could be added to key-value.wit to provide either synchronous or asynchronous feedback on durability for guests which need it.

Implementations

impl<T> CachingStoreManager<T>

pub fn new(inner: T) -> Self

pub fn new_with_capacity(capacity: NonZeroUsize, inner: T) -> Self

Trait Implementations

impl<T: StoreManager> StoreManager for CachingStoreManager<T>

fn get<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn Store>, Error>> + Send + 'async_trait>>

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

fn is_defined(&self, store_name: &str) -> bool

fn summary(&self, store_name: &str) -> Option<String>

A human-readable summary of the given store’s configuration