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| match v.upgrade_check_result {
449                KanidmUpgradeCheckResult::Passed => true,
450                KanidmUpgradeCheckResult::Failed => {
451                    let current_tag = get_image_tag(&self.spec.image).unwrap_or_default();
452                    if let (Some((major, minor, patch)), Some((v_major, v_minor, v_patch))) =
453                        (parse_semver(&current_tag), parse_semver(&v.image_tag))
454                    {
455                        major == v_major && minor == v_minor && patch >= v_patch
456                    } else {
457                        v.image_tag == current_tag
458                    }
459                }
460            })
461            .unwrap_or(true)
462    }
463
464    async fn exec<I, T>(&self, ctx: Arc<Context>, pod_name: &str, command: I) -> Result<String>
465    where
466        I: IntoIterator<Item = T> + Debug,
467        T: Into<String>,
468    {
469        let namespace = &self.get_namespace();
470        trace!(
471            msg = "pod exec",
472            resource.name = &pod_name,
473            resource.namespace = &namespace,
474            ?command
475        );
476        let pod = Api::<Pod>::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
477        let attached = pod
478            .exec(pod_name, command, &AttachParams::default())
479            .await
480            .map_err(|e| {
481                Error::KubeError(
482                    format!("failed to exec pod {namespace}/{pod_name}"),
483                    Box::new(e),
484                )
485            })?;
486        get_output(attached).await
487    }
488
489    async fn exec_any<I, T>(&self, ctx: Arc<Context>, command: I) -> Result<String>
490    where
491        I: IntoIterator<Item = T> + Debug,
492        T: Into<String>,
493    {
494        // TODO: if replicas > 1 and replicas initialized, exec on pod available
495        // safe unwrap: at least one replica group is required
496        let sts_name = self.statefulset_name(&self.spec.replica_groups.first().unwrap().name);
497        let pod_name = format!("{sts_name}-0");
498        self.exec(ctx, &pod_name, command).await
499    }
500}
501
502#[cfg(test)]
503mod test {
504    use super::statefulset::StatefulSetExt;
505    use super::{Kanidm, reconcile_kanidm};
506
507    use crate::controller::State;
508    use crate::kanidm::controller::context::{Context, Stores};
509    use crate::kanidm::crd::KanidmStatus;
510
511    use kaniop_k8s_util::error::Result;
512
513    use std::sync::Arc;
514
515    use http::{Request, Response};
516    use k8s_openapi::api::apps::v1::StatefulSet;
517    use k8s_openapi::api::core::v1::Service;
518    use k8s_openapi::api::networking::v1::Ingress;
519    use kube::runtime::reflector::store::Writer;
520    use kube::{Client, Resource, ResourceExt, client::Body};
521    use opentelemetry::metrics::MeterProvider;
522    use serde_json::json;
523
524    impl Kanidm {
525        /// A normal test kanidm with a given status
526        pub fn test() -> Self {
527            let mut e = Kanidm::new(
528                "test",
529                serde_json::from_value(json!({
530                    "domain": "idm.example.com",
531                    "replicaGroups": [
532                        {
533                            "name": "default",
534                            "replicas": 1
535                        }
536                    ]
537                }))
538                .unwrap(),
539            );
540            e.meta_mut().namespace = Some("default".into());
541            // Pre-populate finalizer so reconcile callback runs immediately
542            // (skips the "add finalizer + wait for next reconcile" step)
543            e.meta_mut().finalizers = Some(vec![super::KANIDM_FINALIZER.to_string()]);
544            e
545        }
546
547        pub fn with_ingress(mut self) -> Self {
548            self.spec.ingress = Some(serde_json::from_value(json!({})).unwrap());
549            self
550        }
551
552        /// Modify kanidm replicas
553        pub fn with_replicas(mut self, replicas: i32) -> Self {
554            self.spec.replica_groups[0].replicas = replicas;
555            self
556        }
557
558        /// Modify kanidm to set a deletion timestamp
559        pub fn needs_delete(mut self) -> Self {
560            use chrono::prelude::{DateTime, TimeZone, Utc};
561            let now: DateTime<Utc> = Utc.with_ymd_and_hms(2017, 4, 2, 12, 50, 32).unwrap();
562            use k8s_openapi::apimachinery::pkg::apis::meta::v1::Time;
563            self.meta_mut().deletion_timestamp = Some(Time(now));
564            self
565        }
566
567        /// Modify a kanidm to have an expected status
568        pub fn with_status(mut self, status: KanidmStatus) -> Self {
569            self.status = Some(status);
570            self
571        }
572    }
573
574    // We wrap tower_test::mock::Handle
575    type ApiServerHandle = tower_test::mock::Handle<Request<Body>, Response<Body>>;
576    pub struct ApiServerVerifier(ApiServerHandle);
577
578    /// Scenarios we test for in ApiServerVerifier
579    pub enum Scenario {
580        Create(Kanidm),
581        CreateWithTwoReplicas(Kanidm),
582        CreateWithIngress(Kanidm),
583        CreateWithIngressWithTwoReplicas(Kanidm),
584    }
585
586    pub async fn timeout_after_1s(handle: tokio::task::JoinHandle<()>) {
587        tokio::time::timeout(std::time::Duration::from_secs(1), handle)
588            .await
589            .expect("timeout on mock apiserver")
590            .expect("scenario succeeded")
591    }
592
593    impl ApiServerVerifier {
594        /// Tests only get to run specific scenarios that has matching handlers
595        ///
596        /// This setup makes it easy to handle multiple requests by chaining handlers together.
597        ///
598        /// NB: If the controller is making more calls than we are handling in the scenario,
599        /// you then typically see a `KubeError(Service(Closed(())))` from the reconciler.
600        ///
601        /// You should await the `JoinHandle` (with a timeout) from this function to ensure that the
602        /// scenario runs to completion (i.e. all expected calls were responded to),
603        /// using the timeout to catch missing api calls to Kubernetes.
604        pub fn run(self, scenario: Scenario) -> tokio::task::JoinHandle<()> {
605            tokio::spawn(async move {
606                // moving self => one scenario per test
607                match scenario {
608                    Scenario::Create(kanidm) => {
609                        self.handle_kanidm_status_patch(kanidm.clone())
610                            .await
611                            .unwrap()
612                            .handle_statefulset_patch(kanidm.clone())
613                            .await
614                            .unwrap()
615                            .handle_service_patch(kanidm.clone())
616                            .await
617                    }
618                    Scenario::CreateWithTwoReplicas(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::CreateWithIngress(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                            .unwrap()
638                            .handle_ingress_patch(kanidm.clone())
639                            .await
640                    }
641                    Scenario::CreateWithIngressWithTwoReplicas(kanidm) => {
642                        self.handle_kanidm_status_patch(kanidm.clone())
643                            .await
644                            .unwrap()
645                            .handle_statefulset_patch(kanidm.clone())
646                            .await
647                            .unwrap()
648                            .handle_service_patch(kanidm.clone())
649                            .await
650                            .unwrap()
651                            .handle_ingress_patch(kanidm.clone())
652                            .await
653                    }
654                }
655                .expect("scenario completed without errors");
656            })
657        }
658
659        async fn handle_kanidm_status_patch(mut self, kanidm: Kanidm) -> Result<Self> {
660            let (request, send) = self.0.next_request().await.expect("service not called");
661            assert_eq!(request.method(), http::Method::PATCH);
662            assert_eq!(
663                request.uri().to_string(),
664                format!(
665                    "/apis/kaniop.rs/v1beta1/namespaces/default/kanidms/{}/status?&force=true&fieldManager=kanidms.kaniop.rs",
666                    kanidm.name_any()
667                )
668            );
669
670            let req_body = request.into_body().collect_bytes().await.unwrap();
671            let json: serde_json::Value =
672                serde_json::from_slice(&req_body).expect("patch object is json");
673            let status: KanidmStatus = serde_json::from_value(json.get("status").unwrap().clone())
674                .expect("valid kanidm status");
675            let mut kanidm = Kanidm::test();
676            kanidm.status = Some(status.clone());
677            let response = serde_json::to_vec(&kanidm).unwrap();
678            // pass through kanidm "patch accepted"
679            send.send_response(Response::builder().body(Body::from(response)).unwrap());
680            Ok(self)
681        }
682
683        async fn handle_statefulset_patch(mut self, kanidm: Kanidm) -> Result<Self> {
684            for rg in kanidm.spec.replica_groups.iter() {
685                let (request, send) = self.0.next_request().await.expect("service not called");
686                assert_eq!(request.method(), http::Method::PATCH);
687                assert_eq!(
688                    request.uri().to_string(),
689                    format!(
690                        "/apis/apps/v1/namespaces/default/statefulsets/{}?&force=true&fieldManager=kanidms.kaniop.rs",
691                        kanidm.statefulset_name(&rg.name)
692                    )
693                );
694                let req_body = request.into_body().collect_bytes().await.unwrap();
695                let json: serde_json::Value =
696                    serde_json::from_slice(&req_body).expect("patch object is json");
697                let statefulset: StatefulSet =
698                    serde_json::from_value(json).expect("valid statefulset");
699                assert_eq!(
700                    statefulset.clone().spec.unwrap().replicas.unwrap(),
701                    rg.replicas
702                );
703                let response = serde_json::to_vec(&statefulset).unwrap();
704                // pass through kanidm "patch accepted"
705                send.send_response(Response::builder().body(Body::from(response)).unwrap());
706            }
707
708            Ok(self)
709        }
710
711        async fn handle_service_patch(mut self, kanidm: Kanidm) -> Result<Self> {
712            let (request, send) = self.0.next_request().await.expect("service not called");
713            assert_eq!(request.method(), http::Method::PATCH);
714            assert_eq!(
715                request.uri().to_string(),
716                format!(
717                    "/api/v1/namespaces/default/services/{}?&force=true&fieldManager=kanidms.kaniop.rs",
718                    kanidm.name_any()
719                )
720            );
721
722            let req_body = request.into_body().collect_bytes().await.unwrap();
723            let json: serde_json::Value =
724                serde_json::from_slice(&req_body).expect("patch object is json");
725            let service: Service = serde_json::from_value(json).expect("valid service");
726            let response = serde_json::to_vec(&service).unwrap();
727            // pass through kanidm "patch accepted"
728            send.send_response(Response::builder().body(Body::from(response)).unwrap());
729            Ok(self)
730        }
731
732        async fn handle_ingress_patch(mut self, kanidm: Kanidm) -> Result<Self> {
733            let (request, send) = self.0.next_request().await.expect("service not called");
734            assert_eq!(request.method(), http::Method::PATCH);
735            assert_eq!(
736                request.uri().to_string(),
737                format!(
738                    "/apis/networking.k8s.io/v1/namespaces/default/ingresses/{}?&force=true&fieldManager=kanidms.kaniop.rs",
739                    kanidm.name_any()
740                )
741            );
742
743            let req_body = request.into_body().collect_bytes().await.unwrap();
744            let json: serde_json::Value =
745                serde_json::from_slice(&req_body).expect("patch object is json");
746            let ingress: Ingress = serde_json::from_value(json).expect("valid service");
747            let response = serde_json::to_vec(&ingress).unwrap();
748            // pass through kanidm "patch accepted"
749            send.send_response(Response::builder().body(Body::from(response)).unwrap());
750            Ok(self)
751        }
752    }
753
754    pub fn get_test_context() -> (Arc<Context>, ApiServerVerifier) {
755        let (mock_service, handle) = tower_test::mock::pair::<Request<Body>, Response<Body>>();
756        let mock_client = Client::new(mock_service, "default");
757        let stores = Stores {
758            stateful_set_store: Writer::default().as_reader(),
759            service_store: Writer::default().as_reader(),
760            ingress_store: Writer::default().as_reader(),
761            secret_store: Writer::default().as_reader(),
762        };
763        let controller_id = "test";
764
765        // Create a test meter for metrics
766        let provider = opentelemetry_sdk::metrics::SdkMeterProvider::builder().build();
767        let meter = provider.meter("test");
768        let metrics = crate::metrics::Metrics::new(&meter, &[controller_id]);
769
770        let state = State::new(
771            metrics,
772            Writer::default().as_reader(),
773            Writer::default().as_reader(),
774            None,
775        );
776        let ctx = Arc::new(Context::new(
777            state.to_context(mock_client, controller_id),
778            stores,
779        ));
780        (ctx, ApiServerVerifier(handle))
781    }
782
783    #[tokio::test]
784    async fn kanidm_create() {
785        let (testctx, fakeserver) = get_test_context();
786        let kanidm = Kanidm::test();
787        let mocksrv = fakeserver.run(Scenario::Create(kanidm.clone()));
788        reconcile_kanidm(Arc::new(kanidm), testctx)
789            .await
790            .expect("reconciler");
791        timeout_after_1s(mocksrv).await;
792    }
793
794    #[tokio::test]
795    async fn kanidm_create_with_two_replicas() {
796        let (testctx, fakeserver) = get_test_context();
797        let kanidm = Kanidm::test().with_replicas(2);
798        let mocksrv = fakeserver.run(Scenario::CreateWithTwoReplicas(kanidm.clone()));
799        reconcile_kanidm(Arc::new(kanidm), testctx)
800            .await
801            .expect("reconciler");
802        timeout_after_1s(mocksrv).await;
803    }
804
805    #[tokio::test]
806    async fn kanidm_create_with_ingress() {
807        let (testctx, fakeserver) = get_test_context();
808        let kanidm = Kanidm::test().with_ingress();
809        let mocksrv = fakeserver.run(Scenario::CreateWithIngress(kanidm.clone()));
810        reconcile_kanidm(Arc::new(kanidm), testctx)
811            .await
812            .expect("reconciler");
813        timeout_after_1s(mocksrv).await;
814    }
815
816    #[tokio::test]
817    async fn kanidm_create_with_ingress_with_two_replicas() {
818        let (testctx, fakeserver) = get_test_context();
819        let kanidm = Kanidm::test().with_ingress().with_replicas(2);
820        let mocksrv = fakeserver.run(Scenario::CreateWithIngressWithTwoReplicas(kanidm.clone()));
821        reconcile_kanidm(Arc::new(kanidm), testctx)
822            .await
823            .expect("reconciler");
824        timeout_after_1s(mocksrv).await;
825    }
826}