Struct FarmerCache 

pub struct FarmerCache { /* private fields */ }

Farmer cache that aggregates different kinds of caches of multiple disks.

Pieces in PieceCache are stored based on capacity and proximity of piece index to farmer’s network identity. If capacity is not enough to store all pieces in cache then pieces that are further from network identity will be evicted, this is helpful for quick retrieval of pieces from DSN as well as plotting purposes.

PlotCache is used as a supplementary cache and is primarily helpful for smaller farmers where piece cache is not enough to store all the pieces on the network, while there is a lot of space in the plot that is not used by sectors yet and can be leverage as extra caching space.

Implementations

impl FarmerCache

pub fn new<NC>( node_client: NC, peer_id: PeerId, registry: Option<&mut Registry>, ) -> (Self, FarmerCacheWorker<NC>)

where NC: NodeClient,

Create new piece cache instance and corresponding worker.

NOTE: Returned future is async, but does blocking operations and should be running in dedicated thread.

pub async fn get_piece<Key>(&self, key: Key) -> Option<Piece>

where RecordKey: From<Key>,

Get piece from cache

pub async fn get_pieces<'a, PieceIndices>( &'a self, piece_indices: PieceIndices, ) -> impl Stream<Item = (PieceIndex, Option<Piece>)> + Send + Unpin + 'a

where PieceIndices: IntoIterator<Item = PieceIndex, IntoIter: Send + 'a> + Send + 'a,

Get pieces from cache.

Number of elements in returned stream is the same as number of unique piece_indices.

pub async fn has_pieces( &self, piece_indices: Vec<PieceIndex>, ) -> Vec<PieceIndex>

Returns a filtered list of pieces that were found in farmer cache, order is not guaranteed

pub async fn find_piece( &self, piece_index: PieceIndex, ) -> Option<(PieceCacheId, PieceCacheOffset)>

Find piece in cache and return its retrieval details

pub async fn find_pieces<PieceIndices>( &self, piece_indices: PieceIndices, ) -> Vec<(PieceIndex, PieceCacheId, PieceCacheOffset)>

where PieceIndices: IntoIterator<Item = PieceIndex>,

Find pieces in cache and return their retrieval details

pub async fn maybe_store_additional_piece( &self, piece_index: PieceIndex, piece: &Piece, ) -> bool

Try to store a piece in additional downloaded pieces, if there is space for it. Returns true if the piece was added to this cache, and false if it was already stored, or there was no space.

pub async fn replace_backing_caches( &self, new_piece_caches: Vec<Arc<dyn PieceCache>>, new_plot_caches: Vec<Arc<dyn PlotCache>>, )

Initialize replacement of backing caches

pub fn on_sync_progress( &self, callback: Arc<dyn Fn(&f32) + Send + Sync + 'static>, ) -> HandlerId

Subscribe to cache sync notifications

Trait Implementations

impl Clone for FarmerCache

fn clone(&self) -> FarmerCache

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FarmerCache

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

Formats the value using the given formatter.

impl From<FarmerCache> for FarmerCaches

fn from(cache: FarmerCache) -> Self

Converts to this type from the input type.