Enum BlobRetention 

pub enum BlobRetention {
    Governance(RetentionWindow),
    Compliance(RetentionWindow),
    Disabled(bool),
}

Object-lock blob retention (kopia repository set-parameters --retention-mode/--retention-period).

Externally tagged, so exactly one variant exists by construction. That is load-bearing rather than stylistic: kopia rejects a mode without a period and a period without a mode (“both retention mode and period must be provided when setting blob retention properties”), and pairing the period with the mode in the type makes that error unrepresentable instead of merely validated.

Requires a backend that supports object lock — S3, Azure, or GCS — and a bucket with object lock enabled at creation time (it cannot be turned on afterwards). kopia’s flags do not create it. On an unsupported backend set-parameters hard-fails with blob-retention: unsupported put-blob option, so admission rejects those backends.

What this does and does not protect

The lock is applied when a blob is written. Kopiur does not enable kopia’s maintenance set --extend-object-locks, so locks on blobs that are still needed are never extended: a blob written today under period: 720h becomes deletable again in 30 days. Treat it as a rolling floor, not cumulative immutability, and size the period to exceed your longest recovery window. Blobs written before retention was enabled — including the repository format blob — are never retroactively locked.

use kopiur_api::repository::{BlobRetention, RetentionWindow};

// Externally tagged: the wire form is `{ "governance": { "period": "720h" } }`.
let r: BlobRetention = serde_json::from_value(serde_json::json!({
    "governance": { "period": "720h" }
}))
.unwrap();
assert_eq!(r, BlobRetention::Governance(RetentionWindow { period: "720h".into() }));
assert_eq!(r.kind_str(), "Governance");

// Disabling carries no period — kopia ignores it, and the type says so.
let off: BlobRetention = serde_json::from_value(serde_json::json!({ "disabled": true }))
    .unwrap();
assert_eq!(off.kind_str(), "Disabled");

Variants

Governance(RetentionWindow)

GOVERNANCE — locked against ordinary deletes, but a sufficiently privileged identity can still shorten or remove the lock. The safe default for most clusters.

Compliance(RetentionWindow)

COMPLIANCE — nobody can shorten or remove the lock before it expires, including the account root. An oversized period is an unfixable storage-cost commitment; there is no recovery path short of deleting the bucket after expiry.

Disabled(bool)

Actively disable retention (--retention-mode=none). Must be true.

A bool rather than a unit variant because an externally-tagged unit variant serializes as the bare string "Disabled", mixing string and object forms in one oneOf and breaking the structural schema. Same shape, and same reason, as crate::cluster_repository::AllowedNamespaces::All.

This is distinct from omitting blobRetention entirely: absent means “leave the repository alone”, so deleting the block from a manifest can never silently strip ransomware protection someone configured deliberately.

Implementations

impl BlobRetention

pub fn kind_str(&self) -> &'static str

Stable discriminant string for status/metrics/printcolumns.

pub fn window(&self) -> Option<&RetentionWindow>

The declared retention window, or None when retention is being disabled.

Trait Implementations

impl Clone for BlobRetention

fn clone(&self) -> BlobRetention

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BlobRetention

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BlobRetention

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for BlobRetention

impl JsonSchema for BlobRetention

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 BlobRetention

fn eq(&self, other: &BlobRetention) -> 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 BlobRetention

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 BlobRetention