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