Struct CacheStore 

pub struct CacheStore { /* private fields */ }

Cached module information stored on disk.

Entries are keyed on the ROOT-RELATIVE, forward-slash-normalised path, and the root is recorded once in the header. Absolute keys made the blob unusable anywhere but the directory that wrote it: a container job, a matrix over roots, a GitLab shell executor, or a plain cp -Rp to a sibling path paid the full decode of a multi-megabyte file and then missed every single lookup, with nothing on stderr to say so.

Implementations

impl CacheStore

pub fn new(root: &Path) -> CacheStore

Create a new empty cache anchored at root.

pub fn load( cache_dir: &Path, root: &Path, expected_config_hash: u64, max_size_bytes: usize, ) -> Result<CacheStore, CacheRejection>

Load cache from disk.

Errors

Returns the CacheRejection that decided against reuse. Every branch names itself instead of collapsing into a bare miss: a run that read a multi-megabyte blob and then refused it costs the same as a cold run but used to be indistinguishable from having no cache at all, and the config-hash branch in particular said nothing whatsoever. Callers carry the reason into the perf table and fallow doctor.

The version is read from the file header BEFORE the payload is decoded, because the two are decided by different things. A format bump changes the encoded shape, so decoding a blob from the previous release fails outright and never reaches a version comparison made afterwards: the most ordinary event there is (upgrading fallow) then reported “cache file could not be decoded”, which reads as corruption and sent people looking for a damaged disk. With the version in front, an upgrade says the format changed. The framing is checked separately from the version it carries, so an unframed or unreadable payload reports Undecodable rather than borrowing the upgrade message.

Every branch that refuses a file that DID exist logs at warn, because the user paid the read and got nothing back. Only the missing-file case stays quiet.

pub fn save( &mut self, cache_dir: &Path, config_hash: u64, max_size_bytes: usize, ) -> Result<(), String>

Save cache to disk with write-time size enforcement and atomic rename.

pub fn get(&self, path: &Path, content_hash: u64) -> Option<&CachedModule>

Look up a cached module by path and content hash. Returns None if not cached or hash mismatch.

pub fn insert(&mut self, path: &Path, module: CachedModule)

Insert or update a cached module.

pub fn get_by_path_only(&self, path: &Path) -> Option<&CachedModule>

Look up a cached module by path only (ignoring hash).

pub fn retain_paths(&mut self, files: &[DiscoveredFile]) -> bool

Remove cache entries for files that no longer exist on disk.

Returns true when any entry was removed.

The predicate is deliberately “still exists”, not “was discovered by this run”. Discovery is scoped: --production drops test and story files, --root narrows to a subtree, and ignorePatterns differs per command. Evicting whatever the current scope did not walk meant one --production run threw away the entries for every test file, and the next full run reparsed them from cold. Entries are keyed by absolute path, so the check is one symlink_metadata per undiscovered entry (symlink_metadata, not metadata, so a broken symlink still counts as present rather than being evicted as missing). Size is not this method’s concern: evict_lru_to_target remains the only guard on how large the blob may grow.

pub fn len(&self) -> usize

Number of cached entries.

pub fn is_empty(&self) -> bool

Whether the cache is empty.

Trait Implementations

impl Debug for CacheStore

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

Formats the value using the given formatter.

impl<'__de> Decode<'__de> for CacheStore

impl Default for CacheStore

fn default() -> CacheStore

Returns the “default value” for a type.

impl Encode for CacheStore