Struct mz_persist_client::cache::PersistClientCache

pub struct PersistClientCache {
    pub(crate) cfg: PersistConfig,
    pub(crate) metrics: Arc<Metrics>,
    blob_by_uri: Mutex<BTreeMap<String, (RttLatencyTask, Arc<dyn Blob + Send + Sync>)>>,
    consensus_by_uri: Mutex<BTreeMap<String, (RttLatencyTask, Arc<dyn Consensus + Send + Sync>)>>,
    cpu_heavy_runtime: Arc<CpuHeavyRuntime>,
}

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

metrics: Arc<Metrics>

blob_by_uri: Mutex<BTreeMap<String, (RttLatencyTask, Arc<dyn Blob + Send + Sync>)>>

consensus_by_uri: Mutex<BTreeMap<String, (RttLatencyTask, Arc<dyn Consensus + Send + Sync>)>>

cpu_heavy_runtime: Arc<CpuHeavyRuntime>

Implementations

impl PersistClientCache

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

Returns a new PersistClientCache.

pub fn cfg(&self) -> &PersistConfig

Returns the PersistConfig being used by this cache.

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: String
) -> Result<Arc<dyn Consensus + Send + Sync>, ExternalError>

async fn open_blob(
    &self,
    blob_uri: String
) -> Result<Arc<dyn Blob + Send + Sync>, ExternalError>

Trait Implementations

impl Debug for PersistClientCache

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

Formats the value using the given formatter.