Struct FileStore 

pub struct FileStore { /* private fields */ }

Implementations

impl FileStore

pub fn open(root: impl Into<PathBuf>) -> Result<Self, StoreError>

pub fn root(&self) -> &Path

pub fn persist( &self, key: &Key, bytes: &[u8], tool_kind: &str, file_roots: Vec<FileRootSerde>, ) -> Result<(), StoreError>

Write a payload. Uses tempfile + rename so a crash mid-write leaves the store in a consistent state (either the entry is fully there or it is not), which keeps lookup from ever observing torn data.

pub fn persist_with_upstreams( &self, key: &Key, bytes: &[u8], tool_kind: &str, file_roots: Vec<FileRootSerde>, upstream_keys: Vec<String>, ) -> Result<(), StoreError>

Persist a payload that depends on previously-cached upstream entries. The LlmCall path uses this to record which tool-call keys it consumed, so downstream invalidation can walk the dependency edge and drop dependent entries when a tool key is marked dirty.

pub fn remove(&self, key: &Key) -> Result<(), StoreError>

Delete the payload + meta for a key. Used by LiveCache when an upstream invalidation makes a cached entry definitely-stale; the caller has already removed the registry entry, and this drops the bytes from disk so a future rehydration does not resurrect the entry.

pub fn total_bytes(&self) -> Result<u64, StoreError>

Total bytes occupied by the store, summed across every payload and meta file under the root. Used by evict_to_cap and by operator-facing stats; cheap on small stores, linear-walk on large ones (we accept the cost because eviction is a periodic operation, not a hot path).

pub fn evict_to_cap(&self, cap_bytes: u64) -> Result<usize, StoreError>

Evict oldest entries until total_bytes() <= cap_bytes. Order is by payload-file mtime ascending so the least-recently- modified entry is removed first; on filesystems where reads update atime but not mtime this is a true write-order eviction (entries that have never been re-persisted go first), which is the right default for an append-only cache because a hot key gets re-persisted on every backend fall-through and a cold key does not. Returns the number of entries dropped.

The function intentionally does not touch the in-memory LiveCache registry; the caller is expected to either call this at process startup (before LiveCache::new rehydrates) or to recreate the cache afterwards.

pub fn iter_meta(&self) -> Result<Vec<(Key, PayloadMeta)>, StoreError>

Iterate every (key, meta) pair in the store. Used by LiveCache to rehydrate its in-memory registry on startup so cross-process cache hits work — without this, a fresh MCP server would see an empty registry and miss every lookup until it re-populated each entry from scratch.

pub fn lookup(&self, key: &Key) -> Result<Option<Payload>, StoreError>

Look up a payload. Returns None if absent. Returns StoreError::Integrity if the payload bytes on disk do not match the recorded hash, which indicates corruption (torn write that somehow survived, on-disk tamper, hardware fault) and must not silently return wrong bytes to the model.

pub fn contains(&self, key: &Key) -> bool

True if the key has a complete entry (both payload and meta). Useful for tests and stats; the integrity check still fires on lookup, so this is an existence-only check.

Trait Implementations

impl Debug for FileStore

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

Formats the value using the given formatter.

impl Store for FileStore

fn persist_with_upstreams( &self, key: &Key, bytes: &[u8], tool_kind: &str, file_roots: Vec<FileRootSerde>, upstream_keys: Vec<String>, ) -> Result<(), StoreError>

fn lookup(&self, key: &Key) -> Result<Option<Payload>, StoreError>

fn remove(&self, key: &Key) -> Result<(), StoreError>

fn total_bytes(&self) -> Result<u64, StoreError>

fn evict_to_cap(&self, cap_bytes: u64) -> Result<usize, StoreError>

fn iter_meta(&self) -> Result<Vec<(Key, PayloadMeta)>, StoreError>

fn contains(&self, key: &Key) -> bool

fn persist( &self, key: &Key, bytes: &[u8], tool_kind: &str, file_roots: Vec<FileRootSerde>, ) -> Result<(), StoreError>