Trait subspace_farmer::farm::PieceCache

source · 
pub trait PieceCache:
    Send
    + Sync
    + Debug {
    // Required methods
    fn id(&self) -> &PieceCacheId;
    fn max_num_elements(&self) -> u32;
    fn contents<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Stream<Item = Result<(PieceCacheOffset, Option<PieceIndex>), FarmError>> + Unpin + Send + '_>, FarmError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn write_piece<'life0, 'life1, 'async_trait>(
        &'life0 self,
        offset: PieceCacheOffset,
        piece_index: PieceIndex,
        piece: &'life1 Piece,
    ) -> Pin<Box<dyn Future<Output = Result<(), FarmError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn read_piece_index<'life0, 'async_trait>(
        &'life0 self,
        offset: PieceCacheOffset,
    ) -> Pin<Box<dyn Future<Output = Result<Option<PieceIndex>, FarmError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn read_piece<'life0, 'async_trait>(
        &'life0 self,
        offset: PieceCacheOffset,
    ) -> Pin<Box<dyn Future<Output = Result<Option<(PieceIndex, Piece)>, FarmError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
}
Expand description

Abstract piece cache implementation.

Piece cache is a simple container that stores concatenated pieces in a flat file at specific offsets. Implementation doesn’t have to be local though, cache can be remote somewhere on the network, APIs are intentionally async to account for that.

Required Methods§

source

fn id(&self) -> &PieceCacheId

ID of this cache

source

fn max_num_elements(&self) -> u32

Max number of elements in this cache

source

fn contents<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Stream<Item = Result<(PieceCacheOffset, Option<PieceIndex>), FarmError>> + Unpin + Send + '_>, FarmError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Contents of this piece cache.

NOTE: it is possible to do concurrent reads and writes, higher level logic must ensure this doesn’t happen for the same piece being accessed!

source

fn write_piece<'life0, 'life1, 'async_trait>( &'life0 self, offset: PieceCacheOffset, piece_index: PieceIndex, piece: &'life1 Piece, ) -> Pin<Box<dyn Future<Output = Result<(), FarmError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store piece in cache at specified offset, replacing existing piece if there is any.

NOTE: it is possible to do concurrent reads and writes, higher level logic must ensure this doesn’t happen for the same piece being accessed!

source

fn read_piece_index<'life0, 'async_trait>( &'life0 self, offset: PieceCacheOffset, ) -> Pin<Box<dyn Future<Output = Result<Option<PieceIndex>, FarmError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Read piece index from cache at specified offset.

Returns None if offset is out of range.

NOTE: it is possible to do concurrent reads and writes, higher level logic must ensure this doesn’t happen for the same piece being accessed!

source

fn read_piece<'life0, 'async_trait>( &'life0 self, offset: PieceCacheOffset, ) -> Pin<Box<dyn Future<Output = Result<Option<(PieceIndex, Piece)>, FarmError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Read piece from cache at specified offset.

Returns None if offset is out of range.

NOTE: it is possible to do concurrent reads and writes, higher level logic must ensure this doesn’t happen for the same piece being accessed!

Implementors§