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 serde_json::json;
522
523    impl Kanidm {
524        /// A normal test kanidm with a given status
525        pub fn test() -> Self {
526            let mut e = Kanidm::new(
527                "test",
528                serde_json::from_value(json!({
529                    "domain": "idm.example.com",
530                    "replicaGroups": [
531                        {
532                            "name": "default",
533                            "replicas": 1
534                        }
535                    ]
536                }))
537                .unwrap(),
538            );
539            e.meta_mut().namespace = Some("default".into());
540            // Pre-populate finalizer so reconcile callback runs immediately
541            // (skips the "add finalizer + wait for next reconcile" step)
542            e.meta_mut().finalizers = Some(vec![super::KANIDM_FINALIZER.to_string()]);
543            e
544        }
545
546        pub fn with_ingress(mut self) -> Self {
547            self.spec.ingress = Some(serde_json::from_value(json!({})).unwrap());
548            self
549        }
550
551        /// Modify kanidm replicas
552        pub fn with_replicas(mut self, replicas: i32) -> Self {
553            self.spec.replica_groups[0].replicas = replicas;
554            self
555        }
556
557        /// Modify kanidm to set a deletion timestamp
558        pub fn needs_delete(mut self) -> Self {
559            use chrono::prelude::{DateTime, TimeZone, Utc};
560            let now: DateTime<Utc> = Utc.with_ymd_and_hms(2017, 4, 2, 12, 50, 32).unwrap();
561            use k8s_openapi::apimachinery::pkg::apis::meta::v1::Time;
562            self.meta_mut().deletion_timestamp = Some(Time(now));
563            self
564        }
565
566        /// Modify a kanidm to have an expected status
567        pub fn with_status(mut self, status: KanidmStatus) -> Self {
568            self.status = Some(status);
569            self
570        }
571    }
572
573    // We wrap tower_test::mock::Handle
574    type ApiServerHandle = tower_test::mock::Handle<Request<Body>, Response<Body>>;
575    pub struct ApiServerVerifier(ApiServerHandle);
576
577    /// Scenarios we test for in ApiServerVerifier
578    pub enum Scenario {
579        Create(Kanidm),
580        CreateWithTwoReplicas(Kanidm),
581        CreateWithIngress(Kanidm),
582        CreateWithIngressWithTwoReplicas(Kanidm),
583    }
584
585    pub async fn timeout_after_1s(handle: tokio::task::JoinHandle<()>) {
586        tokio::time::timeout(std::time::Duration::from_secs(1), handle)
587            .await
588            .expect("timeout on mock apiserver")
589            .expect("scenario succeeded")
590    }
591
592    impl ApiServerVerifier {
593        /// Tests only get to run specific scenarios that has matching handlers
594        ///
595        /// This setup makes it easy to handle multiple requests by chaining handlers together.
596        ///
597        /// NB: If the controller is making more calls than we are handling in the scenario,
598        /// you then typically see a `KubeError(Service(Closed(())))` from the reconciler.
599        ///
600        /// You should await the `JoinHandle` (with a timeout) from this function to ensure that the
601        /// scenario runs to completion (i.e. all expected calls were responded to),
602        /// using the timeout to catch missing api calls to Kubernetes.
603        pub fn run(self, scenario: Scenario) -> tokio::task::JoinHandle<()> {
604            tokio::spawn(async move {
605                // moving self => one scenario per test
606                match scenario {
607                    Scenario::Create(kanidm) => {
608                        self.handle_kanidm_status_patch(kanidm.clone())
609                            .await
610                            .unwrap()
611                            .handle_statefulset_patch(kanidm.clone())
612                            .await
613                            .unwrap()
614                            .handle_service_patch(kanidm.clone())
615                            .await
616                    }
617                    Scenario::CreateWithTwoReplicas(kanidm) => {
618                        self.handle_kanidm_status_patch(kanidm.clone())
619                            .await
620                            .unwrap()
621                            .handle_statefulset_patch(kanidm.clone())
622                            .await
623                            .unwrap()
624                            .handle_service_patch(kanidm.clone())
625                            .await
626                    }
627                    Scenario::CreateWithIngress(kanidm) => {
628                        self.handle_kanidm_status_patch(kanidm.clone())
629                            .await
630                            .unwrap()
631                            .handle_statefulset_patch(kanidm.clone())
632                            .await
633                            .unwrap()
634                            .handle_service_patch(kanidm.clone())
635                            .await
636                            .unwrap()
637                            .handle_ingress_patch(kanidm.clone())
638                            .await
639                    }
640                    Scenario::CreateWithIngressWithTwoReplicas(kanidm) => {
641                        self.handle_kanidm_status_patch(kanidm.clone())
642                            .await
643                            .unwrap()
644                            .handle_statefulset_patch(kanidm.clone())
645                            .await
646                            .unwrap()
647                            .handle_service_patch(kanidm.clone())
648                            .await
649                            .unwrap()
650                            .handle_ingress_patch(kanidm.clone())
651                            .await
652                    }
653                }
654                .expect("scenario completed without errors");
655            })
656        }
657
658        async fn handle_kanidm_status_patch(mut self, kanidm: Kanidm) -> Result<Self> {
659            let (request, send) = self.0.next_request().await.expect("service not called");
660            assert_eq!(request.method(), http::Method::PATCH);
661            assert_eq!(
662                request.uri().to_string(),
663                format!(
664                    "/apis/kaniop.rs/v1beta1/namespaces/default/kanidms/{}/status?&force=true&fieldManager=kanidms.kaniop.rs",
665                    kanidm.name_any()
666                )
667            );
668
669            let req_body = request.into_body().collect_bytes().await.unwrap();
670            let json: serde_json::Value =
671                serde_json::from_slice(&req_body).expect("patch object is json");
672            let status: KanidmStatus = serde_json::from_value(json.get("status").unwrap().clone())
673                .expect("valid kanidm status");
674            let mut kanidm = Kanidm::test();
675            kanidm.status = Some(status.clone());
676            let response = serde_json::to_vec(&kanidm).unwrap();
677            // pass through kanidm "patch accepted"
678            send.send_response(Response::builder().body(Body::from(response)).unwrap());
679            Ok(self)
680        }
681
682        async fn handle_statefulset_patch(mut self, kanidm: Kanidm) -> Result<Self> {
683            for rg in kanidm.spec.replica_groups.iter() {
684                let (request, send) = self.0.next_request().await.expect("service not called");
685                assert_eq!(request.method(), http::Method::PATCH);
686                assert_eq!(
687                    request.uri().to_string(),
688                    format!(
689                        "/apis/apps/v1/namespaces/default/statefulsets/{}?&force=true&fieldManager=kanidms.kaniop.rs",
690                        kanidm.statefulset_name(&rg.name)
691                    )
692                );
693                let req_body = request.into_body().collect_bytes().await.unwrap();
694                let json: serde_json::Value =
695                    serde_json::from_slice(&req_body).expect("patch object is json");
696                let statefulset: StatefulSet =
697                    serde_json::from_value(json).expect("valid statefulset");
698                assert_eq!(
699                    statefulset.clone().spec.unwrap().replicas.unwrap(),
700                    rg.replicas
701                );
702                let response = serde_json::to_vec(&statefulset).unwrap();
703                // pass through kanidm "patch accepted"
704                send.send_response(Response::builder().body(Body::from(response)).unwrap());
705            }
706
707            Ok(self)
708        }
709
710        async fn handle_service_patch(mut self, kanidm: Kanidm) -> Result<Self> {
711            let (request, send) = self.0.next_request().await.expect("service not called");
712            assert_eq!(request.method(), http::Method::PATCH);
713            assert_eq!(
714                request.uri().to_string(),
715                format!(
716                    "/api/v1/namespaces/default/services/{}?&force=true&fieldManager=kanidms.kaniop.rs",
717                    kanidm.name_any()
718                )
719            );
720
721            let req_body = request.into_body().collect_bytes().await.unwrap();
722            let json: serde_json::Value =
723                serde_json::from_slice(&req_body).expect("patch object is json");
724            let service: Service = serde_json::from_value(json).expect("valid service");
725            let response = serde_json::to_vec(&service).unwrap();
726            // pass through kanidm "patch accepted"
727            send.send_response(Response::builder().body(Body::from(response)).unwrap());
728            Ok(self)
729        }
730
731        async fn handle_ingress_patch(mut self, kanidm: Kanidm) -> Result<Self> {
732            let (request, send) = self.0.next_request().await.expect("service not called");
733            assert_eq!(request.method(), http::Method::PATCH);
734            assert_eq!(
735                request.uri().to_string(),
736                format!(
737                    "/apis/networking.k8s.io/v1/namespaces/default/ingresses/{}?&force=true&fieldManager=kanidms.kaniop.rs",
738                    kanidm.name_any()
739                )
740            );
741
742            let req_body = request.into_body().collect_bytes().await.unwrap();
743            let json: serde_json::Value =
744                serde_json::from_slice(&req_body).expect("patch object is json");
745            let ingress: Ingress = serde_json::from_value(json).expect("valid service");
746            let response = serde_json::to_vec(&ingress).unwrap();
747            // pass through kanidm "patch accepted"
748            send.send_response(Response::builder().body(Body::from(response)).unwrap());
749            Ok(self)
750        }
751    }
752
753    pub fn get_test_context() -> (Arc<Context>, ApiServerVerifier) {
754        let (mock_service, handle) = tower_test::mock::pair::<Request<Body>, Response<Body>>();
755        let mock_client = Client::new(mock_service, "default");
756        let stores = Stores {
757            stateful_set_store: Writer::default().as_reader(),
758            service_store: Writer::default().as_reader(),
759            ingress_store: Writer::default().as_reader(),
760            secret_store: Writer::default().as_reader(),
761        };
762        let controller_id = "test";
763        let state = State::new(
764            Default::default(),
765            &[controller_id],
766            Writer::default().as_reader(),
767            Writer::default().as_reader(),
768            None,
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}