koprs 0.8.3

A reusable, ergonomic library that streamlines Kubernetes operator development, allowing developers to build controllers with significantly less code.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! Fluent builder for [`ObjectMeta`].

use k8s_openapi::apimachinery::pkg::apis::meta::v1::OwnerReference;
use kube::core::ObjectMeta;
use std::collections::BTreeMap;

/// Fluent builder for [`ObjectMeta`].
///
/// Constructs the metadata block for any Kubernetes object. Each setter
/// returns `self` for chaining; call [`build`][ObjectMetaBuilder::build]
/// to produce the final [`ObjectMeta`].
///
/// # Examples
///
/// ```
/// use koprs::meta::ObjectMetaBuilder;
///
/// let meta = ObjectMetaBuilder::new()
///     .name("my-configmap")
///     .namespace("my-namespace")
///     .label("app.kubernetes.io/managed-by", "my-operator")
///     .label("my-operator/owner", "my-cr")
///     .build();
///
/// assert_eq!(meta.name.as_deref(), Some("my-configmap"));
/// assert_eq!(meta.namespace.as_deref(), Some("my-namespace"));
/// assert_eq!(meta.labels.as_ref().unwrap().len(), 2);
/// ```
#[derive(Default)]
pub struct ObjectMetaBuilder {
    name: Option<String>,
    namespace: Option<String>,
    labels: BTreeMap<String, String>,
    annotations: BTreeMap<String, String>,
    owner_references: Vec<OwnerReference>,
}

impl ObjectMetaBuilder {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn name(mut self, name: impl Into<String>) -> Self {
        self.name = Some(name.into());
        self
    }

    pub fn namespace(mut self, namespace: impl Into<String>) -> Self {
        self.namespace = Some(namespace.into());
        self
    }

    /// Add a single label.
    pub fn label(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
        self.labels.insert(key.into(), value.into());
        self
    }

    /// Add multiple labels from an iterable of `(key, value)` pairs.
    pub fn labels(
        mut self,
        pairs: impl IntoIterator<Item = (impl Into<String>, impl Into<String>)>,
    ) -> Self {
        for (k, v) in pairs {
            self.labels.insert(k.into(), v.into());
        }
        self
    }

    /// Add a single annotation.
    pub fn annotation(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
        self.annotations.insert(key.into(), value.into());
        self
    }

    /// Add an owner reference (e.g. from [`owner_ref`][crate::owners::owner_ref]).
    pub fn owner_ref(mut self, owner_ref: OwnerReference) -> Self {
        self.owner_references.push(owner_ref);
        self
    }

    /// Consume the builder and produce an [`ObjectMeta`].
    pub fn build(self) -> ObjectMeta {
        ObjectMeta {
            name: self.name,
            namespace: self.namespace,
            labels: if self.labels.is_empty() {
                None
            } else {
                Some(self.labels)
            },
            annotations: if self.annotations.is_empty() {
                None
            } else {
                Some(self.annotations)
            },
            owner_references: if self.owner_references.is_empty() {
                None
            } else {
                Some(self.owner_references)
            },
            ..Default::default()
        }
    }
}