Skip to main content

kaniop_operator/kanidm/reconcile/
mod.rs

1mod ingress;
2pub mod secret;
3mod service;
4pub mod statefulset;
5mod status;
6
7use super::controller::{CONTROLLER_ID, context::Context};
8
9use self::ingress::IngressExt;
10use self::secret::SecretExt;
11use self::service::ServiceExt;
12use self::statefulset::StatefulSetExt;
13use self::status::StatusExt;
14use self::status::{is_kanidm_available, is_kanidm_initialized};
15
16use crate::controller::context::KubeOperations;
17use crate::controller::{INSTANCE_LABEL, MANAGED_BY_LABEL, NAME_LABEL};
18use crate::kanidm::crd::{
19    Kanidm, KanidmReplicaState, KanidmStatus, KanidmUpgradeCheckResult, VersionCompatibilityResult,
20};
21use crate::kanidm::reconcile::statefulset::REPLICA_LABEL;
22use crate::telemetry;
23
24use kaniop_k8s_util::client::get_output;
25use kaniop_k8s_util::error::{Error, Result};
26use kaniop_k8s_util::parse::parse_semver;
27use kaniop_k8s_util::resources::get_image_tag;
28
29use std::collections::BTreeMap;
30use std::fmt::Debug;
31use std::sync::{Arc, LazyLock};
32
33use futures::future::{TryJoinAll, join_all, try_join_all};
34use futures::stream::{self, StreamExt};
35use futures::try_join;
36use k8s_openapi::NamespaceResourceScope;
37use k8s_openapi::api::apps::v1::StatefulSet;
38use k8s_openapi::api::core::v1::Pod;
39use kube::Resource;
40use kube::ResourceExt;
41use kube::api::{Api, AttachParams};
42use kube::runtime::controller::Action;
43use kube::runtime::events::{Event, EventType};
44use kube::runtime::finalizer::{Event as Finalizer, finalizer};
45use serde::{Deserialize, Serialize};
46use tokio::time::Duration;
47use tracing::{Span, debug, field, info, instrument, trace, warn};
48
49pub const CLUSTER_LABEL: &str = "kanidm.kaniop.rs/cluster";
50const KANIDM_OPERATOR_NAME: &str = "kanidms.kaniop.rs";
51pub static KANIDM_FINALIZER: &str = "kanidms.kaniop.rs/finalizer";
52
53const DEFAULT_RECONCILE_INTERVAL: Duration = Duration::from_secs(24 * 60 * 60);
54
55static LABELS: LazyLock<BTreeMap<String, String>> = LazyLock::new(|| {
56    BTreeMap::from([
57        (NAME_LABEL.to_string(), "kanidm".to_string()),
58        (
59            MANAGED_BY_LABEL.to_string(),
60            format!("kaniop-{CONTROLLER_ID}"),
61        ),
62    ])
63});
64
65pub async fn reconcile_admins_secret(
66    kanidm: Arc<Kanidm>,
67    ctx: Arc<Context>,
68    status: &KanidmStatus,
69) -> Result<()> {
70    if is_kanidm_available(status.clone()) && !is_kanidm_initialized(status.clone()) {
71        let admins_secret = kanidm.generate_admins_secret(ctx.clone()).await?;
72        kanidm.patch(&ctx, admins_secret).await?;
73    }
74    Ok(())
75}
76
77pub async fn reconcile_replication_secrets(
78    kanidm: Arc<Kanidm>,
79    ctx: Arc<Context>,
80    status: &KanidmStatus,
81) -> Result<()> {
82    let expected_secret_names = if kanidm.is_replication_enabled() {
83        status
84            .replica_statuses
85            .iter()
86            .map(|rs| kanidm.replica_secret_name(&rs.pod_name))
87            .collect::<Vec<_>>()
88    } else {
89        Vec::new()
90    };
91    let deprecated_secrets = ctx
92        .stores
93        .secret_store
94        .state()
95        .into_iter()
96        .filter(|secret| {
97            secret.namespace() == kanidm.namespace()
98                && kanidm.admins_secret_name() != secret.name_any()
99                && !expected_secret_names.contains(&secret.name_any())
100                && secret
101                    .metadata
102                    .labels
103                    .as_ref()
104                    .is_some_and(|l| l.get(CLUSTER_LABEL) == Some(&kanidm.name_any()))
105        })
106        .collect::<Vec<_>>();
107    let secret_delete_future = deprecated_secrets
108        .iter()
109        .map(|secret| kanidm.delete(&ctx, secret.as_ref()))
110        .collect::<TryJoinAll<_>>();
111    try_join!(secret_delete_future)?;
112
113    if kanidm.is_replication_enabled() {
114        // sequential renewal: concurrent certificate updates are not allowed; abort on first error
115        // https://github.com/kanidm/kanidm/issues/3917
116        for rs in status.replica_statuses.iter().filter(|rs| {
117            rs.state == KanidmReplicaState::CertificateExpiring
118                || rs.state == KanidmReplicaState::CertificateHostInvalid
119        }) {
120            let secret = kanidm
121                .update_replica_secret(ctx.clone(), &rs.pod_name)
122                .await?;
123            kanidm.patch(&ctx, secret.clone()).await?;
124        }
125
126        stream::iter(
127            status
128                .replica_statuses
129                .iter()
130                .filter(|rs| rs.state == KanidmReplicaState::Pending),
131        )
132        .then(|rs| async {
133            let secret = kanidm
134                .generate_replica_secret(ctx.clone(), &rs.pod_name)
135                .await?;
136            kanidm.patch(&ctx, secret).await
137        })
138        .collect::<Vec<_>>()
139        .await
140        .into_iter()
141        .collect::<Result<Vec<_>>>()?;
142
143        // If there are any replicas in pending or cert expiring state, trigger a restart
144        // of all statefulsets to pickup new certs
145        let has_pending_or_expiring = status
146            .replica_statuses
147            .iter()
148            .any(|rs| rs.state != KanidmReplicaState::Ready);
149
150        if has_pending_or_expiring {
151            let sts_api = Api::<StatefulSet>::namespaced(
152                ctx.kaniop_ctx.client.clone(),
153                &kanidm.get_namespace(),
154            );
155
156            // Check if any replica group has only 1 replica
157            let has_single_replica = kanidm.spec.replica_groups.iter().any(|rg| rg.replicas == 1);
158
159            let restart_futures = status
160                .replica_statuses
161                .iter()
162                .map(|rs| sts_api.restart(&rs.statefulset_name));
163
164            if has_single_replica {
165                // Restart sequentially to avoid downtime
166                let results = stream::iter(restart_futures)
167                    .then(|f| f)
168                    .collect::<Vec<_>>()
169                    .await;
170                for result in results.iter().filter(|r| r.is_err()) {
171                    warn!(msg = "failed to restart statefulset sequentially", error = ?result);
172                }
173            } else {
174                // Restart concurrently for replica groups with multiple replicas
175                let results = join_all(restart_futures).await;
176                for result in results.iter().filter(|r| r.is_err()) {
177                    warn!(msg = "failed to restart statefulset concurrently", error = ?result);
178                }
179            }
180        }
181    }
182
183    Ok(())
184}
185
186#[instrument(skip(ctx, kanidm))]
187pub async fn reconcile_kanidm(kanidm: Arc<Kanidm>, ctx: Arc<Context>) -> Result<Action> {
188    let trace_id = telemetry::get_trace_id();
189    Span::current().record("trace_id", field::display(&trace_id));
190    let _timer = ctx
191        .kaniop_ctx
192        .metrics
193        .reconcile_count_and_measure(&trace_id);
194    info!(msg = "reconciling Kanidm");
195
196    let status = kanidm.update_status(ctx.clone()).await.map_err(|e| {
197        debug!(msg = "failed to reconcile status", %e);
198        ctx.kaniop_ctx.metrics.status_update_errors_inc();
199        e
200    })?;
201    let kanidm_api: Api<Kanidm> =
202        Api::namespaced(ctx.kaniop_ctx.client.clone(), &kanidm.get_namespace());
203    finalizer(&kanidm_api, KANIDM_FINALIZER, kanidm, |event| async {
204        match event {
205            Finalizer::Apply(kanidm) => reconcile(kanidm, ctx, status).await,
206            Finalizer::Cleanup(kanidm) => cleanup(kanidm, ctx).await,
207        }
208    })
209    .await
210    .map_err(|e| {
211        Error::FinalizerError(
212            "failed on kanidm account finalizer".to_string(),
213            Box::new(e),
214        )
215    })
216}
217
218async fn reconcile(kanidm: Arc<Kanidm>, ctx: Arc<Context>, status: KanidmStatus) -> Result<Action> {
219    let admin_secret_future = reconcile_admins_secret(kanidm.clone(), ctx.clone(), &status);
220    let replication_secret_futures =
221        reconcile_replication_secrets(kanidm.clone(), ctx.clone(), &status);
222
223    let sts_to_delete = {
224        let expected_sts_names = kanidm
225            .spec
226            .replica_groups
227            .iter()
228            .map(|rg| kanidm.statefulset_name(&rg.name))
229            .collect::<Vec<_>>();
230        ctx.stores
231            .stateful_set_store
232            .state()
233            .into_iter()
234            .filter(|sts| {
235                sts.namespace() == kanidm.namespace()
236                    && sts
237                        .metadata
238                        .labels
239                        .as_ref()
240                        .is_some_and(|l| l.get(CLUSTER_LABEL) == Some(&kanidm.name_any()))
241                    && !expected_sts_names.contains(&sts.name_any())
242            })
243            .collect::<Vec<_>>()
244    };
245    let sts_delete_futures = sts_to_delete
246        .iter()
247        .map(|sts| kanidm.delete(&ctx, sts.as_ref()))
248        .collect::<TryJoinAll<_>>();
249
250    let sts_futures = match kanidm.is_updatable(&status) {
251        true => kanidm
252            .spec
253            .replica_groups
254            .iter()
255            .map(|rg| {
256                let sts = kanidm.create_statefulset(rg, &ctx)?;
257                Ok(kanidm.patch(&ctx, sts))
258            })
259            .collect::<Result<TryJoinAll<_>, _>>()?,
260        false => {
261            let note = match status.version.as_ref() {
262                Some(v) if v.compatibility_result == VersionCompatibilityResult::Incompatible => {
263                    format!(
264                        "Version change blocked: image version {} is not compatible with operator (uses Kanidm client v{}). Override with `.spec.disableUpgradeChecks: true` or use a compatible version.",
265                        v.image_tag,
266                        crate::version::KANIDM_CLIENT_VERSION
267                    )
268                }
269                _ => "Version change blocked: upgrade pre-check failed. Override with `.spec.disableUpgradeCheck: true` or update the resource to retry.".to_string(),
270            };
271            let _ignore_error = ctx
272                .kaniop_ctx
273                .recorder
274                .publish(
275                    &Event {
276                        type_: EventType::Warning,
277                        reason: "UpgradeBlocked".to_string(),
278                        note: Some(note),
279                        action: "ReconcileStatefulSet".to_string(),
280                        secondary: None,
281                    },
282                    &kanidm.object_ref(&()),
283                )
284                .await
285                .map_err(|e| {
286                    warn!(msg = "failed to publish KanidmError event", %e);
287                    Error::KubeError("failed to publish event".to_string(), Box::new(e))
288                });
289            try_join_all([].into_iter())
290        }
291    };
292    let service_future = kanidm.patch(&ctx, kanidm.create_service());
293
294    let deprecated_rg_svcs = {
295        let expected_rg_svcs_names = kanidm
296            .spec
297            .replica_groups
298            .iter()
299            .filter(|rg| rg.services.is_some())
300            .flat_map(|rg| (0..rg.replicas).map(|i| kanidm.replica_group_service_name(&rg.name, i)))
301            .collect::<Vec<_>>();
302        ctx.stores
303            .service_store
304            .state()
305            .into_iter()
306            .filter(|svc| {
307                let labels = svc.metadata.labels.as_ref();
308                svc.namespace() == kanidm.namespace()
309                    && !expected_rg_svcs_names.contains(&svc.name_any())
310                    && labels.is_some_and(|l| {
311                        l.contains_key(REPLICA_LABEL)
312                            && l.get(CLUSTER_LABEL) == Some(&kanidm.name_any())
313                    })
314            })
315            .collect::<Vec<_>>()
316    };
317    let rg_svcs_delete_futures = deprecated_rg_svcs
318        .iter()
319        .map(|svc| kanidm.delete(&ctx, svc.as_ref()))
320        .collect::<TryJoinAll<_>>();
321
322    let rg_services_futures = kanidm
323        .spec
324        .replica_groups
325        .iter()
326        .filter(|rg| rg.services.is_some())
327        .flat_map(|rg| {
328            (0..rg.replicas).map(|i| kanidm.patch(&ctx, kanidm.create_replica_group_service(rg, i)))
329        })
330        .collect::<TryJoinAll<_>>();
331
332    let deprecated_ingresses = {
333        let names = [
334            kanidm.spec.ingress.as_ref().map(|_| kanidm.name_any()),
335            kanidm.generate_region_ingress_name(),
336        ]
337        .into_iter()
338        .flatten()
339        .collect::<Vec<_>>();
340        ctx.stores
341            .ingress_store
342            .state()
343            .into_iter()
344            .filter(|ing| {
345                ing.namespace() == kanidm.namespace()
346                    && !names.contains(&ing.name_any())
347                    && ing.metadata.labels == Some(kanidm.generate_labels())
348            })
349            .collect::<Vec<_>>()
350    };
351    let ingress_delete_futures = deprecated_ingresses
352        .iter()
353        .map(|ing| kanidm.delete(&ctx, ing.as_ref()))
354        .collect::<TryJoinAll<_>>();
355
356    let ingress_futures = kanidm
357        .create_ingress()
358        .into_iter()
359        .chain(kanidm.create_region_ingress())
360        .map(|ingress| kanidm.patch(&ctx, ingress))
361        .collect::<TryJoinAll<_>>();
362
363    try_join!(
364        sts_delete_futures,
365        admin_secret_future,
366        replication_secret_futures,
367        sts_futures,
368        service_future,
369        rg_svcs_delete_futures,
370        rg_services_futures,
371        ingress_delete_futures,
372        ingress_futures
373    )?;
374    Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL))
375}
376
377async fn cleanup(kanidm: Arc<Kanidm>, ctx: Arc<Context>) -> Result<Action> {
378    debug!(msg = "cleanup");
379    ctx.kaniop_ctx.release_kanidm_clients(&kanidm).await;
380    Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL))
381}
382
383impl Kanidm {
384    // Convenience methods that handle context and operator name
385    pub async fn delete<K>(&self, ctx: &Context, resource: &K) -> Result<()>
386    where
387        K: Resource<Scope = NamespaceResourceScope>
388            + Serialize
389            + Clone
390            + std::fmt::Debug
391            + for<'de> Deserialize<'de>,
392        <K as kube::Resource>::DynamicType: Default,
393        <K as Resource>::Scope: std::marker::Sized,
394    {
395        self.kube_delete(
396            ctx.kaniop_ctx.client.clone(),
397            &ctx.kaniop_ctx.metrics,
398            resource,
399        )
400        .await
401    }
402
403    pub async fn patch<K>(&self, ctx: &Context, resource: K) -> Result<K>
404    where
405        K: Resource<Scope = NamespaceResourceScope>
406            + Serialize
407            + Clone
408            + std::fmt::Debug
409            + for<'de> Deserialize<'de>,
410        <K as kube::Resource>::DynamicType: Default,
411        <K as Resource>::Scope: std::marker::Sized,
412    {
413        self.kube_patch(
414            ctx.kaniop_ctx.client.clone(),
415            &ctx.kaniop_ctx.metrics,
416            resource,
417            KANIDM_OPERATOR_NAME,
418        )
419        .await
420    }
421
422    #[inline]
423    fn generate_resource_labels(&self) -> BTreeMap<String, String> {
424        LABELS
425            .clone()
426            .into_iter()
427            .chain([
428                (INSTANCE_LABEL.to_string(), self.name_any()),
429                (CLUSTER_LABEL.to_string(), self.name_any()),
430            ])
431            .collect()
432    }
433
434    #[inline]
435    fn generate_labels(&self) -> BTreeMap<String, String> {
436        self.generate_resource_labels()
437            .clone()
438            .into_iter()
439            .chain(self.labels().clone())
440            .collect()
441    }
442
443    #[inline]
444    fn get_tls_secret_name(&self) -> String {
445        format!("{}-tls", self.name_any())
446    }
447
448    #[inline]
449    fn get_namespace(&self) -> String {
450        // safe unwrap: Kanidm is namespaced scoped
451        self.namespace().unwrap()
452    }
453
454    #[inline]
455    fn is_replication_enabled(&self) -> bool {
456        // safe unwrap: at least one replica group is required
457        self.spec.replica_groups.len() > 1
458            || self.spec.replica_groups.first().unwrap().replicas > 1
459            || !self.spec.external_replication_nodes.is_empty()
460    }
461
462    #[inline]
463    fn is_updatable(&self, status: &KanidmStatus) -> bool {
464        status
465            .version
466            .as_ref()
467            .map(|v| {
468                if v.compatibility_result == VersionCompatibilityResult::Incompatible {
469                    return false;
470                }
471                let current_tag = get_image_tag(&self.spec.image).unwrap_or_default();
472                let versions = (parse_semver(&current_tag), parse_semver(&v.image_tag));
473                match v.upgrade_check_result {
474                    KanidmUpgradeCheckResult::Passed => {
475                        if let (Some((_, minor, _)), Some((_, v_minor, _))) = versions {
476                            minor <= v_minor + 1
477                        } else {
478                            true
479                        }
480                    }
481                    KanidmUpgradeCheckResult::Failed => {
482                        if let (Some((major, minor, patch)), Some((v_major, v_minor, v_patch))) =
483                            versions
484                        {
485                            major == v_major && minor == v_minor && patch >= v_patch
486                        } else {
487                            v.image_tag == current_tag
488                        }
489                    }
490                }
491            })
492            .unwrap_or(true)
493    }
494
495    async fn exec<I, T>(&self, ctx: Arc<Context>, pod_name: &str, command: I) -> Result<String>
496    where
497        I: IntoIterator<Item = T> + Debug,
498        T: Into<String>,
499    {
500        let namespace = &self.get_namespace();
501        trace!(
502            msg = "pod exec",
503            resource.name = &pod_name,
504            resource.namespace = &namespace,
505            ?command
506        );
507        let pod = Api::<Pod>::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
508        let attached = pod
509            .exec(pod_name, command, &AttachParams::default())
510            .await
511            .map_err(|e| {
512                Error::KubeError(
513                    format!("failed to exec pod {namespace}/{pod_name}"),
514                    Box::new(e),
515                )
516            })?;
517        get_output(attached).await
518    }
519
520    async fn exec_any<I, T>(&self, ctx: Arc<Context>, command: I) -> Result<String>
521    where
522        I: IntoIterator<Item = T> + Debug,
523        T: Into<String>,
524    {
525        // TODO: if replicas > 1 and replicas initialized, exec on pod available
526        // safe unwrap: at least one replica group is required
527        let sts_name = self.statefulset_name(&self.spec.replica_groups.first().unwrap().name);
528        let pod_name = format!("{sts_name}-0");
529        self.exec(ctx, &pod_name, command).await
530    }
531}
532
533#[cfg(test)]
534mod test {
535    use super::statefulset::StatefulSetExt;
536    use super::{Kanidm, reconcile_kanidm};
537
538    use crate::controller::State;
539    use crate::kanidm::controller::context::{Context, Stores};
540    use crate::kanidm::crd::KanidmStatus;
541
542    use kaniop_k8s_util::error::Result;
543
544    use std::sync::Arc;
545
546    use http::{Request, Response};
547    use k8s_openapi::api::apps::v1::StatefulSet;
548    use k8s_openapi::api::core::v1::Service;
549    use k8s_openapi::api::networking::v1::Ingress;
550    use kube::runtime::reflector::store::Writer;
551    use kube::{Client, Resource, ResourceExt, client::Body};
552    use opentelemetry::metrics::MeterProvider;
553    use serde_json::json;
554
555    impl Kanidm {
556        /// A normal test kanidm with a given status
557        pub fn test() -> Self {
558            let mut e = Kanidm::new(
559                "test",
560                serde_json::from_value(json!({
561                    "domain": "idm.example.com",
562                    "replicaGroups": [
563                        {
564                            "name": "default",
565                            "replicas": 1
566                        }
567                    ]
568                }))
569                .unwrap(),
570            );
571            e.meta_mut().namespace = Some("default".into());
572            // Pre-populate finalizer so reconcile callback runs immediately
573            // (skips the "add finalizer + wait for next reconcile" step)
574            e.meta_mut().finalizers = Some(vec![super::KANIDM_FINALIZER.to_string()]);
575            e
576        }
577
578        pub fn with_ingress(mut self) -> Self {
579            self.spec.ingress = Some(serde_json::from_value(json!({})).unwrap());
580            self
581        }
582
583        /// Modify kanidm replicas
584        pub fn with_replicas(mut self, replicas: i32) -> Self {
585            self.spec.replica_groups[0].replicas = replicas;
586            self
587        }
588
589        /// Modify kanidm to set a deletion timestamp
590        pub fn needs_delete(mut self) -> Self {
591            use k8s_openapi::apimachinery::pkg::apis::meta::v1::Time;
592            use k8s_openapi::jiff::Timestamp;
593            let now = Timestamp::from_second(1491138632).unwrap(); // 2017-04-02 12:50:32 UTC
594            self.meta_mut().deletion_timestamp = Some(Time(now));
595            self
596        }
597
598        /// Modify a kanidm to have an expected status
599        pub fn with_status(mut self, status: KanidmStatus) -> Self {
600            self.status = Some(status);
601            self
602        }
603    }
604
605    // We wrap tower_test::mock::Handle
606    type ApiServerHandle = tower_test::mock::Handle<Request<Body>, Response<Body>>;
607    pub struct ApiServerVerifier(ApiServerHandle);
608
609    /// Scenarios we test for in ApiServerVerifier
610    pub enum Scenario {
611        Create(Kanidm),
612        CreateWithTwoReplicas(Kanidm),
613        CreateWithIngress(Kanidm),
614        CreateWithIngressWithTwoReplicas(Kanidm),
615    }
616
617    pub async fn timeout_after_1s(handle: tokio::task::JoinHandle<()>) {
618        tokio::time::timeout(std::time::Duration::from_secs(1), handle)
619            .await
620            .expect("timeout on mock apiserver")
621            .expect("scenario succeeded")
622    }
623
624    impl ApiServerVerifier {
625        /// Tests only get to run specific scenarios that has matching handlers
626        ///
627        /// This setup makes it easy to handle multiple requests by chaining handlers together.
628        ///
629        /// NB: If the controller is making more calls than we are handling in the scenario,
630        /// you then typically see a `KubeError(Service(Closed(())))` from the reconciler.
631        ///
632        /// You should await the `JoinHandle` (with a timeout) from this function to ensure that the
633        /// scenario runs to completion (i.e. all expected calls were responded to),
634        /// using the timeout to catch missing api calls to Kubernetes.
635        pub fn run(self, scenario: Scenario) -> tokio::task::JoinHandle<()> {
636            tokio::spawn(async move {
637                // moving self => one scenario per test
638                match scenario {
639                    Scenario::Create(kanidm) => {
640                        self.handle_kanidm_status_patch(kanidm.clone())
641                            .await
642                            .unwrap()
643                            .handle_statefulset_patch(kanidm.clone())
644                            .await
645                            .unwrap()
646                            .handle_service_patch(kanidm.clone())
647                            .await
648                    }
649                    Scenario::CreateWithTwoReplicas(kanidm) => {
650                        self.handle_kanidm_status_patch(kanidm.clone())
651                            .await
652                            .unwrap()
653                            .handle_statefulset_patch(kanidm.clone())
654                            .await
655                            .unwrap()
656                            .handle_service_patch(kanidm.clone())
657                            .await
658                    }
659                    Scenario::CreateWithIngress(kanidm) => {
660                        self.handle_kanidm_status_patch(kanidm.clone())
661                            .await
662                            .unwrap()
663                            .handle_statefulset_patch(kanidm.clone())
664                            .await
665                            .unwrap()
666                            .handle_service_patch(kanidm.clone())
667                            .await
668                            .unwrap()
669                            .handle_ingress_patch(kanidm.clone())
670                            .await
671                    }
672                    Scenario::CreateWithIngressWithTwoReplicas(kanidm) => {
673                        self.handle_kanidm_status_patch(kanidm.clone())
674                            .await
675                            .unwrap()
676                            .handle_statefulset_patch(kanidm.clone())
677                            .await
678                            .unwrap()
679                            .handle_service_patch(kanidm.clone())
680                            .await
681                            .unwrap()
682                            .handle_ingress_patch(kanidm.clone())
683                            .await
684                    }
685                }
686                .expect("scenario completed without errors");
687            })
688        }
689
690        async fn handle_kanidm_status_patch(mut self, kanidm: Kanidm) -> Result<Self> {
691            let (request, send) = self.0.next_request().await.expect("service not called");
692            assert_eq!(request.method(), http::Method::PATCH);
693            assert_eq!(
694                request.uri().to_string(),
695                format!(
696                    "/apis/kaniop.rs/v1beta1/namespaces/default/kanidms/{}/status?&force=true&fieldManager=kanidms.kaniop.rs",
697                    kanidm.name_any()
698                )
699            );
700
701            let req_body = request.into_body().collect_bytes().await.unwrap();
702            let json: serde_json::Value =
703                serde_json::from_slice(&req_body).expect("patch object is json");
704            let status: KanidmStatus = serde_json::from_value(json.get("status").unwrap().clone())
705                .expect("valid kanidm status");
706            let mut kanidm = Kanidm::test();
707            kanidm.status = Some(status.clone());
708            let response = serde_json::to_vec(&kanidm).unwrap();
709            // pass through kanidm "patch accepted"
710            send.send_response(Response::builder().body(Body::from(response)).unwrap());
711            Ok(self)
712        }
713
714        async fn handle_statefulset_patch(mut self, kanidm: Kanidm) -> Result<Self> {
715            for rg in kanidm.spec.replica_groups.iter() {
716                let (request, send) = self.0.next_request().await.expect("service not called");
717                assert_eq!(request.method(), http::Method::PATCH);
718                assert_eq!(
719                    request.uri().to_string(),
720                    format!(
721                        "/apis/apps/v1/namespaces/default/statefulsets/{}?&force=true&fieldManager=kanidms.kaniop.rs",
722                        kanidm.statefulset_name(&rg.name)
723                    )
724                );
725                let req_body = request.into_body().collect_bytes().await.unwrap();
726                let json: serde_json::Value =
727                    serde_json::from_slice(&req_body).expect("patch object is json");
728                let statefulset: StatefulSet =
729                    serde_json::from_value(json).expect("valid statefulset");
730                assert_eq!(
731                    statefulset.clone().spec.unwrap().replicas.unwrap(),
732                    rg.replicas
733                );
734                let response = serde_json::to_vec(&statefulset).unwrap();
735                // pass through kanidm "patch accepted"
736                send.send_response(Response::builder().body(Body::from(response)).unwrap());
737            }
738
739            Ok(self)
740        }
741
742        async fn handle_service_patch(mut self, kanidm: Kanidm) -> Result<Self> {
743            let (request, send) = self.0.next_request().await.expect("service not called");
744            assert_eq!(request.method(), http::Method::PATCH);
745            assert_eq!(
746                request.uri().to_string(),
747                format!(
748                    "/api/v1/namespaces/default/services/{}?&force=true&fieldManager=kanidms.kaniop.rs",
749                    kanidm.name_any()
750                )
751            );
752
753            let req_body = request.into_body().collect_bytes().await.unwrap();
754            let json: serde_json::Value =
755                serde_json::from_slice(&req_body).expect("patch object is json");
756            let service: Service = serde_json::from_value(json).expect("valid service");
757            let response = serde_json::to_vec(&service).unwrap();
758            // pass through kanidm "patch accepted"
759            send.send_response(Response::builder().body(Body::from(response)).unwrap());
760            Ok(self)
761        }
762
763        async fn handle_ingress_patch(mut self, kanidm: Kanidm) -> Result<Self> {
764            let (request, send) = self.0.next_request().await.expect("service not called");
765            assert_eq!(request.method(), http::Method::PATCH);
766            assert_eq!(
767                request.uri().to_string(),
768                format!(
769                    "/apis/networking.k8s.io/v1/namespaces/default/ingresses/{}?&force=true&fieldManager=kanidms.kaniop.rs",
770                    kanidm.name_any()
771                )
772            );
773
774            let req_body = request.into_body().collect_bytes().await.unwrap();
775            let json: serde_json::Value =
776                serde_json::from_slice(&req_body).expect("patch object is json");
777            let ingress: Ingress = serde_json::from_value(json).expect("valid service");
778            let response = serde_json::to_vec(&ingress).unwrap();
779            // pass through kanidm "patch accepted"
780            send.send_response(Response::builder().body(Body::from(response)).unwrap());
781            Ok(self)
782        }
783    }
784
785    pub fn get_test_context() -> (Arc<Context>, ApiServerVerifier) {
786        let (mock_service, handle) = tower_test::mock::pair::<Request<Body>, Response<Body>>();
787        let mock_client = Client::new(mock_service, "default");
788        let stores = Stores {
789            stateful_set_store: Writer::default().as_reader(),
790            service_store: Writer::default().as_reader(),
791            ingress_store: Writer::default().as_reader(),
792            secret_store: Writer::default().as_reader(),
793        };
794        let controller_id = "test";
795
796        // Create a test meter for metrics
797        let provider = opentelemetry_sdk::metrics::SdkMeterProvider::builder().build();
798        let meter = provider.meter("test");
799        let metrics = crate::metrics::Metrics::new(&meter, &[controller_id]);
800
801        let state = State::new(
802            metrics,
803            Writer::default().as_reader(),
804            Writer::default().as_reader(),
805            None,
806        );
807        let ctx = Arc::new(Context::new(
808            state.to_context(mock_client, controller_id),
809            stores,
810        ));
811        (ctx, ApiServerVerifier(handle))
812    }
813
814    #[tokio::test]
815    async fn kanidm_create() {
816        let (testctx, fakeserver) = get_test_context();
817        let kanidm = Kanidm::test();
818        let mocksrv = fakeserver.run(Scenario::Create(kanidm.clone()));
819        reconcile_kanidm(Arc::new(kanidm), testctx)
820            .await
821            .expect("reconciler");
822        timeout_after_1s(mocksrv).await;
823    }
824
825    #[tokio::test]
826    async fn kanidm_create_with_two_replicas() {
827        let (testctx, fakeserver) = get_test_context();
828        let kanidm = Kanidm::test().with_replicas(2);
829        let mocksrv = fakeserver.run(Scenario::CreateWithTwoReplicas(kanidm.clone()));
830        reconcile_kanidm(Arc::new(kanidm), testctx)
831            .await
832            .expect("reconciler");
833        timeout_after_1s(mocksrv).await;
834    }
835
836    #[tokio::test]
837    async fn kanidm_create_with_ingress() {
838        let (testctx, fakeserver) = get_test_context();
839        let kanidm = Kanidm::test().with_ingress();
840        let mocksrv = fakeserver.run(Scenario::CreateWithIngress(kanidm.clone()));
841        reconcile_kanidm(Arc::new(kanidm), testctx)
842            .await
843            .expect("reconciler");
844        timeout_after_1s(mocksrv).await;
845    }
846
847    #[tokio::test]
848    async fn kanidm_create_with_ingress_with_two_replicas() {
849        let (testctx, fakeserver) = get_test_context();
850        let kanidm = Kanidm::test().with_ingress().with_replicas(2);
851        let mocksrv = fakeserver.run(Scenario::CreateWithIngressWithTwoReplicas(kanidm.clone()));
852        reconcile_kanidm(Arc::new(kanidm), testctx)
853            .await
854            .expect("reconciler");
855        timeout_after_1s(mocksrv).await;
856    }
857}