Struct mz_persist_client::cache::PersistClientCache

pub struct PersistClientCache {
    pub cfg: PersistConfig,
    pub(crate) metrics: Arc<Metrics>,
    blob_by_uri: Mutex<BTreeMap<SensitiveUrl, (RttLatencyTask, Arc<dyn Blob>)>>,
    consensus_by_uri: Mutex<BTreeMap<SensitiveUrl, (RttLatencyTask, Arc<dyn Consensus>)>>,
    isolated_runtime: Arc<IsolatedRuntime>,
    pub(crate) state_cache: Arc<StateCache>,
    pubsub_sender: Arc<dyn PubSubSender>,
    _pubsub_receiver_task: JoinHandle<()>,
}

A cache of PersistClients indexed by PersistLocations.

There should be at most one of these per process. All production PersistClients should be created through this cache.

This is because, in production, persist is heavily limited by the number of server-side Postgres/Aurora connections. This cache allows PersistClients to share, for example, these Postgres connections.

Fields

cfg: PersistConfig

The tunable knobs for persist.

metrics: Arc<Metrics>

blob_by_uri: Mutex<BTreeMap<SensitiveUrl, (RttLatencyTask, Arc<dyn Blob>)>>

consensus_by_uri: Mutex<BTreeMap<SensitiveUrl, (RttLatencyTask, Arc<dyn Consensus>)>>

isolated_runtime: Arc<IsolatedRuntime>

state_cache: Arc<StateCache>

pubsub_sender: Arc<dyn PubSubSender>

_pubsub_receiver_task: JoinHandle<()>

Implementations

impl PersistClientCache

pub fn new<F>(cfg: PersistConfig, registry: &MetricsRegistry, pubsub: F) -> Self

where F: FnOnce(&PersistConfig, Arc<Metrics>) -> PubSubClientConnection,

Returns a new PersistClientCache.

pub fn new_no_metrics() -> Self

A test helper that returns a PersistClientCache disconnected from metrics.

pub fn cfg(&self) -> &PersistConfig

Returns the PersistConfig being used by this cache.

pub fn metrics(&self) -> &Arc<Metrics>

Returns persist Metrics.

pub fn shard_metrics(&self, shard_id: &ShardId, name: &str) -> Arc<ShardMetrics>

Returns ShardMetrics for the given shard.

pub fn clear_state_cache(&mut self)

Clears the state cache, allowing for tests with disconnected states.

Only exposed for testing.

pub async fn open( &self, location: PersistLocation, ) -> Result<PersistClient, ExternalError>

Returns a new PersistClient for interfacing with persist shards made durable to the given PersistLocation.

The same location may be used concurrently from multiple processes.

const PROMETHEUS_SCRAPE_INTERVAL: Duration = _

async fn open_consensus( &self, consensus_uri: SensitiveUrl, ) -> Result<Arc<dyn Consensus>, ExternalError>

async fn open_blob( &self, blob_uri: SensitiveUrl, ) -> Result<Arc<dyn Blob>, ExternalError>

Trait Implementations

impl Debug for PersistClientCache

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

Formats the value using the given formatter.