Struct persist::indexed::cache::BlobCache

pub struct BlobCache<B> {
    build_version: Version,
    metrics: Arc<Metrics>,
    blob: Arc<Mutex<B>>,
    async_runtime: Arc<AsyncRuntime>,
    cache: BlobCacheInner,
    prev_meta_len: u64,
}

A disk-backed cache for objects in Blob storage.

The data for the objects in the cache is stored on disk, mmap’d, and a validated handle is stored in-memory to avoid repeatedly decoding it.

TODO: Add a limit to bound how much disk this cache can use. The Arc return type for get_batch seems correct, but means that a bad user could starve the cache by indefinitely holding handles. The Arcs could be made into weak references so the cache could forcefully reclaim the backing data, but this is going to make performance of using the cached batches unpredictable. I think we probably want a soft limit and a hard limit where the soft limit does some alerting and the hard limit starts blocking (or erroring) until disk space frees up.

Fields

build_version: Version

metrics: Arc<Metrics>

blob: Arc<Mutex<B>>

async_runtime: Arc<AsyncRuntime>

cache: BlobCacheInner

prev_meta_len: u64

Implementations

impl<B: BlobRead> BlobCache<B>

const META_KEY: &'static str

const DEFAULT_CACHE_SIZE_LIMIT: usize

pub fn new(
    build: BuildInfo,
    metrics: Arc<Metrics>,
    async_runtime: Arc<AsyncRuntime>,
    blob: B,
    cache_size_limit: Option<usize>
) -> Self

Returns a new, empty cache for the given Blob storage.

pub fn close(&mut self) -> Result<bool, Error>

Synchronously closes the cache, releasing exclusive-writer locks and causing all future commands to error.

This method is idempotent. Returns true if the blob had not previously been closed.

fn fetch_unsealed_batch_sync(
    &self,
    key: &str,
    hint: CacheHint
) -> Result<Arc<BlobUnsealedBatch>, Error>

Synchronously fetches the batch for the given key.

pub fn get_unsealed_batch_async(
    &self,
    key: &str,
    hint: CacheHint
) -> PFuture<Arc<BlobUnsealedBatch>>

Asynchronously returns the batch for the given key, fetching in another thread if it’s not already in the cache.

fn fetch_trace_batch_sync(
    &self,
    key: &str,
    hint: CacheHint
) -> Result<Arc<BlobTraceBatch>, Error>

Synchronously fetches the batch for the given key.

pub fn get_trace_batch_async(
    &self,
    key: &str,
    hint: CacheHint
) -> PFuture<Arc<BlobTraceBatch>>

Asynchronously returns the batch for the given key, fetching in another thread if it’s not already in the cache.

pub fn get_meta(&self) -> Result<Option<BlobMeta>, Error>

Fetches metadata about what batches are in Blob storage.

fn check_meta_build_version(&self, meta: &ProtoMeta) -> Result<(), Error>

pub fn list_keys(&self) -> Result<Vec<String>, Error>

Returns the list of keys known to the underlying Blob.

impl<B: Blob> BlobCache<B>

pub fn set_unsealed_batch(
    &mut self,
    key: String,
    batch: BlobUnsealedBatch
) -> Result<(ProtoBatchFormat, u64), Error>

Writes a batch to backing Blob storage.

Returns the size of the encoded blob value in bytes.

pub fn delete_unsealed_batch(
    &mut self,
    batch: &UnsealedBatchMeta
) -> Result<(), Error>

Removes a batch from both Blob storage and the local cache.

pub fn set_trace_batch(
    &self,
    key: String,
    batch: BlobTraceBatch
) -> Result<(ProtoBatchFormat, u64), Error>

Writes a batch to backing Blob storage.

Returns the size of the encoded blob value in bytes.

pub fn delete_trace_batch(
    &mut self,
    batch: &TraceBatchMeta
) -> Result<(), Error>

Removes a batch from both Blob storage and the local cache.

pub fn set_meta(&mut self, meta: &BlobMeta) -> Result<(), Error>

Overwrites metadata about what batches are in Blob storage.

fn metric_set_error(&self, err: Error) -> Error

Trait Implementations

impl<B> Clone for BlobCache<B>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B: Debug> Debug for BlobCache<B>

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

Formats the value using the given formatter.