Struct bitbazaar::redis::RedisTempList

pub struct RedisTempList {
    pub namespace: Cow<'static, str>,
    pub key: String,
    pub list_inactive_ttl: Duration,
    pub item_inactive_ttl: Duration,
    /* private fields */
}

Connect up to a magic redis list that:

• Has an expiry on the list itself, resetting on each read or write. (each change lives again for list_inactive_ttl time)
• Each item in the list has it’s own expiry, so the list is always clean of old items.
• Each item has a generated unique key, this key can be used to update or delete specific items directly.
• Returned items are returned newest/last-updated to oldest This makes this distributed data structure perfect for stuff like:
• recent/temporary logs/events of any sort.
• pending actions, that can be updated in-place by the creator, but read as part of a list by a viewer etc.

Fields

namespace: Cow<'static, str>

The namespace of the list in redis (should come in as static, but Cow needed because of deserialization)

key: String

The key of the list in redis

list_inactive_ttl: Duration

If the list hasn’t been read or written to in this time, it will be expired.

item_inactive_ttl: Duration

If an item hasn’t been read or written to in this time, it will be expired.

Implementations

impl RedisTempList

A managed list entry in redis that will:

• Auto expire on inactivity
• Return items newest to oldest
• Items are set with their own ttl, so the members themselves expire separate from the full list
• Optionally prevents duplicate values. When enabled, if a duplicate is added, the item will be bumped to the front & old discarded.

pub async fn push<'a, T: Serialize + for<'b> Deserialize<'b>>( self: &'a Arc<Self>, conn: &mut RedisConn<'_>, item: T, ) -> RedisTempListItem<T>

Add a new item to the sorted list.

This will also:

• Autoreset list’s expire time to self.list_inactive_ttl from now
• Clean up expired list items

Returns: RedisTempListItem: The resulting item holder which can be used to further manipulate the items.

pub async fn extend<'a, T: Serialize + for<'b> Deserialize<'b>>( self: &'a Arc<Self>, conn: &mut RedisConn<'_>, items: impl IntoIterator<Item = T>, ) -> Vec<RedisTempListItem<T>>

Add multiple items to the sorted list. Purposely using one ttl for all, should think about why if you’re needing to set different ttls to items you’re adding together!

This will also:

• Autoreset list’s expire time to self.list_inactive_ttl from now
• Clean up expired list items

Returns:

• Some(Vec<RedisTempListItem>): The resulting item holders for each of the items added, these can be used to further manipulate the items.
• None: Something went wrong and the items weren’t added correctly.

pub async fn read_multi_raw<T: Serialize + for<'a> Deserialize<'a>>( &self, conn: &mut RedisConn<'_>, limit: Option<isize>, ) -> Vec<(i64, String, T)>

Underlying of RedisTempList::read_multi, but returns the (i64: ttl, String: item key, T: item) rather than RedisTempList that makes working with items easier.

pub async fn read_multi<T: Serialize + for<'a> Deserialize<'a>>( self: &Arc<Self>, conn: &mut RedisConn<'_>, limit: Option<isize>, ) -> Vec<RedisTempListItem<T>>

Read multiple items from the list, ordered from last updated to least (newest to oldest).

This will also:

• Autoreset list’s expire time to self.list_inactive_ttl from now
• Clean up expired list items

Returns:

• Vec<RedisTempListItem: The wrapped items in the list from newest to oldest up to the provided limit (if any).

pub async fn read<T: Serialize + for<'a> Deserialize<'a>>( self: &Arc<Self>, conn: &mut RedisConn<'_>, uid: &str, ) -> RedisTempListItem<T>

Read a specific item given it’s uid.

This will also:

• Autoreset list’s expire time to self.list_inactive_ttl from now
• Clean up expired list items

Returns:

• RedisTempListItem<’a, ’c, T>: The item holder that encapsulates any error logic.

pub async fn delete(&self, conn: &mut RedisConn<'_>, uid: &str)

Delete a specific item given it’s uid.

This will also:

• Autoreset list’s expire time to self.list_inactive_ttl from now
• Clean up expired list items

pub async fn delete_multi<S: Into<String>>( &self, conn: &mut RedisConn<'_>, uids: impl IntoIterator<Item = S>, )

Delete multiple items via their ids.

This will also:

• Autoreset list’s expire time to self.list_inactive_ttl from now
• Clean up expired list items

pub async fn update<'a, T>( &self, conn: &mut RedisConn<'_>, uid: &str, item: &'a T, )

where T: 'a + Deserialize<'a>, &'a T: Serialize,

Update a specific item given it’s uid.

This will also:

• Autoreset list’s expire time to self.list_inactive_ttl from now
• Clean up expired list items
• Reset the item’s expiry time, given its been updated

pub async fn clear(&self, conn: &mut RedisConn<'_>)

Clear all the items in the list. (by just deleting the list itself, stored values will still live until their ttl but used a random uid so no conflicts)

Trait Implementations

impl Clone for RedisTempList

fn clone(&self) -> RedisTempList

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RedisTempList

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RedisTempList

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for RedisTempList

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.