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 serde_json::json;
522
523 impl Kanidm {
524 pub fn test() -> Self {
526 let mut e = Kanidm::new(
527 "test",
528 serde_json::from_value(json!({
529 "domain": "idm.example.com",
530 "replicaGroups": [
531 {
532 "name": "default",
533 "replicas": 1
534 }
535 ]
536 }))
537 .unwrap(),
538 );
539 e.meta_mut().namespace = Some("default".into());
540 e.meta_mut().finalizers = Some(vec![super::KANIDM_FINALIZER.to_string()]);
543 e
544 }
545
546 pub fn with_ingress(mut self) -> Self {
547 self.spec.ingress = Some(serde_json::from_value(json!({})).unwrap());
548 self
549 }
550
551 pub fn with_replicas(mut self, replicas: i32) -> Self {
553 self.spec.replica_groups[0].replicas = replicas;
554 self
555 }
556
557 pub fn needs_delete(mut self) -> Self {
559 use chrono::prelude::{DateTime, TimeZone, Utc};
560 let now: DateTime<Utc> = Utc.with_ymd_and_hms(2017, 4, 2, 12, 50, 32).unwrap();
561 use k8s_openapi::apimachinery::pkg::apis::meta::v1::Time;
562 self.meta_mut().deletion_timestamp = Some(Time(now));
563 self
564 }
565
566 pub fn with_status(mut self, status: KanidmStatus) -> Self {
568 self.status = Some(status);
569 self
570 }
571 }
572
573 type ApiServerHandle = tower_test::mock::Handle<Request<Body>, Response<Body>>;
575 pub struct ApiServerVerifier(ApiServerHandle);
576
577 pub enum Scenario {
579 Create(Kanidm),
580 CreateWithTwoReplicas(Kanidm),
581 CreateWithIngress(Kanidm),
582 CreateWithIngressWithTwoReplicas(Kanidm),
583 }
584
585 pub async fn timeout_after_1s(handle: tokio::task::JoinHandle<()>) {
586 tokio::time::timeout(std::time::Duration::from_secs(1), handle)
587 .await
588 .expect("timeout on mock apiserver")
589 .expect("scenario succeeded")
590 }
591
592 impl ApiServerVerifier {
593 pub fn run(self, scenario: Scenario) -> tokio::task::JoinHandle<()> {
604 tokio::spawn(async move {
605 match scenario {
607 Scenario::Create(kanidm) => {
608 self.handle_kanidm_status_patch(kanidm.clone())
609 .await
610 .unwrap()
611 .handle_statefulset_patch(kanidm.clone())
612 .await
613 .unwrap()
614 .handle_service_patch(kanidm.clone())
615 .await
616 }
617 Scenario::CreateWithTwoReplicas(kanidm) => {
618 self.handle_kanidm_status_patch(kanidm.clone())
619 .await
620 .unwrap()
621 .handle_statefulset_patch(kanidm.clone())
622 .await
623 .unwrap()
624 .handle_service_patch(kanidm.clone())
625 .await
626 }
627 Scenario::CreateWithIngress(kanidm) => {
628 self.handle_kanidm_status_patch(kanidm.clone())
629 .await
630 .unwrap()
631 .handle_statefulset_patch(kanidm.clone())
632 .await
633 .unwrap()
634 .handle_service_patch(kanidm.clone())
635 .await
636 .unwrap()
637 .handle_ingress_patch(kanidm.clone())
638 .await
639 }
640 Scenario::CreateWithIngressWithTwoReplicas(kanidm) => {
641 self.handle_kanidm_status_patch(kanidm.clone())
642 .await
643 .unwrap()
644 .handle_statefulset_patch(kanidm.clone())
645 .await
646 .unwrap()
647 .handle_service_patch(kanidm.clone())
648 .await
649 .unwrap()
650 .handle_ingress_patch(kanidm.clone())
651 .await
652 }
653 }
654 .expect("scenario completed without errors");
655 })
656 }
657
658 async fn handle_kanidm_status_patch(mut self, kanidm: Kanidm) -> Result<Self> {
659 let (request, send) = self.0.next_request().await.expect("service not called");
660 assert_eq!(request.method(), http::Method::PATCH);
661 assert_eq!(
662 request.uri().to_string(),
663 format!(
664 "/apis/kaniop.rs/v1beta1/namespaces/default/kanidms/{}/status?&force=true&fieldManager=kanidms.kaniop.rs",
665 kanidm.name_any()
666 )
667 );
668
669 let req_body = request.into_body().collect_bytes().await.unwrap();
670 let json: serde_json::Value =
671 serde_json::from_slice(&req_body).expect("patch object is json");
672 let status: KanidmStatus = serde_json::from_value(json.get("status").unwrap().clone())
673 .expect("valid kanidm status");
674 let mut kanidm = Kanidm::test();
675 kanidm.status = Some(status.clone());
676 let response = serde_json::to_vec(&kanidm).unwrap();
677 send.send_response(Response::builder().body(Body::from(response)).unwrap());
679 Ok(self)
680 }
681
682 async fn handle_statefulset_patch(mut self, kanidm: Kanidm) -> Result<Self> {
683 for rg in kanidm.spec.replica_groups.iter() {
684 let (request, send) = self.0.next_request().await.expect("service not called");
685 assert_eq!(request.method(), http::Method::PATCH);
686 assert_eq!(
687 request.uri().to_string(),
688 format!(
689 "/apis/apps/v1/namespaces/default/statefulsets/{}?&force=true&fieldManager=kanidms.kaniop.rs",
690 kanidm.statefulset_name(&rg.name)
691 )
692 );
693 let req_body = request.into_body().collect_bytes().await.unwrap();
694 let json: serde_json::Value =
695 serde_json::from_slice(&req_body).expect("patch object is json");
696 let statefulset: StatefulSet =
697 serde_json::from_value(json).expect("valid statefulset");
698 assert_eq!(
699 statefulset.clone().spec.unwrap().replicas.unwrap(),
700 rg.replicas
701 );
702 let response = serde_json::to_vec(&statefulset).unwrap();
703 send.send_response(Response::builder().body(Body::from(response)).unwrap());
705 }
706
707 Ok(self)
708 }
709
710 async fn handle_service_patch(mut self, kanidm: Kanidm) -> Result<Self> {
711 let (request, send) = self.0.next_request().await.expect("service not called");
712 assert_eq!(request.method(), http::Method::PATCH);
713 assert_eq!(
714 request.uri().to_string(),
715 format!(
716 "/api/v1/namespaces/default/services/{}?&force=true&fieldManager=kanidms.kaniop.rs",
717 kanidm.name_any()
718 )
719 );
720
721 let req_body = request.into_body().collect_bytes().await.unwrap();
722 let json: serde_json::Value =
723 serde_json::from_slice(&req_body).expect("patch object is json");
724 let service: Service = serde_json::from_value(json).expect("valid service");
725 let response = serde_json::to_vec(&service).unwrap();
726 send.send_response(Response::builder().body(Body::from(response)).unwrap());
728 Ok(self)
729 }
730
731 async fn handle_ingress_patch(mut self, kanidm: Kanidm) -> Result<Self> {
732 let (request, send) = self.0.next_request().await.expect("service not called");
733 assert_eq!(request.method(), http::Method::PATCH);
734 assert_eq!(
735 request.uri().to_string(),
736 format!(
737 "/apis/networking.k8s.io/v1/namespaces/default/ingresses/{}?&force=true&fieldManager=kanidms.kaniop.rs",
738 kanidm.name_any()
739 )
740 );
741
742 let req_body = request.into_body().collect_bytes().await.unwrap();
743 let json: serde_json::Value =
744 serde_json::from_slice(&req_body).expect("patch object is json");
745 let ingress: Ingress = serde_json::from_value(json).expect("valid service");
746 let response = serde_json::to_vec(&ingress).unwrap();
747 send.send_response(Response::builder().body(Body::from(response)).unwrap());
749 Ok(self)
750 }
751 }
752
753 pub fn get_test_context() -> (Arc<Context>, ApiServerVerifier) {
754 let (mock_service, handle) = tower_test::mock::pair::<Request<Body>, Response<Body>>();
755 let mock_client = Client::new(mock_service, "default");
756 let stores = Stores {
757 stateful_set_store: Writer::default().as_reader(),
758 service_store: Writer::default().as_reader(),
759 ingress_store: Writer::default().as_reader(),
760 secret_store: Writer::default().as_reader(),
761 };
762 let controller_id = "test";
763 let state = State::new(
764 Default::default(),
765 &[controller_id],
766 Writer::default().as_reader(),
767 Writer::default().as_reader(),
768 None,
769 );
770 let ctx = Arc::new(Context::new(
771 state.to_context(mock_client, controller_id),
772 stores,
773 ));
774 (ctx, ApiServerVerifier(handle))
775 }
776
777 #[tokio::test]
778 async fn kanidm_create() {
779 let (testctx, fakeserver) = get_test_context();
780 let kanidm = Kanidm::test();
781 let mocksrv = fakeserver.run(Scenario::Create(kanidm.clone()));
782 reconcile_kanidm(Arc::new(kanidm), testctx)
783 .await
784 .expect("reconciler");
785 timeout_after_1s(mocksrv).await;
786 }
787
788 #[tokio::test]
789 async fn kanidm_create_with_two_replicas() {
790 let (testctx, fakeserver) = get_test_context();
791 let kanidm = Kanidm::test().with_replicas(2);
792 let mocksrv = fakeserver.run(Scenario::CreateWithTwoReplicas(kanidm.clone()));
793 reconcile_kanidm(Arc::new(kanidm), testctx)
794 .await
795 .expect("reconciler");
796 timeout_after_1s(mocksrv).await;
797 }
798
799 #[tokio::test]
800 async fn kanidm_create_with_ingress() {
801 let (testctx, fakeserver) = get_test_context();
802 let kanidm = Kanidm::test().with_ingress();
803 let mocksrv = fakeserver.run(Scenario::CreateWithIngress(kanidm.clone()));
804 reconcile_kanidm(Arc::new(kanidm), testctx)
805 .await
806 .expect("reconciler");
807 timeout_after_1s(mocksrv).await;
808 }
809
810 #[tokio::test]
811 async fn kanidm_create_with_ingress_with_two_replicas() {
812 let (testctx, fakeserver) = get_test_context();
813 let kanidm = Kanidm::test().with_ingress().with_replicas(2);
814 let mocksrv = fakeserver.run(Scenario::CreateWithIngressWithTwoReplicas(kanidm.clone()));
815 reconcile_kanidm(Arc::new(kanidm), testctx)
816 .await
817 .expect("reconciler");
818 timeout_after_1s(mocksrv).await;
819 }
820}