Struct RefreshableWriteSynced

pub struct RefreshableWriteSynced<T: Clone> { /* private fields */ }

Available on crate feature redis only.

A data wrapper that automatically updates the data given out when deemed stale. The data is set to refresh at a certain interval (triggered on access), or can be forcefully refreshed.

Implementations

impl<T: Clone> RefreshableWriteSynced<T>

pub fn new<FutGet: Future<Output = RResult<T, AnyErr>> + Send + 'static, FutSet: Future<Output = RResult<(), AnyErr>> + Send + 'static>( redis: &Redis, redis_namespace: impl Into<String>, redis_key: impl Into<String>, force_refresh_every: TimeDelta, getter: impl Fn() -> FutGet + 'static + Send + Sync, setter: impl Fn(T) -> FutSet + 'static + Send + Sync, ) -> RResult<Self, AnyErr>

Creates a new refreshable data wrapper. This will only call the getter on first access, not on instanstiation.

Arguments:

• redis: The redis wrapper itself needed for dlocking.
• redis_namespace: The namespace to use for the redis key when locking during setting.
• redis_key: The key to use for the redis key when locking during setting.
• force_refresh_every: The interval for forceful data should be refreshed. For when something other than a Refreshable container updates, but still good as a backup.
• getter: A function that returns a future that resolves to the data.
• setter: A function that updates the source with new data.

pub fn on_mutate( self, on_mutate: impl Fn(&mut T) -> RResult<(), AnyErr> + 'static + Send + Sync, ) -> Self

Do something whenever a mutation happens, useful to hook in other mutations while a mut self is available.

pub async fn mutate<R, E>( &self, conn: &impl RedisConnLike, mutator: impl FnOnce(&mut T) -> Result<R, E>, ) -> RResult<Result<R, E>, AnyErr>

Update the data in the refreshable with key features:

• Locks the source using a redis dlock for the duration of the update.
• Refreshes the data before the update inside the locked section, to make sure you’re doing the update on the latest data and not overwriting changes.
• Updates the setter, thanks to above guaranteed no sibling node overwrites etc.

NOTE: returns a double result to allow custom internal error types to be passed out.

pub async fn refresh(&self) -> RResult<(), AnyErr>

Force a refresh of the data.

pub async fn get( &self, conn: &impl RedisConnLike, ) -> RResult<RefreshableGuard<Arc<T>>, AnyErr>

Get the underlying data for use. If the data is stale, it will be refreshed before returning.

NOTE: the implementation of the guards means not too many should be alive at once, and keeping across await points should be discouraged. If you need long access to the underlying data, consider cloning it.