Implement DiskCache using Sled

[codeZe-us]

To provide persistent caching across application restarts, a disk-based cache implementation is needed. Utilizing sled, a high-performance embedded database, this implementation will fulfill the CacheProvider contract, allowing large or persistent data to be stored efficiently on the local file system without consuming excessive RAM.

Implementation guidelines

• Implement the CacheProvider trait for a new DiskCache struct.
• Initialize the sled database instance with a configurable local directory path.
• Serialize keys and values using a fast binary format (e.g., bincode) before inserting them into the sled tree.
• Handle database locking and concurrency properly as expected in an asynchronous context.

Files location

crates/core/src/cache/disk.rs

Expected result

A reliable, persistent caching layer that survives application restarts, efficiently managing local storage using the sled embedded database.

Please make sure to use the PR template when submitting your pull request.

Join the contributor Telegram group and ask any questions: https://t.me/+sII7WPhll2liMGNk

[GazzyLee]

hi boss, I’d like to implement the DiskCache by creating a sled-backed implementation of the existing CacheProvider trait in crates/core/src/cache/disk.rs. I’ll make the storage path configurable, use an efficient binary format such as bincode for serialization, and ensure reads/writes are safe and non-blocking in the asynchronous context. I’ll also test persistence across restarts, concurrent access, and cache operations to ensure the implementation is reliable for larger datasets.

[JuliobaCR]

Hi, I'd like to work on this one.

Problem
The cache module currently only has a bespoke file-based CacheStore (crates/core/src/cache/store.rs) backed by redb, with no unified async trait. We need a dedicated DiskCache that implements the CacheProvider contract using sled (not yet a project dependency) as a persistent, embedded, lock-free B+tree store, so large or long-lived data can survive application restarts without a custom eviction/LRU scheme.

Proposed solution

• Add sled to crates/core/Cargo.toml.
• Create crates/core/src/cache/disk.rs with a DiskCache struct wrapping a sled::Db, with a constructor that takes a configurable local directory path.
• Implement CacheProvider::{get, put, remove, clear} using bincode (already a dep) to serialize/deserialize values before inserting into the sled tree; clear() maps to dropping/recreating the tree.
• Rely on sled's internal concurrency guarantees for safe concurrent reads/writes instead of an external mutex; wrap I/O errors into the existing GratError::CacheError variant.
• Tests: persistence across a Db close/reopen cycle, concurrent get/put from multiple tokio tasks, and a cache-miss path returning Ok(None).

ETA: 1-2 days.

Will follow the PR template. Let me know if there's a preferred default cache directory convention (I see CacheStore::default_location() uses directories::ProjectDirs — planning to reuse that same pattern).

[grantfox-oss]

🦊 GrantFox — @JuliobaCR has been assigned to this issue as part of the Third Campaign campaign!

Next steps:

1. Open a Pull Request referencing this issue (e.g., Closes #403)
2. Your PR will be reviewed by the Toolbox-Lab maintainers

Good luck! Track your progress on GrantFox.