Struct MonitoredStateStore

pub struct MonitoredStateStore<S, E = ()> {
    inner: Box<S>,
    storage_metrics: Arc<MonitoredStorageMetrics>,
    extra: E,
}

A state store wrapper for monitoring metrics.

Fields

inner: Box<S>

storage_metrics: Arc<MonitoredStorageMetrics>

extra: E

Implementations

impl<S> MonitoredStateStore<S>

pub fn new(inner: S, storage_metrics: Arc<MonitoredStorageMetrics>) -> Self

pub fn inner(&self) -> &S

impl<S> MonitoredStateStore<S, TableId>

fn new( inner: S, storage_metrics: Arc<MonitoredStorageMetrics>, table_id: TableId, ) -> Self

fn table_id(&self) -> TableId

impl<S, E> MonitoredStateStore<S, E>

async fn monitored_iter<'a, Item: IterItem, I: StateStoreIter<Item> + 'a, Stat: StateStoreIterStatsTrait<Item = Item>>( &'a self, table_id: TableId, iter_stream_future: impl Future<Output = StorageResult<I>> + 'a, ) -> StorageResult<MonitoredStateStoreIter<Item, I, Stat>>

async fn monitored_on_key_value<O>( &self, on_key_value_future: impl Future<Output = StorageResult<Option<(O, usize)>>>, table_id: TableId, key_len: usize, ) -> StorageResult<Option<O>>

impl MonitoredStateStore<HummockStorage>

pub fn sstable_store(&self) -> SstableStoreRef

pub fn object_id_manager(&self) -> ObjectIdManagerRef

Trait Implementations

impl<S: AsHummock> AsHummock for MonitoredStateStore<S>

fn as_hummock(&self) -> Option<&HummockStorage>

fn sync( &self, sync_table_epochs: Vec<(HummockEpoch, HashSet<TableId>)>, ) -> BoxFuture<'_, StorageResult<SyncResult>>

impl<S: Clone, E: Clone> Clone for MonitoredStateStore<S, E>

fn clone(&self) -> MonitoredStateStore<S, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: LocalStateStore> LocalStateStore for MonitoredStateStore<S, TableId>

type FlushedSnapshotReader = MonitoredStateStore<<S as LocalStateStore>::FlushedSnapshotReader, TableId>

type Iter<'a> = impl StateStoreIter + 'a

type RevIter<'a> = impl StateStoreIter + 'a

fn iter( &self, key_range: TableKeyRange, read_options: ReadOptions, ) -> impl Future<Output = StorageResult<Self::Iter<'_>>> + Send + '_

Opens and returns an iterator for given prefix_hint and full_key_range Internally, prefix_hint will be used to for checking bloom_filter and full_key_range used for iter. (if the prefix_hint not None, it should be be included in key_range) The returned iterator will iterate data based on the latest written snapshot.

fn rev_iter( &self, key_range: TableKeyRange, read_options: ReadOptions, ) -> impl Future<Output = StorageResult<Self::RevIter<'_>>> + Send + '_

fn insert( &mut self, key: TableKey<Bytes>, new_val: Bytes, old_val: Option<Bytes>, ) -> StorageResult<()>

Inserts a key-value entry associated with a given epoch into the state store.

fn delete(&mut self, key: TableKey<Bytes>, old_val: Bytes) -> StorageResult<()>

Deletes a key-value entry from the state store. Only the key-value entry with epoch smaller than the given epoch will be deleted.

fn get_table_watermark(&self, vnode: VirtualNode) -> Option<Bytes>

Get last persisted watermark for a given vnode.

fn new_flushed_snapshot_reader(&self) -> Self::FlushedSnapshotReader

async fn update_vnode_bitmap( &mut self, vnodes: Arc<Bitmap>, ) -> StorageResult<Arc<Bitmap>>

impl<S: StateStore> StateStore for MonitoredStateStore<S>

type Local = MonitoredStateStore<<S as StateStore>::Local, TableId>

type ReadSnapshot = MonitoredStateStore<<S as StateStore>::ReadSnapshot, TableId>

