Struct RedisBackend 

pub struct RedisBackend<C>
where
    C: RedisConn,
{ /* private fields */ }

L1 hot cache: content-addressed key → value, sub-ms hits, TTL/eviction-aware.

Generic over the RedisConn seam so it is fully testable against a mock.

Implementations

impl<C> RedisBackend<C>

where C: RedisConn,

pub fn new(conn: C) -> RedisBackend<C>

Wrap a RedisConn with no per-write TTL (entries are LRU-evicted by the maxmemory band).

pub fn with_ttl(conn: C, ttl_secs: u64) -> RedisBackend<C>

Wrap a RedisConn, stamping every write with a ttl_secs expiry.

pub fn with_max_value_bytes(self, max: usize) -> RedisBackend<C>

Override the per-value byte cap (default DEFAULT_REDIS_MAX_VALUE_BYTES).

pub fn max_value_bytes(&self) -> usize

The per-value byte cap this tier refuses beyond.

pub fn ttl_secs(&self) -> Option<u64>

The per-write TTL, if any.

pub fn conn(&self) -> &C

Borrow the underlying connection (for composition / diagnostics).

Trait Implementations

impl<C> NarRefIndex for RedisBackend<C>

where C: RedisConn,

The reverse index as one Redis key per edge.

Edges carry no TTL, deliberately, even when narinfo/NAR writes do. An edge that expired while the narinfo it describes is still live would be an under-report, and an under-report authorizes deleting a NAR out from under that narinfo. An edge that outlives its narinfo is an over-report, which costs a retained NAR. The whole tier is still best-effort — Redis maxmemory LRU can drop an edge regardless — which is why a TieredBackend unions this tier’s answer with the durable tiers’ rather than trusting it alone.

fn record<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, nar_path: &'life1 str, hash: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, RedisBackend<C>: 'async_trait,

Record “hash’s narinfo advertises nar_path”. Idempotent.

fn forget<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, nar_path: &'life1 str, hash: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, RedisBackend<C>: 'async_trait,

Forget that edge. Idempotent — forgetting an absent edge is Ok(()).

fn referrers<'life0, 'life1, 'async_trait>( &'life0 self, nar_path: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, RedisBackend<C>: 'async_trait,

Every store-path hash whose narinfo advertises nar_path, sorted and deduplicated.

impl<C> StorageBackend for RedisBackend<C>

where C: RedisConn,

fn put_nar<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, path: &'life1 str, data: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, RedisBackend<C>: 'async_trait,

Store a NAR in the hot tier, refusing anything over the cap.

The cap is checked against the slice’s length before the value ever reaches the wire, so an oversized NAR costs this tier nothing.

fn nar_residency(&self) -> NarResidency

O(min(nar, cap)). Redis has no streaming SET — a value is one contiguous buffer by protocol — so this tier is bounded by a cap rather than by a chunk. That is a real bound: see DEFAULT_REDIS_MAX_VALUE_BYTES for why refusing is the correct behavior for a best-effort hot tier.

fn put_nar_stream<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, path: &'life1 str, src: &'life2 dyn NarSource, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, RedisBackend<C>: 'async_trait,

Drain the source only up to the cap, refusing the moment it is crossed.

The refusal is the load-bearing part: collection stops at the cap and the remainder of the NAR is never read, so a 2 GiB NAR costs this tier cap + one chunk and not 2 GiB. Without it, “L1 refuses oversized values” would be a claim the code does not make.

fn wipe_all<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<usize, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, RedisBackend<C>: 'async_trait,

Complete L1 wipe: DEL every key under BOTH the narinfo and NAR prefixes (a scoped clear — never FLUSHDB, which would blow away an unrelated co-tenant of the same Redis db). Returns the narinfo key count removed.

fn get_narinfo<'life0, 'life1, 'async_trait>( &'life0 self, hash: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, RedisBackend<C>: 'async_trait,

Retrieve narinfo text by store path hash.

fn put_narinfo_record<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, hash: &'life1 str, content: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, RedisBackend<C>: 'async_trait,

Store narinfo text keyed by store path hash — the record verb: one key, no index maintenance.

fn delete_narinfo_record<'life0, 'life1, 'async_trait>( &'life0 self, hash: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, RedisBackend<C>: 'async_trait,

Remove a narinfo record by store path hash. Idempotent; removing an absent narinfo is Ok(()).

fn delete_nar_record<'life0, 'life1, 'async_trait>( &'life0 self, nar_path: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, RedisBackend<C>: 'async_trait,

Remove one NAR blob by its relative path. Idempotent.

fn nar_ref_index(&self) -> &dyn NarRefIndex

This backend’s narhash → store-hash reverse index.

fn get_nar<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, RedisBackend<C>: 'async_trait,

Retrieve a NAR blob by its relative path.

fn list_narinfos<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, StoreError>> + Send + 'async_trait>>

where 'life0: 'async_trait, RedisBackend<C>: 'async_trait,

List all stored narinfo hashes.

fn get_nar_stream<'life0, 'life1, 'async_trait>( &'life0 self, path: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Pin<Box<dyn Stream<Item = Result<Bytes, StoreError>> + Send>>>, StoreError>> + Send + 'async_trait>>

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

Retrieve a NAR blob as a bounded-chunk stream.

fn put_narinfo<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, hash: &'life1 str, content: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Store narinfo text and record the reverse edge it creates.

fn advertised_nar<'life0, 'life1, 'async_trait>( &'life0 self, hash: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, StoreError>> + Send + 'async_trait>>

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

The NAR path this store path’s narinfo advertises — resolved, never guessed.

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, hash: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), StoreError>> + Send + 'async_trait>>

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

Delete a store path’s narinfo, and its NAR only if nothing else advertises that NAR.

fn reindex_nar_refs<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<usize, StoreError>> + Send + 'async_trait>>

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

Rebuild every reverse edge from the narinfos this backend holds, and return the number of edges recorded.