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)
310                .map(|i| kanidm.patch(&ctx, kanidm.create_replica_group_service(&rg.name, i)))
311        })
312        .collect::<TryJoinAll<_>>();
313
314    let deprecated_ingresses = {
315        let names = [
316            kanidm.spec.ingress.as_ref().map(|_| kanidm.name_any()),
317            kanidm.generate_region_ingress_name(),
318        ]
319        .into_iter()
320        .flatten()
321        .collect::<Vec<_>>();
322        ctx.stores
323            .ingress_store
324            .state()
325            .into_iter()
326            .filter(|ing| {
327                ing.namespace() == kanidm.namespace()
328                    && !names.contains(&ing.name_any())
329                    && ing.metadata.labels == Some(kanidm.generate_labels())
330            })
331            .collect::<Vec<_>>()
332    };
333    let ingress_delete_futures = deprecated_ingresses
334        .iter()
335        .map(|ing| kanidm.delete(&ctx, ing.as_ref()))
336        .collect::<TryJoinAll<_>>();
337
338    let ingress_futures = kanidm
339        .create_ingress()
340        .into_iter()
341        .chain(kanidm.create_region_ingress())
342        .map(|ingress| kanidm.patch(&ctx, ingress))
343        .collect::<TryJoinAll<_>>();
344
345    try_join!(
346        sts_delete_futures,
347        admin_secret_future,
348        replication_secret_futures,
349        sts_futures,
350        service_future,
351        rg_svcs_delete_futures,
352        rg_services_futures,
353        ingress_delete_futures,
354        ingress_futures
355    )?;
356    Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL))
357}
358
359async fn cleanup(kanidm: Arc<Kanidm>, ctx: Arc<Context>) -> Result<Action> {
360    debug!(msg = "cleanup");
361    ctx.kaniop_ctx.release_kanidm_clients(&kanidm).await;
362    Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL))
363}
364
365impl Kanidm {
366    // Convenience methods that handle context and operator name
367    pub async fn delete<K>(&self, ctx: &Context, resource: &K) -> Result<()>
368    where
369        K: Resource<Scope = NamespaceResourceScope>
370            + Serialize
371            + Clone
372            + std::fmt::Debug
373            + for<'de> Deserialize<'de>,
374        <K as kube::Resource>::DynamicType: Default,
375        <K as Resource>::Scope: std::marker::Sized,
376    {
377        self.kube_delete(
378            ctx.kaniop_ctx.client.clone(),
379            &ctx.kaniop_ctx.metrics,
380            resource,
381        )
382        .await
383    }
384
385    pub async fn patch<K>(&self, ctx: &Context, resource: K) -> Result<K>
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_patch(
396            ctx.kaniop_ctx.client.clone(),
397            &ctx.kaniop_ctx.metrics,
398            resource,
399            KANIDM_OPERATOR_NAME,
400        )
401        .await
402    }
403
404    #[inline]
405    fn generate_resource_labels(&self) -> BTreeMap<String, String> {
406        LABELS
407            .clone()
408            .into_iter()
409            .chain([
410                (INSTANCE_LABEL.to_string(), self.name_any()),
411                (CLUSTER_LABEL.to_string(), self.name_any()),
412            ])
413            .collect()
414    }
415
416    #[inline]
417    fn generate_labels(&self) -> BTreeMap<String, String> {
418        self.generate_resource_labels()
419            .clone()
420            .into_iter()
421            .chain(self.labels().clone())
422            .collect()
423    }
424
425    #[inline]
426    fn get_tls_secret_name(&self) -> String {
427        format!("{}-tls", self.name_any())
428    }
429
430    #[inline]
431    fn get_namespace(&self) -> String {
432        // safe unwrap: Kanidm is namespaced scoped
433        self.namespace().unwrap()
434    }
435
436    #[inline]
437    fn is_replication_enabled(&self) -> bool {
438        // safe unwrap: at least one replica group is required
439        self.spec.replica_groups.len() > 1
440            || self.spec.replica_groups.first().unwrap().replicas > 1
441            || !self.spec.external_replication_nodes.is_empty()
442    }
443
444    #[inline]
445    fn is_updatable(&self, status: &KanidmStatus) -> bool {
446        status
447            .version
448            .as_ref()
449            .map(|v| match v.upgrade_check_result {
450                KanidmUpgradeCheckResult::Passed => true,
451                KanidmUpgradeCheckResult::Failed => {
452                    let current_tag = get_image_tag(&self.spec.image).unwrap_or_default();
453                    if let (Some((major, minor, patch)), Some((v_major, v_minor, v_patch))) =
454                        (parse_semver(&current_tag), parse_semver(&v.image_tag))
455                    {
456                        major == v_major && minor == v_minor && patch >= v_patch
457                    } else {
458                        v.image_tag == current_tag
459                    }
460                }
461            })
462            .unwrap_or(true)
463    }
464
465    async fn exec<I, T>(&self, ctx: Arc<Context>, pod_name: &str, command: I) -> Result<String>
466    where
467        I: IntoIterator<Item = T> + Debug,
468        T: Into<String>,
469    {
470        let namespace = &self.get_namespace();
471        trace!(
472            msg = "pod exec",
473            resource.name = &pod_name,
474            resource.namespace = &namespace,
475            ?command
476        );
477        let pod = Api::<Pod>::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
478        let attached = pod
479            .exec(pod_name, command, &AttachParams::default())
480            .await
481            .map_err(|e| {
482                Error::KubeError(
483                    format!("failed to exec pod {namespace}/{pod_name}"),
484                    Box::new(e),
485                )
486            })?;
487        get_output(attached).await
488    }
489
490    async fn exec_any<I, T>(&self, ctx: Arc<Context>, command: I) -> Result<String>
491    where
492        I: IntoIterator<Item = T> + Debug,
493        T: Into<String>,
494    {
495        // TODO: if replicas > 1 and replicas initialized, exec on pod available
496        // safe unwrap: at least one replica group is required
497        let sts_name = self.statefulset_name(&self.spec.replica_groups.first().unwrap().name);
498        let pod_name = format!("{sts_name}-0");
499        self.exec(ctx, &pod_name, command).await
500    }
501}
502
503#[cfg(test)]
504mod test {
505    use super::statefulset::StatefulSetExt;
506    use super::{Kanidm, reconcile_kanidm};
507
508    use crate::controller::State;
509    use crate::kanidm::controller::context::{Context, Stores};
510    use crate::kanidm::crd::KanidmStatus;
511
512    use kaniop_k8s_util::error::Result;
513
514    use std::sync::Arc;
515
516    use http::{Request, Response};
517    use k8s_openapi::api::apps::v1::StatefulSet;
518    use k8s_openapi::api::core::v1::Service;
519    use k8s_openapi::api::networking::v1::Ingress;
520    use kube::runtime::reflector::store::Writer;
521    use kube::{Client, Resource, ResourceExt, client::Body};
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        let state = State::new(
765            Default::default(),
766            &[controller_id],
767            Writer::default().as_reader(),
768            Writer::default().as_reader(),
769        );
770        let ctx = Arc::new(Context::new(
771            state.to_context(mock_client, controller_id),
772            stores,
773        ));
774        (ctx, ApiServerVerifier(handle))
775    }
776
777    #[tokio::test]
778    async fn kanidm_create() {
779        let (testctx, fakeserver) = get_test_context();
780        let kanidm = Kanidm::test();
781        let mocksrv = fakeserver.run(Scenario::Create(kanidm.clone()));
782        reconcile_kanidm(Arc::new(kanidm), testctx)
783            .await
784            .expect("reconciler");
785        timeout_after_1s(mocksrv).await;
786    }
787
788    #[tokio::test]
789    async fn kanidm_create_with_two_replicas() {
790        let (testctx, fakeserver) = get_test_context();
791        let kanidm = Kanidm::test().with_replicas(2);
792        let mocksrv = fakeserver.run(Scenario::CreateWithTwoReplicas(kanidm.clone()));
793        reconcile_kanidm(Arc::new(kanidm), testctx)
794            .await
795            .expect("reconciler");
796        timeout_after_1s(mocksrv).await;
797    }
798
799    #[tokio::test]
800    async fn kanidm_create_with_ingress() {
801        let (testctx, fakeserver) = get_test_context();
802        let kanidm = Kanidm::test().with_ingress();
803        let mocksrv = fakeserver.run(Scenario::CreateWithIngress(kanidm.clone()));
804        reconcile_kanidm(Arc::new(kanidm), testctx)
805            .await
806            .expect("reconciler");
807        timeout_after_1s(mocksrv).await;
808    }
809
810    #[tokio::test]
811    async fn kanidm_create_with_ingress_with_two_replicas() {
812        let (testctx, fakeserver) = get_test_context();
813        let kanidm = Kanidm::test().with_ingress().with_replicas(2);
814        let mocksrv = fakeserver.run(Scenario::CreateWithIngressWithTwoReplicas(kanidm.clone()));
815        reconcile_kanidm(Arc::new(kanidm), testctx)
816            .await
817            .expect("reconciler");
818        timeout_after_1s(mocksrv).await;
819    }
820}