Struct BoundedStager

pub struct BoundedStager<H> {
    base_dir: PathBuf,
    cache: Cache<String, CacheValue>,
    recycle_bin: Cache<String, CacheValue>,
    delete_queue: Sender<DeleteTask>,
    notifier: Option<Arc<dyn StagerNotifier>>,
    _phantom: PhantomData<H>,
}

BoundedStager is a Stager that uses moka to manage staging area.

Fields

base_dir: PathBuf

The base directory of the staging area.

cache: Cache<String, CacheValue>

The cache maintaining the cache key to the size of the file or directory.

recycle_bin: Cache<String, CacheValue>

The recycle bin for the deleted files and directories.

delete_queue: Sender<DeleteTask>

The delete queue for the cleanup task.

The lifetime of a guard is:

1. initially inserted into the cache
2. moved to the recycle bin when evicted 2.1 moved back to the cache when accessed 2.2 deleted from the recycle bin after a certain period
3. sent the delete task to the delete queue on drop
4. background routine removes the file or directory

notifier: Option<Arc<dyn StagerNotifier>>

Notifier for the stager.

_phantom: PhantomData<H>

Implementations

impl<H: 'static> BoundedStager<H>

pub async fn new( base_dir: PathBuf, capacity: u64, notifier: Option<Arc<dyn StagerNotifier>>, cache_ttl: Option<Duration>, ) -> Result<Self>

impl<H> BoundedStager<H>

fn encode_cache_key(puffin_file_name: &str, key: &str) -> String

async fn write_blob( target_path: &PathBuf, init_fn: Box<dyn InitBlobFn + Send + Sync + '_>, ) -> Result<u64>

async fn write_dir( target_path: &PathBuf, init_fn: Box<dyn InitDirFn + Send + Sync + '_>, ) -> Result<u64>

async fn recover(&self) -> Result<()>

Recovers the staging area by iterating through the staging directory.

Note: It can’t recover the mapping between puffin files and keys, so TTL is configured to purge the dangling files and directories.

async fn get_dir_size(path: &PathBuf) -> Result<u64>

Walks through the directory and calculate the total size of all files in the directory.

async fn delete_routine( receiver: Receiver<DeleteTask>, recycle_bin: Cache<String, CacheValue>, notifier: Option<Arc<dyn StagerNotifier>>, )

Trait Implementations

impl<H> Drop for BoundedStager<H>

fn drop(&mut self)

Executes the destructor for this type.

impl<H: ToString + Clone + Send + Sync> Stager for BoundedStager<H>

type Blob = Arc<FsBlobGuard>

type Dir = Arc<FsDirGuard>

type FileHandle = H

fn get_blob<'a, 'life0, 'life1, 'life2, 'async_trait>( &'life0 self, handle: &'life1 Self::FileHandle, key: &'life2 str, init_fn: Box<dyn InitBlobFn + Send + Sync + 'a>, ) -> Pin<Box<dyn Future<Output = Result<Self::Blob>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Retrieves a blob, initializing it if necessary using the provided init_fn.

fn get_dir<'a, 'life0, 'life1, 'life2, 'async_trait>( &'life0 self, handle: &'life1 Self::FileHandle, key: &'life2 str, init_fn: Box<dyn InitDirFn + Send + Sync + 'a>, ) -> Pin<Box<dyn Future<Output = Result<Self::Dir>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Retrieves a directory, initializing it if necessary using the provided init_fn.

fn put_dir<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, handle: &'life1 Self::FileHandle, key: &'life2 str, dir_path: PathBuf, size: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Stores a directory in the staging area.

fn purge<'life0, 'life1, 'async_trait>( &'life0 self, handle: &'life1 Self::FileHandle, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Purges all content for the given puffin file from the staging area.