type VectorWriter = MonitoredStateStore<<S as StateStore>::VectorWriter, TableId>

fn try_wait_epoch( &self, epoch: HummockReadEpoch, options: TryWaitEpochOptions, ) -> impl Future<Output = StorageResult<()>> + Send + '_

If epoch is Committed, we will wait until the epoch is committed and its data is ready to read. If epoch is Current, we will only check if the data can be read with this epoch.

fn monitored( self, _storage_metrics: Arc<MonitoredStorageMetrics>, ) -> MonitoredStateStore<Self>

Creates a MonitoredStateStore from this state store, with given stats.

async fn new_local(&self, option: NewLocalOptions) -> Self::Local

async fn new_read_snapshot( &self, epoch: HummockReadEpoch, options: NewReadSnapshotOptions, ) -> StorageResult<Self::ReadSnapshot>

async fn new_vector_writer( &self, options: NewVectorWriterOptions, ) -> Self::VectorWriter

impl<S: StateStoreGet> StateStoreGet for MonitoredStateStore<S, TableId>

fn on_key_value<O: Send + 'static>( &self, key: TableKey<Bytes>, read_options: ReadOptions, on_key_value_fn: impl KeyValueFn<O>, ) -> impl StorageFuture<'_, Option<O>>

impl<S: StateStoreRead> StateStoreRead for MonitoredStateStore<S, TableId>

type Iter = impl StateStoreReadIter

type RevIter = impl StateStoreReadIter

fn iter( &self, key_range: TableKeyRange, read_options: ReadOptions, ) -> impl Future<Output = StorageResult<Self::Iter>> + '_

Opens and returns an iterator for given prefix_hint and full_key_range Internally, prefix_hint will be used to for checking bloom_filter and full_key_range used for iter. (if the prefix_hint not None, it should be be included in key_range) The returned iterator will iterate data based on a snapshot corresponding to the given epoch.

fn rev_iter( &self, key_range: TableKeyRange, read_options: ReadOptions, ) -> impl Future<Output = StorageResult<Self::RevIter>> + '_

impl<S: StateStoreReadLog> StateStoreReadLog for MonitoredStateStore<S>

type ChangeLogIter = impl StateStoreReadChangeLogIter

fn next_epoch( &self, epoch: u64, options: NextEpochOptions, ) -> impl StorageFuture<'_, u64>

fn iter_log( &self, epoch_range: (u64, u64), key_range: TableKeyRange, options: ReadLogOptions, ) -> impl Future<Output = StorageResult<Self::ChangeLogIter>> + Send + '_

impl<S: StateStoreReadVector> StateStoreReadVector for MonitoredStateStore<S, TableId>

fn nearest<O: Send + 'static>( &self, vec: Vector, options: VectorNearestOptions, on_nearest_item_fn: impl OnNearestItemFn<O>, ) -> impl StorageFuture<'_, Vec<O>>

impl<S: StateStoreWriteEpochControl> StateStoreWriteEpochControl for MonitoredStateStore<S, TableId>

fn flush(&mut self) -> impl Future<Output = StorageResult<usize>> + Send + '_

async fn init(&mut self, options: InitOptions) -> StorageResult<()>

Initializes the state store with given epoch pair. Typically we will use epoch.curr as the initialized epoch, Since state table will begin as empty. In some cases like replicated state table, state table may not be empty initially, as such we need to wait for epoch.prev checkpoint to complete, hence this interface is made async.

fn seal_current_epoch(&mut self, next_epoch: u64, opts: SealCurrentEpochOptions)

Updates the monotonically increasing write epoch to new_epoch. All writes after this function is called will be tagged with new_epoch. In other words, the previous write epoch is sealed.

fn try_flush(&mut self) -> impl Future<Output = StorageResult<()>> + Send + '_

impl<S: StateStoreWriteVector> StateStoreWriteVector for MonitoredStateStore<S, TableId>

fn insert(&mut self, vec: Vector, info: Bytes) -> StorageResult<()>