Struct EpochParameters 

pub struct EpochParameters {
    pub min_duration: Option<String>,
    pub refresh_frequency: Option<String>,
    pub advance_on_count: Option<i64>,
    pub advance_on_size_mb: Option<i64>,
    pub checkpoint_frequency: Option<i64>,
    pub delete_parallelism: Option<i64>,
}

kopia epoch-manager parameters. Absent fields are left at whatever the repository already has (kopia’s defaults, noted per field).

An epoch may only advance once it is older than minDuration AND has accumulated advanceOnCount blobs or advanceOnSizeMB of index data. minDuration is a floor, so kopia’s 24h default means a busy fleet — say 17 hourly policies at ~60 index blobs/hour — is forced to ~1700 blobs before an epoch may close, and kopia only compacts two epochs behind. The repository then permanently carries thousands of uncompacted index blobs, tripping IndexBlobHealth and slowing every mover’s connect. Lowering minDuration is the lever for that (#258).

cleanupSafetyMargin is deliberately observable but not settable: its job is to stop kopia deleting index blobs a concurrent writer still needs, and there is no safe generic advice for lowering it.

Every field here has an admission floor (#458), because kopia repository set-parameters merges the flags it is given into the repository’s existing parameters and then validates the whole resulting set — so ONE out-of-range value refuses the entire call and discards every other parameter in the same apply. The floors:

• minDuration: at least 10m, and at least 3x refreshFrequency (kopia’s untouched 20m default when none is declared — which is why minDuration: 10m alone is rejected, and 60m is the smallest value that stands on its own).
• refreshFrequency: at most 80m, because kopia needs cleanupSafetyMargin to be at least 3x it and the margin is stuck at kopia’s 4h default (kopiur cannot set it).
• advanceOnCount: at least 10. advanceOnSizeMiB: at least 1.
• checkpointFrequency: at least 1. deleteParallelism: at least 1.

Fields

min_duration: Option<String>

Minimum epoch age before it may advance (kopia default 24h). A Go-style duration (6h, 90m). The advance gate — no blob count closes an epoch younger than this.

Must be at least 10m (kopia’s absolute floor) AND at least 3x refreshFrequency. When refreshFrequency is not declared, that second bound is measured against kopia’s untouched 20m default, so 10m on its own is rejected: use 60m, or declare a refreshFrequency of a third of it or less alongside it.

refresh_frequency: Option<String>

How often clients re-read epoch state (kopia default 20m). Go-style duration.

At most 80m: kopia requires cleanupSafetyMargin >= 3x this value, and cleanupSafetyMargin is observable-but-not-settable here, so it stays at kopia’s 4h default and 4h / 3 is a hard ceiling.

advance_on_count: Option<i64>

Index blobs in an epoch that trigger an advance, once older than minDuration (kopia default 20).

At least 10 — kopia refuses anything lower with “epoch advance on count too low”.

advance_on_size_mb: Option<i64>

Total index size in an epoch that triggers an advance, once older than minDuration (kopia default 10 MiB).

At least 1 — kopia refuses anything lower with “epoch advance on size too low”, and 1 MiB is the smallest threshold the flag can express.

Named MiB, not MB, with an explicit rename rather than the derived camelCase (advanceOnSizeMb, which reads as megabit). The unit is genuinely mebibytes — kopia’s --epoch-advance-on-size-mb multiplies by 1048576, so 10 is 10485760 bytes — even though kopia’s own log renders the result as “MB”. That ambiguity is this field’s main hazard; the API surface should not reproduce it.

checkpoint_frequency: Option<i64>

Epochs between full index checkpoints (kopia default 7).

At least 1 — kopia refuses anything lower with “invalid epoch range compaction period”.

delete_parallelism: Option<i64>

Parallelism for epoch cleanup deletions (kopia default 4).

At least 1. This floor is kopiur’s own: kopia does not validate the field, so a non-positive value would ask it to run epoch cleanup with no workers.

Trait Implementations

impl Clone for EpochParameters

fn clone(&self) -> EpochParameters

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EpochParameters

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

Formats the value using the given formatter.

impl Default for EpochParameters

fn default() -> EpochParameters

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for EpochParameters

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for EpochParameters

impl JsonSchema for EpochParameters

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for EpochParameters

fn eq(&self, other: &EpochParameters) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for EpochParameters

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for EpochParameters