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| match v.upgrade_check_result {
449 KanidmUpgradeCheckResult::Passed => true,
450 KanidmUpgradeCheckResult::Failed => {
451 let current_tag = get_image_tag(&self.spec.image).unwrap_or_default();
452 if let (Some((major, minor, patch)), Some((v_major, v_minor, v_patch))) =
453 (parse_semver(¤t_tag), parse_semver(&v.image_tag))
454 {
455 major == v_major && minor == v_minor && patch >= v_patch
456 } else {
457 v.image_tag == current_tag
458 }
459 }
460 })
461 .unwrap_or(true)
462 }
463
464 async fn exec<I, T>(&self, ctx: Arc<Context>, pod_name: &str, command: I) -> Result<String>
465 where
466 I: IntoIterator<Item = T> + Debug,
467 T: Into<String>,
468 {
469 let namespace = &self.get_namespace();
470 trace!(
471 msg = "pod exec",
472 resource.name = &pod_name,
473 resource.namespace = &namespace,
474 ?command
475 );
476 let pod = Api::<Pod>::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
477 let attached = pod
478 .exec(pod_name, command, &AttachParams::default())
479 .await
480 .map_err(|e| {
481 Error::KubeError(
482 format!("failed to exec pod {namespace}/{pod_name}"),
483 Box::new(e),
484 )
485 })?;
486 get_output(attached).await
487 }
488
489 async fn exec_any<I, T>(&self, ctx: Arc<Context>, command: I) -> Result<String>
490 where
491 I: IntoIterator<Item = T> + Debug,
492 T: Into<String>,
493 {
494 let sts_name = self.statefulset_name(&self.spec.replica_groups.first().unwrap().name);
497 let pod_name = format!("{sts_name}-0");
498 self.exec(ctx, &pod_name, command).await
499 }
500}
501
502#[cfg(test)]
503mod test {
504 use super::statefulset::StatefulSetExt;
505 use super::{Kanidm, reconcile_kanidm};
506
507 use crate::controller::State;
508 use crate::kanidm::controller::context::{Context, Stores};
509 use crate::kanidm::crd::KanidmStatus;
510
511 use kaniop_k8s_util::error::Result;
512
513 use std::sync::Arc;
514
515 use http::{Request, Response};
516 use k8s_openapi::api::apps::v1::StatefulSet;
517 use k8s_openapi::api::core::v1::Service;
518 use k8s_openapi::api::networking::v1::Ingress;
519 use kube::runtime::reflector::store::Writer;
520 use kube::{Client, Resource, ResourceExt, client::Body};
521 use opentelemetry::metrics::MeterProvider;
522 use serde_json::json;
523
524 impl Kanidm {
525 pub fn test() -> Self {
527 let mut e = Kanidm::new(
528 "test",
529 serde_json::from_value(json!({
530 "domain": "idm.example.com",
531 "replicaGroups": [
532 {
533 "name": "default",
534 "replicas": 1
535 }
536 ]
537 }))
538 .unwrap(),
539 );
540 e.meta_mut().namespace = Some("default".into());
541 e.meta_mut().finalizers = Some(vec![super::KANIDM_FINALIZER.to_string()]);
544 e
545 }
546
547 pub fn with_ingress(mut self) -> Self {
548 self.spec.ingress = Some(serde_json::from_value(json!({})).unwrap());
549 self
550 }
551
552 pub fn with_replicas(mut self, replicas: i32) -> Self {
554 self.spec.replica_groups[0].replicas = replicas;
555 self
556 }
557
558 pub fn needs_delete(mut self) -> Self {
560 use chrono::prelude::{DateTime, TimeZone, Utc};
561 let now: DateTime<Utc> = Utc.with_ymd_and_hms(2017, 4, 2, 12, 50, 32).unwrap();
562 use k8s_openapi::apimachinery::pkg::apis::meta::v1::Time;
563 self.meta_mut().deletion_timestamp = Some(Time(now));
564 self
565 }
566
567 pub fn with_status(mut self, status: KanidmStatus) -> Self {
569 self.status = Some(status);
570 self
571 }
572 }
573
574 type ApiServerHandle = tower_test::mock::Handle<Request<Body>, Response<Body>>;
576 pub struct ApiServerVerifier(ApiServerHandle);
577
578 pub enum Scenario {
580 Create(Kanidm),
581 CreateWithTwoReplicas(Kanidm),
582 CreateWithIngress(Kanidm),
583 CreateWithIngressWithTwoReplicas(Kanidm),
584 }
585
586 pub async fn timeout_after_1s(handle: tokio::task::JoinHandle<()>) {
587 tokio::time::timeout(std::time::Duration::from_secs(1), handle)
588 .await
589 .expect("timeout on mock apiserver")
590 .expect("scenario succeeded")
591 }
592
593 impl ApiServerVerifier {
594 pub fn run(self, scenario: Scenario) -> tokio::task::JoinHandle<()> {
605 tokio::spawn(async move {
606 match scenario {
608 Scenario::Create(kanidm) => {
609 self.handle_kanidm_status_patch(kanidm.clone())
610 .await
611 .unwrap()
612 .handle_statefulset_patch(kanidm.clone())
613 .await
614 .unwrap()
615 .handle_service_patch(kanidm.clone())
616 .await
617 }
618 Scenario::CreateWithTwoReplicas(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::CreateWithIngress(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 .unwrap()
638 .handle_ingress_patch(kanidm.clone())
639 .await
640 }
641 Scenario::CreateWithIngressWithTwoReplicas(kanidm) => {
642 self.handle_kanidm_status_patch(kanidm.clone())
643 .await
644 .unwrap()
645 .handle_statefulset_patch(kanidm.clone())
646 .await
647 .unwrap()
648 .handle_service_patch(kanidm.clone())
649 .await
650 .unwrap()
651 .handle_ingress_patch(kanidm.clone())
652 .await
653 }
654 }
655 .expect("scenario completed without errors");
656 })
657 }
658
659 async fn handle_kanidm_status_patch(mut self, kanidm: Kanidm) -> Result<Self> {
660 let (request, send) = self.0.next_request().await.expect("service not called");
661 assert_eq!(request.method(), http::Method::PATCH);
662 assert_eq!(
663 request.uri().to_string(),
664 format!(
665 "/apis/kaniop.rs/v1beta1/namespaces/default/kanidms/{}/status?&force=true&fieldManager=kanidms.kaniop.rs",
666 kanidm.name_any()
667 )
668 );
669
670 let req_body = request.into_body().collect_bytes().await.unwrap();
671 let json: serde_json::Value =
672 serde_json::from_slice(&req_body).expect("patch object is json");
673 let status: KanidmStatus = serde_json::from_value(json.get("status").unwrap().clone())
674 .expect("valid kanidm status");
675 let mut kanidm = Kanidm::test();
676 kanidm.status = Some(status.clone());
677 let response = serde_json::to_vec(&kanidm).unwrap();
678 send.send_response(Response::builder().body(Body::from(response)).unwrap());
680 Ok(self)
681 }
682
683 async fn handle_statefulset_patch(mut self, kanidm: Kanidm) -> Result<Self> {
684 for rg in kanidm.spec.replica_groups.iter() {
685 let (request, send) = self.0.next_request().await.expect("service not called");
686 assert_eq!(request.method(), http::Method::PATCH);
687 assert_eq!(
688 request.uri().to_string(),
689 format!(
690 "/apis/apps/v1/namespaces/default/statefulsets/{}?&force=true&fieldManager=kanidms.kaniop.rs",
691 kanidm.statefulset_name(&rg.name)
692 )
693 );
694 let req_body = request.into_body().collect_bytes().await.unwrap();
695 let json: serde_json::Value =
696 serde_json::from_slice(&req_body).expect("patch object is json");
697 let statefulset: StatefulSet =
698 serde_json::from_value(json).expect("valid statefulset");
699 assert_eq!(
700 statefulset.clone().spec.unwrap().replicas.unwrap(),
701 rg.replicas
702 );
703 let response = serde_json::to_vec(&statefulset).unwrap();
704 send.send_response(Response::builder().body(Body::from(response)).unwrap());
706 }
707
708 Ok(self)
709 }
710
711 async fn handle_service_patch(mut self, kanidm: Kanidm) -> Result<Self> {
712 let (request, send) = self.0.next_request().await.expect("service not called");
713 assert_eq!(request.method(), http::Method::PATCH);
714 assert_eq!(
715 request.uri().to_string(),
716 format!(
717 "/api/v1/namespaces/default/services/{}?&force=true&fieldManager=kanidms.kaniop.rs",
718 kanidm.name_any()
719 )
720 );
721
722 let req_body = request.into_body().collect_bytes().await.unwrap();
723 let json: serde_json::Value =
724 serde_json::from_slice(&req_body).expect("patch object is json");
725 let service: Service = serde_json::from_value(json).expect("valid service");
726 let response = serde_json::to_vec(&service).unwrap();
727 send.send_response(Response::builder().body(Body::from(response)).unwrap());
729 Ok(self)
730 }
731
732 async fn handle_ingress_patch(mut self, kanidm: Kanidm) -> Result<Self> {
733 let (request, send) = self.0.next_request().await.expect("service not called");
734 assert_eq!(request.method(), http::Method::PATCH);
735 assert_eq!(
736 request.uri().to_string(),
737 format!(
738 "/apis/networking.k8s.io/v1/namespaces/default/ingresses/{}?&force=true&fieldManager=kanidms.kaniop.rs",
739 kanidm.name_any()
740 )
741 );
742
743 let req_body = request.into_body().collect_bytes().await.unwrap();
744 let json: serde_json::Value =
745 serde_json::from_slice(&req_body).expect("patch object is json");
746 let ingress: Ingress = serde_json::from_value(json).expect("valid service");
747 let response = serde_json::to_vec(&ingress).unwrap();
748 send.send_response(Response::builder().body(Body::from(response)).unwrap());
750 Ok(self)
751 }
752 }
753
754 pub fn get_test_context() -> (Arc<Context>, ApiServerVerifier) {
755 let (mock_service, handle) = tower_test::mock::pair::<Request<Body>, Response<Body>>();
756 let mock_client = Client::new(mock_service, "default");
757 let stores = Stores {
758 stateful_set_store: Writer::default().as_reader(),
759 service_store: Writer::default().as_reader(),
760 ingress_store: Writer::default().as_reader(),
761 secret_store: Writer::default().as_reader(),
762 };
763 let controller_id = "test";
764
765 let provider = opentelemetry_sdk::metrics::SdkMeterProvider::builder().build();
767 let meter = provider.meter("test");
768 let metrics = crate::metrics::Metrics::new(&meter, &[controller_id]);
769
770 let state = State::new(
771 metrics,
772 Writer::default().as_reader(),
773 Writer::default().as_reader(),
774 None,
775 );
776 let ctx = Arc::new(Context::new(
777 state.to_context(mock_client, controller_id),
778 stores,
779 ));
780 (ctx, ApiServerVerifier(handle))
781 }
782
783 #[tokio::test]
784 async fn kanidm_create() {
785 let (testctx, fakeserver) = get_test_context();
786 let kanidm = Kanidm::test();
787 let mocksrv = fakeserver.run(Scenario::Create(kanidm.clone()));
788 reconcile_kanidm(Arc::new(kanidm), testctx)
789 .await
790 .expect("reconciler");
791 timeout_after_1s(mocksrv).await;
792 }
793
794 #[tokio::test]
795 async fn kanidm_create_with_two_replicas() {
796 let (testctx, fakeserver) = get_test_context();
797 let kanidm = Kanidm::test().with_replicas(2);
798 let mocksrv = fakeserver.run(Scenario::CreateWithTwoReplicas(kanidm.clone()));
799 reconcile_kanidm(Arc::new(kanidm), testctx)
800 .await
801 .expect("reconciler");
802 timeout_after_1s(mocksrv).await;
803 }
804
805 #[tokio::test]
806 async fn kanidm_create_with_ingress() {
807 let (testctx, fakeserver) = get_test_context();
808 let kanidm = Kanidm::test().with_ingress();
809 let mocksrv = fakeserver.run(Scenario::CreateWithIngress(kanidm.clone()));
810 reconcile_kanidm(Arc::new(kanidm), testctx)
811 .await
812 .expect("reconciler");
813 timeout_after_1s(mocksrv).await;
814 }
815
816 #[tokio::test]
817 async fn kanidm_create_with_ingress_with_two_replicas() {
818 let (testctx, fakeserver) = get_test_context();
819 let kanidm = Kanidm::test().with_ingress().with_replicas(2);
820 let mocksrv = fakeserver.run(Scenario::CreateWithIngressWithTwoReplicas(kanidm.clone()));
821 reconcile_kanidm(Arc::new(kanidm), testctx)
822 .await
823 .expect("reconciler");
824 timeout_after_1s(mocksrv).await;
825 }
826}