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