Enum Backend 

pub enum Backend {
    S3(S3Backend),
    Azure(AzureBackend),
    Gcs(GcsBackend),
    B2(B2Backend),
    Filesystem(FilesystemBackend),
    Sftp(SftpBackend),
    WebDav(WebDavBackend),
    Rclone(RcloneBackend),
}

The discriminated backend union. Exactly one variant by construction.

Representation choice

ADR-0003 §3.1 sketches this as #[serde(tag = "kind")] (a kind: S3 inline discriminant). In practice an internally-tagged enum cannot produce a valid Kubernetes structural schema: kube’s schema rewriter hoists oneOf branch properties to the root and requires the shared kind property to be identical across branches, but each variant needs a distinct kind const — a hard conflict. We therefore use serde’s externally-tagged representation (backend: { s3: {...} }), which:

• is exactly the YAML shape ADR-0001 §3.1 actually used (backend.s3.bucket);
• generates a valid structural schema (a oneOf of distinct optional properties — kubectl enforces “exactly one backend”);
• preserves the ADR’s type-safety thesis verbatim — this is still a Rust enum, a value is still exactly one variant, and reconcilers still match it exhaustively.

The webhook (api::validate) validates content (bucket-name format, credential-secret reachability) that the schema can’t express.

Variants

S3(S3Backend)

Amazon S3 or any S3-compatible object store (MinIO, RustFS, Ceph RGW, …).

Azure(AzureBackend)

Azure Blob Storage.

Gcs(GcsBackend)

Google Cloud Storage.

B2(B2Backend)

Backblaze B2.

Filesystem(FilesystemBackend)

A local filesystem path, backed by a PVC the operator mounts into the mover.

Sftp(SftpBackend)

SFTP server.

WebDav(WebDavBackend)

WebDAV endpoint.

Rclone(RcloneBackend)

Any rclone remote (kopia shells out to rclone), broadening reach to providers without a native kopia backend.

Implementations

impl Backend

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

Stable discriminant string for status/metrics/printcolumns.

Returns the variant’s PascalCase name, independent of the camelCase wire key (backend: { s3: ... } deserializes to Backend::S3, whose kind_str() is "S3").

use kopiur_api::backend::{Backend, FilesystemBackend};

let b = Backend::Filesystem(FilesystemBackend {
    path: "/repo".into(),
    pvc_name: None,
});
assert_eq!(b.kind_str(), "Filesystem");

// The wire key is camelCase, but the discriminant stays PascalCase.
let s3: Backend = serde_json::from_value(serde_json::json!({
    "s3": { "bucket": "my-backups" }
}))
.unwrap();
assert_eq!(s3.kind_str(), "S3");

Trait Implementations

impl Clone for Backend

fn clone(&self) -> Backend

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Backend

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Backend

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Backend

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 Backend

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Backend

impl StructuralPartialEq for Backend