Skip to main content

kaniop_operator/kanidm/reconcile/
mod.rs

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