Struct Store 

pub struct Store<S: TileStore> { /* private fields */ }

The store: the data writer, the manifest writer when split, the live runs, and the size a trusted checkpoint covers.

Implementations

impl<S: TileStore> Store<S>

pub fn open(store: S, keys: Keys) -> Result<Self, Error>

Opens a shared log on store with the writer lock, rebuilding the live set from the logged manifests when the cache does not match them.

pub fn open_split(data: S, index: S, keys: Keys) -> Result<Self, Error>

Opens a split log: entries go to data, run files and manifests to index. Both writer locks are held.

pub fn open_trusting( store: S, keys: Keys, size: u64, root: [u8; 32], ) -> Result<Self, Error>

Like Store::open, trusting root as the root at size: what AuthenticatedLog::recover proves the current data tree consistent with. The pair comes from a signed checkpoint kept where the store’s writer cannot reach it.

pub fn live_runs(&self) -> &[RunManifest]

The runs a lookup goes through, oldest first.

pub fn size(&self) -> u64

The number of entries in the data tree.

pub fn root(&self) -> [u8; 32]

The root of the data tree.

pub fn writer(&self) -> &Writer<S>

The data writer, for checkpoints.

pub fn index_writer(&self) -> Option<&Writer<S>>

The index log’s writer when split, for its own checkpoint.

pub fn index(&self) -> Result<Index<&S>, Error>

Lookups at the current trees, sharing this store’s run cache.

pub fn append_batch<I>(&mut self, entries: I) -> Result<Range<u64>, Error>

where I: IntoIterator<Item = Vec<u8>>,

Appends entries in order and returns their index range; the batch is written once. Nothing is written when an entry starts with the manifest magic or is over the tiles entry length.

Trait Implementations

impl<S: TileStore> AuthenticatedLog for Store<S>

fn append(&mut self, entry: &[u8]) -> Result<u64, Error>

Append one entry; returns its log index.

fn find(&self, key: &[u8]) -> Result<Vec<Located>, Error>

Every entry carrying key, each with the run that located it. An empty answer is proven, not assumed: the logged runs’ entry ranges cover every index below the checkpoint size except the scanned tail, or the answer is Error::Tree, since a withheld run file would otherwise hide an entry without doctoring any bytes.

fn range(&self, range: RangeInclusive<&[u8]>) -> Result<Vec<Located>, Error>

Every entry whose keys fall in range, in key order, with their runs.

fn seal(&mut self) -> Result<RunManifest, Error>

Seal the unsealed tail into a run and log its manifest.

fn compact(&mut self) -> Result<Compaction, Error>

Merge runs into one and log the result.

fn recover(&mut self) -> Result<Recovery, Error>

Replay past the last checkpoint and prove the result consistent.