Struct ColdConfig 

pub struct ColdConfig {

    pub backend: ColdBackend,
    pub root: Option<String>,
    pub s3: Option<S3Config>,
    pub cache: Option<ColdCacheConfig>,
    pub flush_interval: HumanDuration,
    pub flush_size: HumanSize,
    pub flush_min_hot_size: Option<HumanSize>,
    pub flush_pressure_hot_size: HumanSize,
    pub flush_max_size: Option<HumanSize>,
    pub flush_max_concurrency: usize,
    pub compaction_enabled: bool,
    pub compaction_interval: HumanDuration,
    pub compaction_target_size: HumanSize,
    pub compaction_max_size: HumanSize,
    pub compaction_max_streams_per_pass: usize,
    pub compaction_gc_grace: HumanDuration,
    pub max_hot_size_per_group: Option<HumanSize>,
    pub gc_interval: HumanDuration,
    pub gc_max_entries: usize,
}

Cold-tier flush, GC, and cache configuration.

Fields

backend: ColdBackend

Cold-storage backend.

root: Option<String>

Root prefix for cold-storage objects (e.g. S3 prefix or local dir).

s3: Option<S3Config>

S3-specific connection and credential settings. Required when backend is S3.

cache: Option<ColdCacheConfig>

Optional cold-read cache.

flush_interval: HumanDuration

Interval between periodic cold-flush passes. Must be non-zero.

flush_size: HumanSize

Target number of hot bytes to flush per group per pass.

flush_min_hot_size: Option<HumanSize>

Minimum hot bytes a group must have before it is eligible for flush. Falls back to flush_size when unset.

flush_pressure_hot_size: HumanSize

Aggregate hot bytes across locally led groups that activate a pressure flush. A pressure pass allows undersized groups to flush without changing their independent state ownership. 0 disables the fallback.

flush_max_size: Option<HumanSize>

Upper bound on bytes flushed per group per pass. Falls back to flush_size when unset.

flush_max_concurrency: usize

Max groups flushed concurrently.

compaction_enabled: bool

Enable background same-stream cold chunk compaction.

compaction_interval: HumanDuration

Interval between cold chunk compaction discovery passes.

compaction_target_size: HumanSize

Preferred compacted object size.

compaction_max_size: HumanSize

Hard maximum compacted object size.

compaction_max_streams_per_pass: usize

Maximum streams compacted per pass.

compaction_gc_grace: HumanDuration

Grace period before compacted input objects are physically deleted.

max_hot_size_per_group: Option<HumanSize>

Per-group hot-size cap. When a group’s hot bytes exceed this, new writes are rejected with HTTP 503. None or 0 disables the admission.

gc_interval: HumanDuration

Interval between periodic cold-gc passes. Must be non-zero.

gc_max_entries: usize

Max GC entries to process per group per pass.

Implementations

impl ColdConfig

pub fn flush_min_hot_size(&self) -> HumanSize

Minimum hot bytes a group must have before it is eligible for flush.

Falls back to flush_size when the user does not supply an explicit value.

pub fn flush_max_size(&self) -> HumanSize

Upper bound on bytes flushed per group per pass.

Falls back to flush_size when the user does not supply an explicit value.

Trait Implementations

impl Clone for ColdConfig

fn clone(&self) -> ColdConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ColdConfig

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

Formats the value using the given formatter.

impl Default for ColdConfig

fn default() -> ColdConfig

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ColdConfig

where ColdConfig: Default,

fn deserialize<__D>( __deserializer: __D, ) -> Result<ColdConfig, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ColdConfig

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.