Skip to main content

kaniop_operator/kanidm/reconcile/
mod.rs

1mod domain_appearance;
2mod gateway;
3mod ingress;
4pub mod mail_sender;
5pub mod secret;
6mod service;
7pub mod statefulset;
8mod status;
9
10use self::domain_appearance::reconcile_domain_appearance;
11use self::mail_sender::{
12    cleanup_mail_sender_in_kanidm, cleanup_mail_sender_resources, reconcile_mail_sender,
13};
14use super::controller::{CONTROLLER_ID, context::Context};
15
16use self::gateway::GatewayExt;
17use self::ingress::IngressExt;
18use self::secret::SecretExt;
19use self::service::ServiceExt;
20use self::statefulset::StatefulSetExt;
21use self::status::StatusExt;
22use self::status::{is_kanidm_available, is_kanidm_initialized};
23
24use crate::controller::context::KubeOperations;
25use crate::controller::{INSTANCE_LABEL, MANAGED_BY_LABEL, NAME_LABEL};
26use crate::kanidm::crd::{
27    Kanidm, KanidmReplicaState, KanidmStatus, KanidmUpgradeCheckResult, VersionCompatibilityResult,
28};
29use crate::kanidm::reconcile::statefulset::REPLICA_LABEL;
30use crate::telemetry;
31
32use kaniop_k8s_util::client::get_output;
33use kaniop_k8s_util::error::{Error, Result};
34use kaniop_k8s_util::parse::parse_semver;
35use kaniop_k8s_util::resources::get_image_tag;
36
37use std::collections::BTreeMap;
38use std::fmt::Debug;
39use std::sync::{Arc, LazyLock};
40
41use futures::future::{TryJoinAll, join_all, try_join_all};
42use futures::stream::{self, StreamExt};
43use futures::try_join;
44use k8s_openapi::NamespaceResourceScope;
45use k8s_openapi::api::apps::v1::StatefulSet;
46use k8s_openapi::api::core::v1::Pod;
47use kube::Resource;
48use kube::ResourceExt;
49use kube::api::{Api, AttachParams, Patch, PatchParams};
50use kube::runtime::controller::Action;
51use kube::runtime::events::{Event, EventType};
52use kube::runtime::finalizer::{Event as Finalizer, finalizer};
53use serde::{Deserialize, Serialize};
54use tokio::time::Duration;
55use tracing::{Span, debug, field, info, instrument, trace, warn};
56
57pub const CLUSTER_LABEL: &str = "kanidm.kaniop.rs/cluster";
58const KANIDM_OPERATOR_NAME: &str = "kanidms.kaniop.rs";
59pub static KANIDM_FINALIZER: &str = "kanidms.kaniop.rs/finalizer";
60
61const DEFAULT_RECONCILE_INTERVAL: Duration = Duration::from_secs(24 * 60 * 60);
62
63static LABELS: LazyLock<BTreeMap<String, String>> = LazyLock::new(|| {
64    BTreeMap::from([
65        (NAME_LABEL.to_string(), "kanidm".to_string()),
66        (
67            MANAGED_BY_LABEL.to_string(),
68            format!("kaniop-{CONTROLLER_ID}"),
69        ),
70    ])
71});
72
73pub async fn reconcile_admins_secret(
74    kanidm: Arc<Kanidm>,
75    ctx: Arc<Context>,
76    status: &KanidmStatus,
77) -> Result<()> {
78    if is_kanidm_available(status.clone()) && !is_kanidm_initialized(status.clone()) {
79        let admins_secret = kanidm.generate_admins_secret(ctx.clone()).await?;
80        kanidm.patch(&ctx, admins_secret).await?;
81    }
82    Ok(())
83}
84
85pub async fn reconcile_replication_secrets(
86    kanidm: Arc<Kanidm>,
87    ctx: Arc<Context>,
88    status: &KanidmStatus,
89) -> Result<()> {
90    let expected_secret_names = if kanidm.is_replication_enabled() {
91        status
92            .replica_statuses
93            .iter()
94            .map(|rs| kanidm.replica_secret_name(&rs.pod_name))
95            .collect::<Vec<_>>()
96    } else {
97        Vec::new()
98    };
99    let deprecated_secrets = ctx
100        .stores
101        .secret_store
102        .state()
103        .into_iter()
104        .filter(|secret| {
105            secret.namespace() == kanidm.namespace()
106                && kanidm.admins_secret_name() != secret.name_any()
107                && !expected_secret_names.contains(&secret.name_any())
108                && secret
109                    .metadata
110                    .labels
111                    .as_ref()
112                    .is_some_and(|l| l.get(CLUSTER_LABEL) == Some(&kanidm.name_any()))
113        })
114        .collect::<Vec<_>>();
115    let secret_delete_future = deprecated_secrets
116        .iter()
117        .map(|secret| kanidm.delete(&ctx, secret.as_ref()))
118        .collect::<TryJoinAll<_>>();
119    try_join!(secret_delete_future)?;
120
121    if kanidm.is_replication_enabled() {
122        let has_pending = status
123            .replica_statuses
124            .iter()
125            .any(|rs| rs.state == KanidmReplicaState::Pending);
126
127        let sts_api =
128            Api::<StatefulSet>::namespaced(ctx.kaniop_ctx.client.clone(), &kanidm.get_namespace());
129
130        if has_pending {
131            stream::iter(
132                status
133                    .replica_statuses
134                    .iter()
135                    .filter(|rs| rs.state == KanidmReplicaState::Pending),
136            )
137            .then(|rs| async {
138                let secret = kanidm
139                    .generate_replica_secret(ctx.clone(), &rs.pod_name)
140                    .await?;
141                kanidm.patch(&ctx, secret).await
142            })
143            .collect::<Vec<_>>()
144            .await
145            .into_iter()
146            .collect::<Result<Vec<_>>>()?;
147
148            let has_single_replica = kanidm.spec.replica_groups.iter().any(|rg| rg.replicas == 1);
149
150            let restart_futures = status
151                .replica_statuses
152                .iter()
153                .map(|rs| sts_api.restart(&rs.statefulset_name));
154
155            if has_single_replica {
156                let results: Vec<_> = stream::iter(restart_futures).then(|f| f).collect().await;
157                if let Some(first_err) = results.into_iter().find_map(|r| r.err()) {
158                    return Err(Error::kube_error(
159                        "restart",
160                        "StatefulSet",
161                        kanidm.get_namespace(),
162                        "pending replica statefulsets",
163                        first_err,
164                    ));
165                }
166            } else {
167                let results: Vec<_> = join_all(restart_futures).await;
168                if let Some(first_err) = results.into_iter().find_map(|r| r.err()) {
169                    return Err(Error::kube_error(
170                        "restart",
171                        "StatefulSet",
172                        kanidm.get_namespace(),
173                        "pending replica statefulsets",
174                        first_err,
175                    ));
176                }
177            }
178        }
179
180        let has_certificate_host_invalid = status
181            .replica_statuses
182            .iter()
183            .any(|rs| rs.state == KanidmReplicaState::CertificateHostInvalid);
184
185        let has_certificate_expiring = status
186            .replica_statuses
187            .iter()
188            .any(|rs| rs.state == KanidmReplicaState::CertificateExpiring);
189
190        let has_non_ready_replicas = status
191            .replica_statuses
192            .iter()
193            .any(|rs| rs.state != KanidmReplicaState::Ready);
194
195        let cert_renewal_replicas: Vec<_> = status
196            .replica_statuses
197            .iter()
198            .filter(|rs| {
199                rs.state == KanidmReplicaState::CertificateHostInvalid
200                    || rs.state == KanidmReplicaState::CertificateExpiring
201            })
202            .collect();
203
204        if !cert_renewal_replicas.is_empty() {
205            let has_single_replica = kanidm.spec.replica_groups.iter().any(|rg| rg.replicas == 1);
206
207            let restart_futures = cert_renewal_replicas
208                .iter()
209                .map(|rs| sts_api.restart(&rs.statefulset_name));
210
211            if has_single_replica {
212                let results: Vec<_> = stream::iter(restart_futures).then(|f| f).collect().await;
213                if let Some(first_err) = results.into_iter().find_map(|r| r.err()) {
214                    return Err(Error::kube_error(
215                        "restart",
216                        "StatefulSet",
217                        kanidm.get_namespace(),
218                        "certificate renewal statefulsets",
219                        first_err,
220                    ));
221                }
222            } else {
223                let results: Vec<_> = join_all(restart_futures).await;
224                if let Some(first_err) = results.into_iter().find_map(|r| r.err()) {
225                    return Err(Error::kube_error(
226                        "restart",
227                        "StatefulSet",
228                        kanidm.get_namespace(),
229                        "certificate renewal statefulsets",
230                        first_err,
231                    ));
232                }
233            }
234
235            for rs in cert_renewal_replicas {
236                let secret = match kanidm
237                    .update_replica_secret(ctx.clone(), &rs.pod_name)
238                    .await
239                {
240                    Ok(secret) => secret,
241                    Err(_) => {
242                        kanidm
243                            .generate_replica_secret(ctx.clone(), &rs.pod_name)
244                            .await?
245                    }
246                };
247                kanidm.patch(&ctx, secret.clone()).await?;
248            }
249        }
250
251        if has_non_ready_replicas
252            && !has_pending
253            && !has_certificate_host_invalid
254            && !has_certificate_expiring
255        {
256            let has_single_replica = kanidm.spec.replica_groups.iter().any(|rg| rg.replicas == 1);
257
258            let restart_futures = status
259                .replica_statuses
260                .iter()
261                .map(|rs| sts_api.restart(&rs.statefulset_name));
262
263            if has_single_replica {
264                let results: Vec<_> = stream::iter(restart_futures).then(|f| f).collect().await;
265                if let Some(first_err) = results.into_iter().find_map(|r| r.err()) {
266                    return Err(Error::kube_error(
267                        "restart",
268                        "StatefulSet",
269                        kanidm.get_namespace(),
270                        "replica statefulsets",
271                        first_err,
272                    ));
273                }
274            } else {
275                let results: Vec<_> = join_all(restart_futures).await;
276                if let Some(first_err) = results.into_iter().find_map(|r| r.err()) {
277                    return Err(Error::kube_error(
278                        "restart",
279                        "StatefulSet",
280                        kanidm.get_namespace(),
281                        "replica statefulsets",
282                        first_err,
283                    ));
284                }
285            }
286        }
287    }
288
289    Ok(())
290}
291
292#[instrument(skip(ctx, kanidm))]
293pub async fn reconcile_kanidm(kanidm: Arc<Kanidm>, ctx: Arc<Context>) -> Result<Action> {
294    let trace_id = telemetry::get_trace_id();
295    Span::current().record("trace_id", field::display(&trace_id));
296    let _timer = ctx
297        .kaniop_ctx
298        .metrics
299        .reconcile_count_and_measure(&trace_id);
300    info!(msg = "reconciling Kanidm");
301
302    let status = kanidm.update_status(ctx.clone()).await.map_err(|e| {
303        debug!(msg = "failed to reconcile status", %e);
304        ctx.kaniop_ctx.metrics.status_update_errors_inc();
305        e
306    })?;
307    let kanidm_api: Api<Kanidm> =
308        Api::namespaced(ctx.kaniop_ctx.client.clone(), &kanidm.get_namespace());
309    finalizer(&kanidm_api, KANIDM_FINALIZER, kanidm, |event| async {
310        match event {
311            Finalizer::Apply(kanidm) => reconcile(kanidm, ctx, status).await,
312            Finalizer::Cleanup(kanidm) => cleanup(kanidm, ctx).await,
313        }
314    })
315    .await
316    .map_err(|e| {
317        Error::FinalizerError(
318            "failed on kanidm account finalizer".to_string(),
319            Box::new(e),
320        )
321    })
322}
323
324async fn reconcile(kanidm: Arc<Kanidm>, ctx: Arc<Context>, status: KanidmStatus) -> Result<Action> {
325    let admin_secret_future = reconcile_admins_secret(kanidm.clone(), ctx.clone(), &status);
326    let replication_secret_futures =
327        reconcile_replication_secrets(kanidm.clone(), ctx.clone(), &status);
328
329    let sts_to_delete = {
330        let expected_sts_names = kanidm
331            .spec
332            .replica_groups
333            .iter()
334            .map(|rg| kanidm.statefulset_name(&rg.name))
335            .collect::<Vec<_>>();
336        ctx.stores
337            .stateful_set_store
338            .state()
339            .into_iter()
340            .filter(|sts| {
341                sts.namespace() == kanidm.namespace()
342                    && sts
343                        .metadata
344                        .labels
345                        .as_ref()
346                        .is_some_and(|l| l.get(CLUSTER_LABEL) == Some(&kanidm.name_any()))
347                    && !expected_sts_names.contains(&sts.name_any())
348            })
349            .collect::<Vec<_>>()
350    };
351    let sts_delete_futures = sts_to_delete
352        .iter()
353        .map(|sts| kanidm.delete(&ctx, sts.as_ref()))
354        .collect::<TryJoinAll<_>>();
355
356    let sts_futures = match kanidm.is_updatable(&status) {
357        true => kanidm
358            .spec
359            .replica_groups
360            .iter()
361            .map(|rg| {
362                let sts = kanidm.create_statefulset(rg)?;
363                Ok(kanidm.patch(&ctx, sts))
364            })
365            .collect::<Result<TryJoinAll<_>, _>>()?,
366        false => {
367            let note = match status.version.as_ref() {
368                Some(v) if v.compatibility_result == VersionCompatibilityResult::Incompatible => {
369                    format!(
370                        "Version change blocked: image version {} is not compatible with operator (uses Kanidm client v{}). Override with `.spec.disableUpgradeChecks: true` or use a compatible version.",
371                        v.image_tag,
372                        crate::version::KANIDM_CLIENT_VERSION
373                    )
374                }
375                _ => "Version change blocked: upgrade pre-check failed. Override with `.spec.disableUpgradeCheck: true` or update the resource to retry.".to_string(),
376            };
377            let _ignore_error = ctx
378                .kaniop_ctx
379                .recorder
380                .publish(
381                    &Event {
382                        type_: EventType::Warning,
383                        reason: "UpgradeBlocked".to_string(),
384                        note: Some(note),
385                        action: "ReconcileStatefulSet".to_string(),
386                        secondary: None,
387                    },
388                    &kanidm.object_ref(&()),
389                )
390                .await
391                .map_err(|e| {
392                    warn!(msg = "failed to publish KanidmError event", %e);
393                    Error::KubeError("failed to publish event".to_string(), Box::new(e))
394                });
395            try_join_all([])
396        }
397    };
398    let service_future = kanidm.patch(&ctx, kanidm.create_service());
399
400    let deprecated_rg_svcs = {
401        let expected_rg_svcs_names = kanidm
402            .spec
403            .replica_groups
404            .iter()
405            .filter(|rg| rg.services.is_some())
406            .flat_map(|rg| (0..rg.replicas).map(|i| kanidm.replica_group_service_name(&rg.name, i)))
407            .collect::<Vec<_>>();
408        ctx.stores
409            .service_store
410            .state()
411            .into_iter()
412            .filter(|svc| {
413                let labels = svc.metadata.labels.as_ref();
414                svc.namespace() == kanidm.namespace()
415                    && !expected_rg_svcs_names.contains(&svc.name_any())
416                    && labels.is_some_and(|l| {
417                        l.contains_key(REPLICA_LABEL)
418                            && l.get(CLUSTER_LABEL) == Some(&kanidm.name_any())
419                    })
420            })
421            .collect::<Vec<_>>()
422    };
423    let rg_svcs_delete_futures = deprecated_rg_svcs
424        .iter()
425        .map(|svc| kanidm.delete(&ctx, svc.as_ref()))
426        .collect::<TryJoinAll<_>>();
427
428    let rg_services_futures = kanidm
429        .spec
430        .replica_groups
431        .iter()
432        .filter(|rg| rg.services.is_some())
433        .flat_map(|rg| {
434            (0..rg.replicas).map(|i| kanidm.patch(&ctx, kanidm.create_replica_group_service(rg, i)))
435        })
436        .collect::<TryJoinAll<_>>();
437
438    let deprecated_ingresses = {
439        let names = [
440            kanidm.spec.ingress.as_ref().map(|_| kanidm.name_any()),
441            kanidm.generate_region_ingress_name(),
442        ]
443        .into_iter()
444        .flatten()
445        .collect::<Vec<_>>();
446        ctx.stores
447            .ingress_store
448            .state()
449            .into_iter()
450            .filter(|ing| {
451                ing.namespace() == kanidm.namespace()
452                    && !names.contains(&ing.name_any())
453                    && ing.metadata.labels == Some(kanidm.generate_labels())
454            })
455            .collect::<Vec<_>>()
456    };
457    let ingress_delete_futures = deprecated_ingresses
458        .iter()
459        .map(|ing| kanidm.delete(&ctx, ing.as_ref()))
460        .collect::<TryJoinAll<_>>();
461
462    let ingress_futures = kanidm
463        .create_ingress()
464        .into_iter()
465        .chain(kanidm.create_region_ingress())
466        .map(|ingress| kanidm.patch(&ctx, ingress))
467        .collect::<TryJoinAll<_>>();
468
469    let deprecated_http_routes = match &ctx.stores.http_route_store {
470        Some(store) => {
471            let expected_names = kanidm
472                .spec
473                .gateway
474                .as_ref()
475                .map(|_| vec![kanidm.name_any()])
476                .unwrap_or_default();
477            store
478                .state()
479                .into_iter()
480                .filter(|route| {
481                    route.namespace() == kanidm.namespace()
482                        && !expected_names.contains(&route.name_any())
483                        && route.metadata.labels == Some(kanidm.generate_labels())
484                })
485                .collect::<Vec<_>>()
486        }
487        None => Vec::new(),
488    };
489    let http_route_delete_futures = deprecated_http_routes
490        .iter()
491        .map(|route| kanidm.delete(&ctx, route.as_ref()))
492        .collect::<TryJoinAll<_>>();
493
494    let http_route_futures = if ctx.stores.http_route_store.is_some() {
495        kanidm
496            .create_http_route()
497            .into_iter()
498            .map(|route| kanidm.patch(&ctx, route))
499            .collect::<TryJoinAll<_>>()
500    } else {
501        try_join_all(Vec::new())
502    };
503
504    try_join!(
505        sts_delete_futures,
506        admin_secret_future,
507        replication_secret_futures,
508        sts_futures,
509        service_future,
510        rg_svcs_delete_futures,
511        rg_services_futures,
512        ingress_delete_futures,
513        ingress_futures,
514        http_route_delete_futures,
515        http_route_futures
516    )?;
517
518    if is_kanidm_available(status.clone()) {
519        let namespace = kanidm.namespace().unwrap();
520        let name = kanidm.name_any();
521        let system_client = crate::controller::kanidm::KanidmClients::create_client(
522            &namespace,
523            &name,
524            crate::controller::kanidm::KanidmUser::Admin,
525            ctx.kaniop_ctx.client.clone(),
526        )
527        .await?;
528        reconcile_domain_appearance(&kanidm, system_client, &status, ctx.clone()).await?;
529
530        let kanidm_client = crate::controller::kanidm::KanidmClients::create_client(
531            &namespace,
532            &name,
533            crate::controller::kanidm::KanidmUser::IdmAdmin,
534            ctx.kaniop_ctx.client.clone(),
535        )
536        .await?;
537        let mail_sender_status =
538            reconcile_mail_sender(&kanidm, kanidm_client.clone(), ctx.clone()).await?;
539        let current_mail_sender_status = kanidm.status.as_ref().and_then(|s| s.mail_sender.clone());
540        if mail_sender_status != current_mail_sender_status {
541            let kanidm_api: Api<Kanidm> =
542                Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
543            let status_patch = serde_json::json!({
544                "status": {
545                    "mailSender": mail_sender_status
546                }
547            });
548            kanidm_api
549                .patch_status(&name, &PatchParams::default(), &Patch::Merge(&status_patch))
550                .await
551                .map_err(|e| {
552                    Error::KubeError(
553                        format!("failed to patch Kanidm/status {namespace}/{name}"),
554                        Box::new(e),
555                    )
556                })?;
557        }
558    }
559
560    Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL))
561}
562
563async fn cleanup(kanidm: Arc<Kanidm>, ctx: Arc<Context>) -> Result<Action> {
564    debug!(msg = "cleanup");
565
566    cleanup_mail_sender_resources(&kanidm, &ctx).await?;
567
568    let namespace = kanidm.namespace().unwrap();
569    let name = kanidm.name_any();
570
571    if let Ok(kanidm_client) = crate::controller::kanidm::KanidmClients::create_client(
572        &namespace,
573        &name,
574        crate::controller::kanidm::KanidmUser::IdmAdmin,
575        ctx.kaniop_ctx.client.clone(),
576    )
577    .await
578    {
579        cleanup_mail_sender_in_kanidm(&kanidm_client, &name).await?;
580    }
581
582    ctx.kaniop_ctx.release_kanidm_clients(&kanidm).await;
583    Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL))
584}
585
586impl Kanidm {
587    // Convenience methods that handle context and operator name
588    pub async fn delete<K>(&self, ctx: &Context, resource: &K) -> Result<()>
589    where
590        K: Resource<Scope = NamespaceResourceScope>
591            + Serialize
592            + Clone
593            + std::fmt::Debug
594            + for<'de> Deserialize<'de>,
595        <K as kube::Resource>::DynamicType: Default,
596        <K as Resource>::Scope: std::marker::Sized,
597    {
598        self.kube_delete(
599            ctx.kaniop_ctx.client.clone(),
600            &ctx.kaniop_ctx.metrics,
601            resource,
602        )
603        .await
604    }
605
606    pub async fn patch<K>(&self, ctx: &Context, resource: K) -> Result<K>
607    where
608        K: Resource<Scope = NamespaceResourceScope>
609            + Serialize
610            + Clone
611            + std::fmt::Debug
612            + for<'de> Deserialize<'de>,
613        <K as kube::Resource>::DynamicType: Default,
614        <K as Resource>::Scope: std::marker::Sized,
615    {
616        self.kube_patch(
617            ctx.kaniop_ctx.client.clone(),
618            &ctx.kaniop_ctx.metrics,
619            resource,
620            KANIDM_OPERATOR_NAME,
621        )
622        .await
623    }
624
625    #[inline]
626    fn generate_resource_labels(&self) -> BTreeMap<String, String> {
627        LABELS
628            .clone()
629            .into_iter()
630            .chain([
631                (INSTANCE_LABEL.to_string(), self.name_any()),
632                (CLUSTER_LABEL.to_string(), self.name_any()),
633            ])
634            .collect()
635    }
636
637    #[inline]
638    fn generate_labels(&self) -> BTreeMap<String, String> {
639        self.generate_resource_labels()
640    }
641
642    #[inline]
643    fn get_tls_secret_name(&self) -> String {
644        format!("{}-tls", self.name_any())
645    }
646
647    #[inline]
648    fn get_namespace(&self) -> String {
649        // safe unwrap: Kanidm is namespaced scoped
650        self.namespace().unwrap()
651    }
652
653    #[inline]
654    fn is_replication_enabled(&self) -> bool {
655        self.spec.replica_groups.len() > 1
656            || self
657                .spec
658                .replica_groups
659                .first()
660                .is_some_and(|rg| rg.replicas > 1)
661            || !self.spec.external_replication_nodes.is_empty()
662    }
663
664    #[inline]
665    fn is_updatable(&self, status: &KanidmStatus) -> bool {
666        status
667            .version
668            .as_ref()
669            .map(|v| {
670                if v.compatibility_result == VersionCompatibilityResult::Incompatible {
671                    return false;
672                }
673                let current_tag = get_image_tag(&self.spec.image).unwrap_or_default();
674                let versions = (parse_semver(&current_tag), parse_semver(&v.image_tag));
675                match v.upgrade_check_result {
676                    KanidmUpgradeCheckResult::Passed => {
677                        if let (Some((_, minor, _)), Some((_, v_minor, _))) = versions {
678                            minor <= v_minor + 1
679                        } else {
680                            true
681                        }
682                    }
683                    KanidmUpgradeCheckResult::Failed => {
684                        if let (Some((major, minor, patch)), Some((v_major, v_minor, v_patch))) =
685                            versions
686                        {
687                            major == v_major && minor == v_minor && patch >= v_patch
688                        } else {
689                            v.image_tag == current_tag
690                        }
691                    }
692                }
693            })
694            .unwrap_or(true)
695    }
696
697    async fn exec<I, T>(&self, ctx: Arc<Context>, pod_name: &str, command: I) -> Result<String>
698    where
699        I: IntoIterator<Item = T> + Debug,
700        T: Into<String>,
701    {
702        let namespace = &self.get_namespace();
703        trace!(
704            msg = "pod exec",
705            resource.name = &pod_name,
706            resource.namespace = &namespace,
707            ?command
708        );
709        let pod = Api::<Pod>::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
710        let attached = pod
711            .exec(
712                pod_name,
713                command,
714                &AttachParams::default().container("kanidm"),
715            )
716            .await
717            .map_err(|e| {
718                Error::KubeError(
719                    format!("failed to exec pod {namespace}/{pod_name}"),
720                    Box::new(e),
721                )
722            })?;
723        get_output(attached).await
724    }
725
726    async fn exec_any<I, T>(&self, ctx: Arc<Context>, command: I) -> Result<String>
727    where
728        I: IntoIterator<Item = T> + Debug,
729        T: Into<String>,
730    {
731        // TODO: if replicas > 1 and replicas initialized, exec on pod available
732        let first_replica_group = self
733            .spec
734            .replica_groups
735            .first()
736            .ok_or_else(|| Error::MissingData("no replica groups configured".to_string()))?;
737        let sts_name = self.statefulset_name(&first_replica_group.name);
738        let pod_name = format!("{sts_name}-0");
739        self.exec(ctx, &pod_name, command).await
740    }
741}
742
743#[cfg(test)]
744mod test {
745    use super::statefulset::StatefulSetExt;
746    use super::{Kanidm, reconcile_kanidm};
747
748    use crate::controller::State;
749    use crate::kanidm::controller::context::{Context, Stores};
750    use crate::kanidm::crd::KanidmStatus;
751
752    use kaniop_k8s_util::error::Result;
753
754    use std::sync::Arc;
755
756    use http::{Request, Response};
757    use k8s_openapi::api::apps::v1::StatefulSet;
758    use k8s_openapi::api::core::v1::Service;
759    use k8s_openapi::api::networking::v1::Ingress;
760    use kube::runtime::reflector::store::Writer;
761    use kube::{Client, Resource, ResourceExt, client::Body};
762    use opentelemetry::metrics::MeterProvider;
763    use serde_json::json;
764
765    impl Kanidm {
766        /// A normal test kanidm with a given status
767        pub fn test() -> Self {
768            let mut e = Kanidm::new(
769                "test",
770                serde_json::from_value(json!({
771                    "domain": "idm.example.com",
772                    "replicaGroups": [
773                        {
774                            "name": "default",
775                            "replicas": 1
776                        }
777                    ]
778                }))
779                .unwrap(),
780            );
781            e.meta_mut().namespace = Some("default".into());
782            // Pre-populate finalizer so reconcile callback runs immediately
783            // (skips the "add finalizer + wait for next reconcile" step)
784            e.meta_mut().finalizers = Some(vec![super::KANIDM_FINALIZER.to_string()]);
785            e
786        }
787
788        pub fn with_ingress(mut self) -> Self {
789            self.spec.ingress = Some(serde_json::from_value(json!({})).unwrap());
790            self
791        }
792
793        /// Modify kanidm replicas
794        pub fn with_replicas(mut self, replicas: i32) -> Self {
795            self.spec.replica_groups[0].replicas = replicas;
796            self
797        }
798
799        /// Modify kanidm to set a deletion timestamp
800        pub fn needs_delete(mut self) -> Self {
801            use k8s_openapi::apimachinery::pkg::apis::meta::v1::Time;
802            use k8s_openapi::jiff::Timestamp;
803            let now = Timestamp::from_second(1491138632).unwrap(); // 2017-04-02 12:50:32 UTC
804            self.meta_mut().deletion_timestamp = Some(Time(now));
805            self
806        }
807
808        /// Modify a kanidm to have an expected status
809        pub fn with_status(mut self, status: KanidmStatus) -> Self {
810            self.status = Some(status);
811            self
812        }
813    }
814
815    // We wrap tower_test::mock::Handle
816    type ApiServerHandle = tower_test::mock::Handle<Request<Body>, Response<Body>>;
817    pub struct ApiServerVerifier(ApiServerHandle);
818
819    /// Scenarios we test for in ApiServerVerifier
820    pub enum Scenario {
821        Create(Kanidm),
822        CreateWithTwoReplicas(Kanidm),
823        CreateWithIngress(Kanidm),
824        CreateWithIngressWithTwoReplicas(Kanidm),
825    }
826
827    pub async fn timeout_after_1s(handle: tokio::task::JoinHandle<()>) {
828        tokio::time::timeout(std::time::Duration::from_secs(1), handle)
829            .await
830            .expect("timeout on mock apiserver")
831            .expect("scenario succeeded")
832    }
833
834    impl ApiServerVerifier {
835        /// Tests only get to run specific scenarios that has matching handlers
836        ///
837        /// This setup makes it easy to handle multiple requests by chaining handlers together.
838        ///
839        /// NB: If the controller is making more calls than we are handling in the scenario,
840        /// you then typically see a `KubeError(Service(Closed(())))` from the reconciler.
841        ///
842        /// You should await the `JoinHandle` (with a timeout) from this function to ensure that the
843        /// scenario runs to completion (i.e. all expected calls were responded to),
844        /// using the timeout to catch missing api calls to Kubernetes.
845        pub fn run(self, scenario: Scenario) -> tokio::task::JoinHandle<()> {
846            tokio::spawn(async move {
847                // moving self => one scenario per test
848                match scenario {
849                    Scenario::Create(kanidm) => {
850                        self.handle_kanidm_get(kanidm.clone())
851                            .await
852                            .unwrap()
853                            .handle_kanidm_status_patch(kanidm.clone())
854                            .await
855                            .unwrap()
856                            .handle_statefulset_patch(kanidm.clone())
857                            .await
858                            .unwrap()
859                            .handle_service_patch(kanidm.clone())
860                            .await
861                    }
862                    Scenario::CreateWithTwoReplicas(kanidm) => {
863                        self.handle_kanidm_get(kanidm.clone())
864                            .await
865                            .unwrap()
866                            .handle_kanidm_status_patch(kanidm.clone())
867                            .await
868                            .unwrap()
869                            .handle_statefulset_patch(kanidm.clone())
870                            .await
871                            .unwrap()
872                            .handle_service_patch(kanidm.clone())
873                            .await
874                    }
875                    Scenario::CreateWithIngress(kanidm) => {
876                        self.handle_kanidm_get(kanidm.clone())
877                            .await
878                            .unwrap()
879                            .handle_kanidm_status_patch(kanidm.clone())
880                            .await
881                            .unwrap()
882                            .handle_statefulset_patch(kanidm.clone())
883                            .await
884                            .unwrap()
885                            .handle_service_patch(kanidm.clone())
886                            .await
887                            .unwrap()
888                            .handle_ingress_patch(kanidm.clone())
889                            .await
890                    }
891                    Scenario::CreateWithIngressWithTwoReplicas(kanidm) => {
892                        self.handle_kanidm_get(kanidm.clone())
893                            .await
894                            .unwrap()
895                            .handle_kanidm_status_patch(kanidm.clone())
896                            .await
897                            .unwrap()
898                            .handle_statefulset_patch(kanidm.clone())
899                            .await
900                            .unwrap()
901                            .handle_service_patch(kanidm.clone())
902                            .await
903                            .unwrap()
904                            .handle_ingress_patch(kanidm.clone())
905                            .await
906                    }
907                }
908                .expect("scenario completed without errors");
909            })
910        }
911
912        async fn handle_kanidm_get(mut self, kanidm: Kanidm) -> Result<Self> {
913            let (request, send) = self.0.next_request().await.expect("service not called");
914            assert_eq!(request.method(), http::Method::GET);
915            let expected_uri_prefix = format!(
916                "/apis/kaniop.rs/v1beta1/namespaces/default/kanidms/{}",
917                kanidm.name_any()
918            );
919            let uri = request.uri().to_string();
920            assert!(
921                uri.starts_with(&expected_uri_prefix),
922                "expected uri to start with {}, got {}",
923                expected_uri_prefix,
924                uri
925            );
926            let response = serde_json::to_vec(&kanidm).unwrap();
927            send.send_response(Response::builder().body(Body::from(response)).unwrap());
928            Ok(self)
929        }
930
931        async fn handle_kanidm_status_patch(mut self, kanidm: Kanidm) -> Result<Self> {
932            let (request, send) = self.0.next_request().await.expect("service not called");
933            assert_eq!(request.method(), http::Method::PATCH);
934            assert_eq!(
935                request.uri().to_string(),
936                format!(
937                    "/apis/kaniop.rs/v1beta1/namespaces/default/kanidms/{}/status?",
938                    kanidm.name_any()
939                )
940            );
941
942            let req_body = request.into_body().collect_bytes().await.unwrap();
943            let json: serde_json::Value =
944                serde_json::from_slice(&req_body).expect("patch object is json");
945            let status: KanidmStatus = serde_json::from_value(json.get("status").unwrap().clone())
946                .expect("valid kanidm status");
947            let mut kanidm = Kanidm::test();
948            kanidm.status = Some(status.clone());
949            let response = serde_json::to_vec(&kanidm).unwrap();
950            // pass through kanidm "patch accepted"
951            send.send_response(Response::builder().body(Body::from(response)).unwrap());
952            Ok(self)
953        }
954
955        async fn handle_statefulset_patch(mut self, kanidm: Kanidm) -> Result<Self> {
956            for rg in kanidm.spec.replica_groups.iter() {
957                let (request, send) = self.0.next_request().await.expect("service not called");
958                assert_eq!(request.method(), http::Method::PATCH);
959                assert_eq!(
960                    request.uri().to_string(),
961                    format!(
962                        "/apis/apps/v1/namespaces/default/statefulsets/{}?&force=true&fieldManager=kanidms.kaniop.rs",
963                        kanidm.statefulset_name(&rg.name)
964                    )
965                );
966                let req_body = request.into_body().collect_bytes().await.unwrap();
967                let json: serde_json::Value =
968                    serde_json::from_slice(&req_body).expect("patch object is json");
969                let statefulset: StatefulSet =
970                    serde_json::from_value(json).expect("valid statefulset");
971                assert_eq!(
972                    statefulset.clone().spec.unwrap().replicas.unwrap(),
973                    rg.replicas
974                );
975                let response = serde_json::to_vec(&statefulset).unwrap();
976                // pass through kanidm "patch accepted"
977                send.send_response(Response::builder().body(Body::from(response)).unwrap());
978            }
979
980            Ok(self)
981        }
982
983        async fn handle_service_patch(mut self, kanidm: Kanidm) -> Result<Self> {
984            let (request, send) = self.0.next_request().await.expect("service not called");
985            assert_eq!(request.method(), http::Method::PATCH);
986            assert_eq!(
987                request.uri().to_string(),
988                format!(
989                    "/api/v1/namespaces/default/services/{}?&force=true&fieldManager=kanidms.kaniop.rs",
990                    kanidm.name_any()
991                )
992            );
993
994            let req_body = request.into_body().collect_bytes().await.unwrap();
995            let json: serde_json::Value =
996                serde_json::from_slice(&req_body).expect("patch object is json");
997            let service: Service = serde_json::from_value(json).expect("valid service");
998            let response = serde_json::to_vec(&service).unwrap();
999            // pass through kanidm "patch accepted"
1000            send.send_response(Response::builder().body(Body::from(response)).unwrap());
1001            Ok(self)
1002        }
1003
1004        async fn handle_ingress_patch(mut self, kanidm: Kanidm) -> Result<Self> {
1005            let (request, send) = self.0.next_request().await.expect("service not called");
1006            assert_eq!(request.method(), http::Method::PATCH);
1007            assert_eq!(
1008                request.uri().to_string(),
1009                format!(
1010                    "/apis/networking.k8s.io/v1/namespaces/default/ingresses/{}?&force=true&fieldManager=kanidms.kaniop.rs",
1011                    kanidm.name_any()
1012                )
1013            );
1014
1015            let req_body = request.into_body().collect_bytes().await.unwrap();
1016            let json: serde_json::Value =
1017                serde_json::from_slice(&req_body).expect("patch object is json");
1018            let ingress: Ingress = serde_json::from_value(json).expect("valid service");
1019            let response = serde_json::to_vec(&ingress).unwrap();
1020            // pass through kanidm "patch accepted"
1021            send.send_response(Response::builder().body(Body::from(response)).unwrap());
1022            Ok(self)
1023        }
1024    }
1025
1026    pub fn get_test_context() -> (Arc<Context>, ApiServerVerifier) {
1027        let (mock_service, handle) = tower_test::mock::pair::<Request<Body>, Response<Body>>();
1028        let mock_client = Client::new(mock_service, "default");
1029        let stores = Stores {
1030            stateful_set_store: Writer::default().as_reader(),
1031            service_store: Writer::default().as_reader(),
1032            ingress_store: Writer::default().as_reader(),
1033            secret_store: Writer::default().as_reader(),
1034            http_route_store: Some(Writer::default().as_reader()),
1035            deployment_store: Writer::default().as_reader(),
1036            config_map_store: Writer::default().as_reader(),
1037        };
1038        let controller_id = "test";
1039
1040        // Create a test meter for metrics
1041        let provider = opentelemetry_sdk::metrics::SdkMeterProvider::builder().build();
1042        let meter = provider.meter("test");
1043        let metrics = crate::metrics::Metrics::new(&meter, &[controller_id]);
1044
1045        let state = State::new(
1046            metrics,
1047            Writer::default().as_reader(),
1048            Writer::default().as_reader(),
1049            None,
1050        );
1051        let ctx = Arc::new(Context::new(
1052            state.to_context(mock_client, controller_id),
1053            stores,
1054        ));
1055        (ctx, ApiServerVerifier(handle))
1056    }
1057
1058    #[tokio::test]
1059    async fn kanidm_create() {
1060        let (testctx, fakeserver) = get_test_context();
1061        let kanidm = Kanidm::test();
1062        let mocksrv = fakeserver.run(Scenario::Create(kanidm.clone()));
1063        reconcile_kanidm(Arc::new(kanidm), testctx)
1064            .await
1065            .expect("reconciler");
1066        timeout_after_1s(mocksrv).await;
1067    }
1068
1069    #[tokio::test]
1070    async fn kanidm_create_with_two_replicas() {
1071        let (testctx, fakeserver) = get_test_context();
1072        let kanidm = Kanidm::test().with_replicas(2);
1073        let mocksrv = fakeserver.run(Scenario::CreateWithTwoReplicas(kanidm.clone()));
1074        reconcile_kanidm(Arc::new(kanidm), testctx)
1075            .await
1076            .expect("reconciler");
1077        timeout_after_1s(mocksrv).await;
1078    }
1079
1080    #[tokio::test]
1081    async fn kanidm_create_with_ingress() {
1082        let (testctx, fakeserver) = get_test_context();
1083        let kanidm = Kanidm::test().with_ingress();
1084        let mocksrv = fakeserver.run(Scenario::CreateWithIngress(kanidm.clone()));
1085        reconcile_kanidm(Arc::new(kanidm), testctx)
1086            .await
1087            .expect("reconciler");
1088        timeout_after_1s(mocksrv).await;
1089    }
1090
1091    #[tokio::test]
1092    async fn kanidm_create_with_ingress_with_two_replicas() {
1093        let (testctx, fakeserver) = get_test_context();
1094        let kanidm = Kanidm::test().with_ingress().with_replicas(2);
1095        let mocksrv = fakeserver.run(Scenario::CreateWithIngressWithTwoReplicas(kanidm.clone()));
1096        reconcile_kanidm(Arc::new(kanidm), testctx)
1097            .await
1098            .expect("reconciler");
1099        timeout_after_1s(mocksrv).await;
1100    }
1101}