Enum SeedSource 

pub enum SeedSource {
    Backend(Box<Backend>),
    Repository(RepositoryRef),
}

Where a seed reads from — exactly one of, externally tagged (from: { backend: { s3: {...} } } or from: { repository: {...} }).

The two variants are genuinely different operations, not two spellings of one: blob mode copies raw storage and inherits the source’s format and password; migrate mode copies snapshot manifests between two independently encrypted repositories. Making them one enum is what forces every handler to answer for both.

use kopiur_api::seed::SeedSource;

// Blob mode: the wire form is `{ "backend": { "s3": { ... } } }`.
let blob: SeedSource = serde_json::from_value(serde_json::json!({
    "backend": { "s3": { "bucket": "offsite-mirror" } }
}))
.unwrap();
assert_eq!(blob.mode(), kopiur_api::seed::SeedMode::Blob);
assert_eq!(blob.describe(), "S3");

// Migrate mode: another repository CR.
let migrate: SeedSource = serde_json::from_value(serde_json::json!({
    "repository": { "kind": "ClusterRepository", "name": "offsite" }
}))
.unwrap();
assert_eq!(migrate.mode(), kopiur_api::seed::SeedMode::Migrate);
assert_eq!(migrate.describe(), "ClusterRepository/offsite");

Variants

Backend(Box<Backend>)

A bare storage backend holding a byte-for-byte mirror of a kopia repository (blob mode, kopia repository sync-to). The mirror’s format and encryption password are inherited verbatim, so this repository’s encryption.passwordSecretRef must already hold the MIRROR’s password and spec.create’s format knobs are refused as inert.

Repository(RepositoryRef)

Another Repository/ClusterRepository, opened read-only (migrate mode, kopia snapshot migrate). Snapshot identities and times are preserved, so seeded history is restorable by identity/fromPolicy.

A kind: Repository reference with no namespace resolves in the referrer’s own namespace — and, on a cluster-scoped ClusterRepository (which has none), in the operator’s namespace, the same rule its credential secretRefs follow. Set namespace explicitly whenever the source lives anywhere else.

Implementations

impl SeedSource

pub fn mode(&self) -> SeedMode

Which copy mechanism this source selects. Exhaustive, so a new variant cannot compile until its mode is decided.

pub fn describe(&self) -> String

The rendering pinned into status.seed.source: the Backend::kind_str discriminant (S3, Filesystem, …) for blob mode, Kind/name (with namespace/ when the reference sets one) for migrate mode.

Lives here so the controller, the CLI and any diagnostic describe a seed source identically instead of each re-deriving a string.

use kopiur_api::seed::SeedSource;

let cross_ns: SeedSource = serde_json::from_value(serde_json::json!({
    "repository": { "name": "nas", "namespace": "backups" }
}))
.unwrap();
assert_eq!(cross_ns.describe(), "Repository/backups/nas");

Trait Implementations

impl Clone for SeedSource

fn clone(&self) -> SeedSource

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SeedSource

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SeedSource

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for SeedSource

impl JsonSchema for SeedSource

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 SeedSource

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

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 SeedSource