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 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 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(¤t_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 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 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 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 pub fn with_replicas(mut self, replicas: i32) -> Self {
795 self.spec.replica_groups[0].replicas = replicas;
796 self
797 }
798
799 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(); self.meta_mut().deletion_timestamp = Some(Time(now));
805 self
806 }
807
808 pub fn with_status(mut self, status: KanidmStatus) -> Self {
810 self.status = Some(status);
811 self
812 }
813 }
814
815 type ApiServerHandle = tower_test::mock::Handle<Request<Body>, Response<Body>>;
817 pub struct ApiServerVerifier(ApiServerHandle);
818
819 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 pub fn run(self, scenario: Scenario) -> tokio::task::JoinHandle<()> {
846 tokio::spawn(async move {
847 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 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 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 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 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 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}