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