Struct forest_filecoin::db::car::plain::PlainCar

pub struct PlainCar<ReaderT> {
    reader: ReaderT,
    write_cache: RwLock<CidHashMap<Vec<u8>>>,
    index: RwLock<CidHashMap<UncompressedBlockDataLocation>>,
    roots: Vec<Cid>,
}

Note that all operations on this store are blocking.

It can often be time, memory, or disk prohibitive to read large snapshots into a database like ParityDb.

This is an implementer of Blockstore that simply wraps an uncompressed CARv1 file.

On creation, PlainCar builds an in-memory index of the Cids in the file, and their offsets into that file. Note that it prepares its own buffer for doing so.

When a block is requested, PlainCar scrolls to that offset, and reads the block, on-demand.

Writes for new blocks (which don’t exist in the CAR already) are currently cached in-memory.

Random-access performance is expected to be poor, as the OS will have to load separate parts of the file from disk, and flush it for each read. However, (near) linear access should be pretty good, as file chunks will be pre-fetched.

See module documentation for more.

Fields

reader: ReaderT

write_cache: RwLock<CidHashMap<Vec<u8>>>

index: RwLock<CidHashMap<UncompressedBlockDataLocation>>

roots: Vec<Cid>

Implementations

impl<ReaderT: RandomAccessFileReader> PlainCar<ReaderT>

pub fn new(reader: ReaderT) -> Result<Self>

To be correct:

• reader must read immutable data. e.g if it is a file, it should be flocked. Blockstore API calls may panic if this is not upheld.

pub fn roots(&self) -> &NonEmpty<Cid>

pub fn heaviest_tipset(&self) -> Result<Tipset>

pub fn into_dyn(self) -> PlainCar<Box<dyn RandomAccessFileReader>>

Trait Implementations

impl<ReaderT> Blockstore for PlainCar<ReaderT>

where ReaderT: ReadAt,

fn put_keyed(&self, k: &Cid, block: &[u8]) -> Result<()>

Panics

• If the write cache already contains different data with this CID
• See also Self::new.

Note: Locks have to be acquired in exactly the same order as in get, otherwise a deadlock is imminent in a multi-threaded context.

fn get(&self, k: &Cid) -> Result<Option<Vec<u8>>>

Gets the block from the blockstore.

fn has(&self, k: &Cid<64>) -> Result<bool, Error>

Checks if the blockstore has the specified block.

fn put<D>(&self, mh_code: Code, block: &Block<D>) -> Result<Cid<64>, Error>

where Self: Sized, D: AsRef<[u8]>,

Puts the block into the blockstore, computing the hash with the specified multicodec.

fn put_many<D, I>(&self, blocks: I) -> Result<(), Error>

where Self: Sized, D: AsRef<[u8]>, I: IntoIterator<Item = (Code, Block<D>)>,

Bulk put blocks into the blockstore.

fn put_many_keyed<D, I>(&self, blocks: I) -> Result<(), Error>

where Self: Sized, D: AsRef<[u8]>, I: IntoIterator<Item = (Cid<64>, D)>,

Bulk-put pre-keyed blocks into the blockstore.

impl<ReaderT> From<PlainCar<ReaderT>> for AnyCar<ReaderT>

fn from(car: PlainCar<ReaderT>) -> Self

Converts to this type from the input type.

impl TryFrom<&'static [u8]> for PlainCar<&'static [u8]>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(bytes: &'static [u8]) -> Result<Self>

Performs the conversion.