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)
310 .map(|i| kanidm.patch(&ctx, kanidm.create_replica_group_service(&rg.name, i)))
311 })
312 .collect::<TryJoinAll<_>>();
313
314 let deprecated_ingresses = {
315 let names = [
316 kanidm.spec.ingress.as_ref().map(|_| kanidm.name_any()),
317 kanidm.generate_region_ingress_name(),
318 ]
319 .into_iter()
320 .flatten()
321 .collect::<Vec<_>>();
322 ctx.stores
323 .ingress_store
324 .state()
325 .into_iter()
326 .filter(|ing| {
327 ing.namespace() == kanidm.namespace()
328 && !names.contains(&ing.name_any())
329 && ing.metadata.labels == Some(kanidm.generate_labels())
330 })
331 .collect::<Vec<_>>()
332 };
333 let ingress_delete_futures = deprecated_ingresses
334 .iter()
335 .map(|ing| kanidm.delete(&ctx, ing.as_ref()))
336 .collect::<TryJoinAll<_>>();
337
338 let ingress_futures = kanidm
339 .create_ingress()
340 .into_iter()
341 .chain(kanidm.create_region_ingress())
342 .map(|ingress| kanidm.patch(&ctx, ingress))
343 .collect::<TryJoinAll<_>>();
344
345 try_join!(
346 sts_delete_futures,
347 admin_secret_future,
348 replication_secret_futures,
349 sts_futures,
350 service_future,
351 rg_svcs_delete_futures,
352 rg_services_futures,
353 ingress_delete_futures,
354 ingress_futures
355 )?;
356 Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL))
357}
358
359async fn cleanup(kanidm: Arc<Kanidm>, ctx: Arc<Context>) -> Result<Action> {
360 debug!(msg = "cleanup");
361 ctx.kaniop_ctx.release_kanidm_clients(&kanidm).await;
362 Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL))
363}
364
365impl Kanidm {
366 pub async fn delete<K>(&self, ctx: &Context, resource: &K) -> Result<()>
368 where
369 K: Resource<Scope = NamespaceResourceScope>
370 + Serialize
371 + Clone
372 + std::fmt::Debug
373 + for<'de> Deserialize<'de>,
374 <K as kube::Resource>::DynamicType: Default,
375 <K as Resource>::Scope: std::marker::Sized,
376 {
377 self.kube_delete(
378 ctx.kaniop_ctx.client.clone(),
379 &ctx.kaniop_ctx.metrics,
380 resource,
381 )
382 .await
383 }
384
385 pub async fn patch<K>(&self, ctx: &Context, resource: K) -> Result<K>
386 where
387 K: Resource<Scope = NamespaceResourceScope>
388 + Serialize
389 + Clone
390 + std::fmt::Debug
391 + for<'de> Deserialize<'de>,
392 <K as kube::Resource>::DynamicType: Default,
393 <K as Resource>::Scope: std::marker::Sized,
394 {
395 self.kube_patch(
396 ctx.kaniop_ctx.client.clone(),
397 &ctx.kaniop_ctx.metrics,
398 resource,
399 KANIDM_OPERATOR_NAME,
400 )
401 .await
402 }
403
404 #[inline]
405 fn generate_resource_labels(&self) -> BTreeMap<String, String> {
406 LABELS
407 .clone()
408 .into_iter()
409 .chain([
410 (INSTANCE_LABEL.to_string(), self.name_any()),
411 (CLUSTER_LABEL.to_string(), self.name_any()),
412 ])
413 .collect()
414 }
415
416 #[inline]
417 fn generate_labels(&self) -> BTreeMap<String, String> {
418 self.generate_resource_labels()
419 .clone()
420 .into_iter()
421 .chain(self.labels().clone())
422 .collect()
423 }
424
425 #[inline]
426 fn get_tls_secret_name(&self) -> String {
427 format!("{}-tls", self.name_any())
428 }
429
430 #[inline]
431 fn get_namespace(&self) -> String {
432 self.namespace().unwrap()
434 }
435
436 #[inline]
437 fn is_replication_enabled(&self) -> bool {
438 self.spec.replica_groups.len() > 1
440 || self.spec.replica_groups.first().unwrap().replicas > 1
441 || !self.spec.external_replication_nodes.is_empty()
442 }
443
444 #[inline]
445 fn is_updatable(&self, status: &KanidmStatus) -> bool {
446 status
447 .version
448 .as_ref()
449 .map(|v| match v.upgrade_check_result {
450 KanidmUpgradeCheckResult::Passed => true,
451 KanidmUpgradeCheckResult::Failed => {
452 let current_tag = get_image_tag(&self.spec.image).unwrap_or_default();
453 if let (Some((major, minor, patch)), Some((v_major, v_minor, v_patch))) =
454 (parse_semver(¤t_tag), parse_semver(&v.image_tag))
455 {
456 major == v_major && minor == v_minor && patch >= v_patch
457 } else {
458 v.image_tag == current_tag
459 }
460 }
461 })
462 .unwrap_or(true)
463 }
464
465 async fn exec<I, T>(&self, ctx: Arc<Context>, pod_name: &str, command: I) -> Result<String>
466 where
467 I: IntoIterator<Item = T> + Debug,
468 T: Into<String>,
469 {
470 let namespace = &self.get_namespace();
471 trace!(
472 msg = "pod exec",
473 resource.name = &pod_name,
474 resource.namespace = &namespace,
475 ?command
476 );
477 let pod = Api::<Pod>::namespaced(ctx.kaniop_ctx.client.clone(), namespace);
478 let attached = pod
479 .exec(pod_name, command, &AttachParams::default())
480 .await
481 .map_err(|e| {
482 Error::KubeError(
483 format!("failed to exec pod {namespace}/{pod_name}"),
484 Box::new(e),
485 )
486 })?;
487 get_output(attached).await
488 }
489
490 async fn exec_any<I, T>(&self, ctx: Arc<Context>, command: I) -> Result<String>
491 where
492 I: IntoIterator<Item = T> + Debug,
493 T: Into<String>,
494 {
495 let sts_name = self.statefulset_name(&self.spec.replica_groups.first().unwrap().name);
498 let pod_name = format!("{sts_name}-0");
499 self.exec(ctx, &pod_name, command).await
500 }
501}
502
503#[cfg(test)]
504mod test {
505 use super::statefulset::StatefulSetExt;
506 use super::{Kanidm, reconcile_kanidm};
507
508 use crate::controller::State;
509 use crate::kanidm::controller::context::{Context, Stores};
510 use crate::kanidm::crd::KanidmStatus;
511
512 use kaniop_k8s_util::error::Result;
513
514 use std::sync::Arc;
515
516 use http::{Request, Response};
517 use k8s_openapi::api::apps::v1::StatefulSet;
518 use k8s_openapi::api::core::v1::Service;
519 use k8s_openapi::api::networking::v1::Ingress;
520 use kube::runtime::reflector::store::Writer;
521 use kube::{Client, Resource, ResourceExt, client::Body};
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 let state = State::new(
765 Default::default(),
766 &[controller_id],
767 Writer::default().as_reader(),
768 Writer::default().as_reader(),
769 None,
770 );
771 let ctx = Arc::new(Context::new(
772 state.to_context(mock_client, controller_id),
773 stores,
774 ));
775 (ctx, ApiServerVerifier(handle))
776 }
777
778 #[tokio::test]
779 async fn kanidm_create() {
780 let (testctx, fakeserver) = get_test_context();
781 let kanidm = Kanidm::test();
782 let mocksrv = fakeserver.run(Scenario::Create(kanidm.clone()));
783 reconcile_kanidm(Arc::new(kanidm), testctx)
784 .await
785 .expect("reconciler");
786 timeout_after_1s(mocksrv).await;
787 }
788
789 #[tokio::test]
790 async fn kanidm_create_with_two_replicas() {
791 let (testctx, fakeserver) = get_test_context();
792 let kanidm = Kanidm::test().with_replicas(2);
793 let mocksrv = fakeserver.run(Scenario::CreateWithTwoReplicas(kanidm.clone()));
794 reconcile_kanidm(Arc::new(kanidm), testctx)
795 .await
796 .expect("reconciler");
797 timeout_after_1s(mocksrv).await;
798 }
799
800 #[tokio::test]
801 async fn kanidm_create_with_ingress() {
802 let (testctx, fakeserver) = get_test_context();
803 let kanidm = Kanidm::test().with_ingress();
804 let mocksrv = fakeserver.run(Scenario::CreateWithIngress(kanidm.clone()));
805 reconcile_kanidm(Arc::new(kanidm), testctx)
806 .await
807 .expect("reconciler");
808 timeout_after_1s(mocksrv).await;
809 }
810
811 #[tokio::test]
812 async fn kanidm_create_with_ingress_with_two_replicas() {
813 let (testctx, fakeserver) = get_test_context();
814 let kanidm = Kanidm::test().with_ingress().with_replicas(2);
815 let mocksrv = fakeserver.run(Scenario::CreateWithIngressWithTwoReplicas(kanidm.clone()));
816 reconcile_kanidm(Arc::new(kanidm), testctx)
817 .await
818 .expect("reconciler");
819 timeout_after_1s(mocksrv).await;
820 }
821}