Struct FoyerLayer 

pub struct FoyerLayer { /* private fields */ }

Available on crate feature layers-foyer only.

FoyerLayer caches OpenDAL data with foyer.

Operation Behavior

• write: FoyerLayer caches data after the service completes the write.
• read: FoyerLayer checks the cache first. On a cache miss, it reads and caches the entire object if its size is within the configured FoyerLayer::with_size_limit range, even when only a byte range is requested.
• delete: FoyerLayer removes cached data after a successful delete when the deleter closes. A failed delete is not invalidated. Cache invalidation happens before the underlying deleter is closed, so the data remains invalidated if closing the deleter fails.
• Other operations: FoyerLayer passes operations such as list, copy, and rename to the service without caching their results.

Range Reads

FoyerLayer caches entire objects, not individual byte ranges. For example, operator.read_with("some/path").range(0..1024) returns only the first 1024 bytes, but on a cache miss the layer fetches and buffers the entire object before returning that range if the object is eligible for caching. On a cache hit, the layer returns the requested range from the cached object.

Reading a small range from a large object can therefore transfer and buffer much more data than requested, increasing read latency and memory usage. Use FoyerLayer::with_size_limit to exclude large objects from caching. On a cache miss, objects outside the configured size range are read directly from the service using the requested byte range.

Examples

use opendal_core::{Operator, services::Memory};
use opendal_layer_foyer::FoyerLayer;
use foyer::HybridCacheBuilder;

let cache = HybridCacheBuilder::new()
    .memory(64 * 1024 * 1024) // 64MB memory cache
    .with_shards(4)
    .storage()
    .build()
    .await?;

let op = Operator::new(Memory::default())?
    .layer(FoyerLayer::new(cache));

Note

When object versioning is enabled, FoyerLayer treats objects with the same path but different versions as different objects.

Implementations

impl FoyerLayer

pub fn new(cache: HybridCache<FoyerKey, FoyerValue>) -> FoyerLayer

Creates a new FoyerLayer with the given foyer hybrid cache.

pub fn with_size_limit<R>(self, size_limit: R) -> FoyerLayer

where R: RangeBounds<usize>,

Set the object-size range eligible for caching.

The layer reads through or writes through objects outside this range without retaining them in Foyer. The default range accepts every representable object size below usize::MAX.

Trait Implementations

impl Debug for FoyerLayer

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

Formats the value using the given formatter.

impl Layer for FoyerLayer

fn apply_service(&self, inner: Arc<dyn ServiceDyn>) -> Arc<dyn ServiceDyn>

Intercept the operation service stack.

fn apply_context( &self, srv: Arc<dyn ServiceDyn>, inner: OperationContext, ) -> OperationContext

Intercept the operation context (HTTP transport and executor).