Struct FoyerLayer 

pub struct FoyerLayer { /* private fields */ }

Available on crate feature layers-foyer only.

Hybrid cache layer for OpenDAL that uses foyer for caching.

Operation Behavior

• write: FoyerLayer will write to the foyer hybrid cache after the service’s write operation is completed.
• read: FoyerLayer will first check the foyer hybrid cache for the data. If the data is not found, it will perform the read operation on the service and cache the result.
• delete: FoyerLayer will remove the data from the foyer hybrid cache regardless of whether the service’s delete operation is successful.
• Other operations: FoyerLayer will not cache the results of other operations, such as list, copy, rename, etc. They will be passed through to the underlying accessor without caching.

Examples

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

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

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

Note

If the object version is enabled, the foyer cache layer will treat the objects with 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>,

Sets the size limit for caching.

It is recommended to set a size limit to avoid caching large files that may not be suitable for caching.

Trait Implementations

impl Debug for FoyerLayer

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

Formats the value using the given formatter.

impl<A> Layer<A> for FoyerLayer

where A: Access,

type LayeredAccess = FoyerAccessor<A>

The layered accessor that returned by this layer.

fn layer(&self, accessor: A) -> <FoyerLayer as Layer<A>>::LayeredAccess

Intercept the operations on the underlying storage.