1use super::secret::{REPLICA_SECRET_KEY, SecretExt};
2use super::service::ServiceExt;
3use crate::kanidm::reconcile::transport::TransportSidecarConfig;
4
5use crate::controller::cluster_domain;
6use crate::kanidm::crd::{IpFamily, Kanidm, KanidmServerRole, ReplicaGroup, ReplicationType};
7
8use kaniop_backup_core::auth::{
9 AuthRole, build_auth_env_vars, build_auth_volume_mounts, build_auth_volumes,
10 build_ca_bundle_volume, build_ca_bundle_volume_mount, ca_bundle_env_var,
11};
12use kaniop_backup_core::image::data_mover_image;
13use kaniop_backup_core::pod_defaults::{default_resource_requirements, hardened_security_context};
14
15use kaniop_k8s_util::error::Result;
16use kaniop_k8s_util::resources::merge_containers;
17
18use std::collections::BTreeMap;
19
20use k8s_openapi::api::apps::v1::{StatefulSet, StatefulSetSpec};
21use k8s_openapi::api::core::v1::{
22 Container, ContainerPort, EmptyDirVolumeSource, EnvVar, EnvVarSource, HTTPGetAction,
23 ObjectFieldSelector, PersistentVolumeClaim, PodSpec, PodTemplateSpec, Probe, SecretKeySelector,
24 SecretVolumeSource, Volume, VolumeMount,
25};
26use k8s_openapi::apimachinery::pkg::apis::meta::v1::LabelSelector;
27use k8s_openapi::apimachinery::pkg::util::intstr::IntOrString;
28use kube::ResourceExt;
29use kube::api::{ObjectMeta, Resource};
30
31pub const REPLICA_GROUP_LABEL: &str = "kanidm.kaniop.rs/replica-group";
32pub const REPLICA_LABEL: &str = "kanidm.kaniop.rs/replica";
33pub const TLS_SECRET_HASH_ANNOTATION: &str = "kanidm.kaniop.rs/tls-secret-hash";
34pub const CONTAINER_REPLICATION_PORT: i32 = 8444;
35pub const CONTAINER_REPLICATION_PORT_NAME: &str = "replication";
36
37const REPLICATION_CONFIG_IMAGE: &str = "ghcr.io/rash-sh/rash:2.18.3";
39const REPLICATION_CONFIG_SCRIPT: &str = r#"
40- copy:
41 content: |
42 version = "2"
43
44 {% if env.KANIOP_BACKUP_ENABLED == "true" and env.POD_NAME == env.KANIDM_PRIMARY_NODE -%}
45 [online_backup]
46 path = "/data/backups"
47 schedule = "{{ env.KANIOP_BACKUP_SCHEDULE }}"
48 versions = {{ env.KANIOP_BACKUP_VERSIONS }}
49 {% endif -%}
50
51 {% if env.KANIOP_REPLICATION_ENABLED == "true" -%}
52 {% set pod_env = env.POD_NAME | upper | replace('-', '_') -%}
53 [replication]
54 origin = "repl://{{ env[pod_env + '_HOST'] }}:{{ env.REPLICATION_PORT }}"
55 bindaddress = "{{ env.BIND_ADDRESS }}:{{ env.REPLICATION_PORT }}"
56
57 {% for e in env -%}
58 {% if e is startingwith(env.KANIDM_NAME| upper | replace('-', '_')) -%}
59 {% if e == pod_env or e is endingwith("_TYPE") or
60 e + '_TYPE' not in env or env[e + '_TYPE'] == "" -%}
61 {% continue -%}
62 {% endif -%}
63 {% set replica = e | lower | replace('_', '-') -%}
64 [replication."repl://{{ env[e + '_HOST'] }}:{{ env.REPLICATION_PORT }}"]
65 {% set type = env[e + '_TYPE'] -%}
66 type = "{{ type }}"
67 {% if type == "mutual-pull" -%}
68 partner_cert = "{{ env[e] }}"
69 {% elif type == "pull" -%}
70 supplier_cert = "{{ env[e] }}"
71 {% else -%}
72 consumer_cert = "{{ env[e] }}"
73 {% endif -%}
74 {% if type != "allow-pull" -%}
75 {% if replica == env.KANIDM_PRIMARY_NODE -%}
76 automatic_refresh = true
77 {% else -%}
78 automatic_refresh = false
79 {% endif -%}
80 {% endif %}
81 {% elif e is startingwith("EXTERNAL_REPLICATION_NODE") -%}
82 {% if e + '_CERT' not in env or e is endingwith("_TYPE") or e is endingwith("_CERT") or e is endingwith("_AUTOMATIC_REFRESH") -%}
83 {% continue -%}
84 {% endif -%}
85 [replication."{{ env[e] }}"]
86 {% set type = env[e + '_TYPE'] -%}
87 type = "{{ type }}"
88 {% if type == "mutual-pull" -%}
89 partner_cert = "{{ env[e + '_CERT'] }}"
90 {% elif type == "pull" -%}
91 supplier_cert = "{{ env[e + '_CERT'] }}"
92 {% else -%}
93 consumer_cert = "{{ env[e + '_CERT'] }}"
94 {% endif -%}
95 {% if type != "allow-pull" -%}
96 automatic_refresh = {{ env[e + '_AUTOMATIC_REFRESH'] }}
97 {% endif %}
98 {% endif %}
99 {%- endfor -%}
100 {% endif -%}
101 dest: "{{ env.KANIDM_CONFIG_PATH }}"
102 mode: "0400"
103"#;
104const CONTAINER_HTTPS_PORT: i32 = 8443;
105const CONTAINER_LDAP_PORT: i32 = 3636;
106pub const KANIDM_CONFIG_PATH: &str = "/run/kanidm/server.toml";
107pub const KANIDM_BACKUP_PATH: &str = "/data/backups";
108const VOLUME_CONFIG_NAME: &str = "kanidm-config";
109const VOLUME_CONFIG_PATH: &str = "/run/kanidm";
110const VOLUME_DATA_NAME: &str = "kanidm-data";
111const VOLUME_DATA_PATH: &str = "/data";
112const VOLUME_TLS_NAME: &str = "kanidm-certs";
113const VOLUME_TLS_PATH: &str = "/etc/kanidm/tls";
114
115const IPV4_BIND_ADDRESS: &str = "0.0.0.0";
116const IPV6_BIND_ADDRESS: &str = "[::]";
117
118#[derive(Debug, Clone, PartialEq, Eq)]
119pub(super) enum StatefulSetApplyStrategy {
120 Apply,
121 Recreate { immutable_fields: Vec<&'static str> },
122}
123
124pub(super) fn preserve_defaulted_statefulset_fields(
135 desired: &mut StatefulSet,
136 current: &StatefulSet,
137) {
138 let Some(desired_spec) = desired.spec.as_mut() else {
139 return;
140 };
141
142 if desired_spec.pod_management_policy.is_none() {
143 desired_spec.pod_management_policy = Some("OrderedReady".to_string());
144 }
145
146 if let Some(templates) = desired_spec.volume_claim_templates.as_mut() {
147 if let Some(current_templates) = current
148 .spec
149 .as_ref()
150 .and_then(|s| s.volume_claim_templates.as_ref())
151 {
152 for template in templates.iter_mut() {
153 if let Some(spec) = template.spec.as_mut() {
154 if spec.storage_class_name.is_none()
158 && let Some(template_name) = template.metadata.name.as_deref()
159 && let Some(current_spec) = current_templates
160 .iter()
161 .find(|current| current.metadata.name.as_deref() == Some(template_name))
162 .and_then(|current| current.spec.as_ref())
163 {
164 spec.storage_class_name
165 .clone_from(¤t_spec.storage_class_name);
166 }
167 if spec.volume_mode.is_none() {
168 spec.volume_mode = Some("Filesystem".to_string());
169 }
170 }
171 }
172 } else {
173 for template in templates {
174 if let Some(spec) = template.spec.as_mut() {
175 if spec.volume_mode.is_none() {
176 spec.volume_mode = Some("Filesystem".to_string());
177 }
178 }
179 }
180 }
181 }
182}
183
184fn pod_management_policy(spec: &StatefulSetSpec) -> &str {
185 spec.pod_management_policy
186 .as_deref()
187 .unwrap_or("OrderedReady")
188}
189
190fn normalized_volume_claim_templates(spec: &StatefulSetSpec) -> Option<Vec<PersistentVolumeClaim>> {
191 let mut templates = spec.volume_claim_templates.clone();
192 if let Some(templates) = templates.as_mut() {
193 for template in templates {
194 if let Some(pvc_spec) = template.spec.as_mut()
195 && pvc_spec.volume_mode.is_none()
196 {
197 pvc_spec.volume_mode = Some("Filesystem".to_string());
198 }
199 }
200 }
201 templates
202}
203
204fn deletes_pvcs_when_deleted(spec: &StatefulSetSpec) -> bool {
205 spec.persistent_volume_claim_retention_policy
206 .as_ref()
207 .and_then(|policy| policy.when_deleted.as_deref())
208 == Some("Delete")
209}
210
211pub(super) fn classify_statefulset_change(
218 current: &StatefulSet,
219 desired: &StatefulSet,
220) -> StatefulSetApplyStrategy {
221 let (Some(current_spec), Some(desired_spec)) = (current.spec.as_ref(), desired.spec.as_ref())
222 else {
223 return StatefulSetApplyStrategy::Apply;
225 };
226
227 if normalized_volume_claim_templates(current_spec)
228 != normalized_volume_claim_templates(desired_spec)
229 {
230 return StatefulSetApplyStrategy::Apply;
231 }
232
233 let mut immutable_fields = Vec::new();
234 if current_spec.selector != desired_spec.selector {
235 immutable_fields.push("spec.selector");
236 }
237 if current_spec.service_name != desired_spec.service_name {
238 immutable_fields.push("spec.serviceName");
239 }
240 if pod_management_policy(current_spec) != pod_management_policy(desired_spec) {
241 immutable_fields.push("spec.podManagementPolicy");
242 }
243
244 if immutable_fields.is_empty() || deletes_pvcs_when_deleted(current_spec) {
245 StatefulSetApplyStrategy::Apply
246 } else {
247 StatefulSetApplyStrategy::Recreate { immutable_fields }
248 }
249}
250
251pub trait StatefulSetExt {
252 fn statefulset_name(&self, rg_name: &str) -> String;
253 fn pod_name(&self, rg_name: &str, i: i32) -> String;
254 fn pod_env_prefix(&self, pod_name: &str) -> String;
255
256 fn create_statefulset(
257 &self,
258 replica_group: &ReplicaGroup,
259 tls_secret_hash: Option<&str>,
260 transport_config: Option<&TransportSidecarConfig>,
261 ) -> Result<StatefulSet>;
262}
263
264impl StatefulSetExt for Kanidm {
265 #[inline]
266 fn statefulset_name(&self, rg_name: &str) -> String {
267 format!("{kanidm_name}-{rg_name}", kanidm_name = self.name_any())
268 }
269
270 #[inline]
271 fn pod_name(&self, rg_name: &str, i: i32) -> String {
272 format!("{}-{}", self.statefulset_name(rg_name), i)
273 }
274
275 #[inline]
276 fn pod_env_prefix(&self, pod_name: &str) -> String {
277 pod_name.to_uppercase().replace("-", "_")
278 }
279
280 fn create_statefulset(
281 &self,
282 replica_group: &ReplicaGroup,
283 tls_secret_hash: Option<&str>,
284 transport_config: Option<&TransportSidecarConfig>,
285 ) -> Result<StatefulSet> {
286 let pod_labels = self.generate_pod_labels(replica_group);
287 let labels = self.generate_sts_labels(&pod_labels);
288 let env = self.generate_env_vars(replica_group);
289 let init_containers = self.generate_init_containers(replica_group)?;
290 let ports = self.generate_container_ports();
291 let probe = self.generate_probe();
292 let volume_mounts = self.generate_volume_mounts();
293 let mut containers =
294 self.generate_containers(&env, &volume_mounts, &ports, &probe, replica_group)?;
295
296 if replica_group.primary_node {
297 if let Some(config) = transport_config {
298 let sidecar = self.build_transport_sidecar(config, replica_group)?;
299 containers.push(sidecar);
300 } else {
301 containers.retain(|c| c.name != super::transport::TRANSPORT_SIDECAR_NAME);
302 }
303 } else {
304 containers.retain(|c| c.name != super::transport::TRANSPORT_SIDECAR_NAME);
305 }
306
307 let dns_policy = self.generate_dns_policy();
308 let (mut volumes, volume_claim_templates) = self.generate_volumes();
309
310 if let Some(config) = transport_config {
311 let auth_volumes = build_auth_volumes(&config.auth_method);
312 volumes.extend(auth_volumes);
313 if let Some(ca_bundle_ref) = &config.ca_bundle_ref {
314 volumes.push(build_ca_bundle_volume(ca_bundle_ref));
315 }
316 if !volumes.iter().any(|v| v.name == "kanidm-tmp") {
317 volumes.push(Volume {
318 name: "kanidm-tmp".to_string(),
319 empty_dir: Some(EmptyDirVolumeSource::default()),
320 ..Volume::default()
321 });
322 }
323 }
324
325 Ok(StatefulSet {
326 metadata: self.generate_metadata(
327 &replica_group.name,
328 &replica_group.stateful_set_annotations,
329 &labels,
330 ),
331 spec: Some(StatefulSetSpec {
332 replicas: Some(replica_group.replicas),
333 selector: LabelSelector {
334 match_expressions: None,
335 match_labels: Some(pod_labels.clone()),
336 },
337 template: PodTemplateSpec {
338 metadata: Some(ObjectMeta {
339 labels: Some(pod_labels),
340 annotations: tls_secret_hash.map(|hash| {
341 BTreeMap::from([(
342 TLS_SECRET_HASH_ANNOTATION.to_string(),
343 hash.to_string(),
344 )])
345 }),
346 ..ObjectMeta::default()
347 }),
348 spec: Some(PodSpec {
349 containers,
350 volumes: Some(volumes),
351 node_selector: replica_group.node_selector.clone(),
352 affinity: replica_group.affinity.clone(),
353 tolerations: replica_group.tolerations.clone(),
354 topology_spread_constraints: replica_group
355 .topology_spread_constraints
356 .clone(),
357 security_context: self.spec.security_context.clone(),
358 dns_policy,
359 dns_config: self.spec.dns_config.clone(),
360 init_containers: Some(init_containers),
361 host_aliases: self.spec.host_aliases.clone(),
362 enable_service_links: Some(self.spec.enable_service_links),
363 automount_service_account_token: self.spec.automount_service_account_token,
364 host_users: self.spec.host_users,
365 runtime_class_name: self.spec.runtime_class_name.clone(),
366 ..PodSpec::default()
367 }),
368 },
369 service_name: Some(self.service_name()),
370 persistent_volume_claim_retention_policy: self
371 .spec
372 .persistent_volume_claim_retention_policy
373 .clone(),
374 min_ready_seconds: self.spec.min_ready_seconds,
375 volume_claim_templates,
376 ..StatefulSetSpec::default()
377 }),
378 ..StatefulSet::default()
379 })
380 }
381}
382
383impl Kanidm {
384 fn uses_generated_config(&self) -> bool {
385 self.is_replication_enabled() || self.spec.backup.is_some()
386 }
387
388 fn generate_pod_labels(&self, replica_group: &ReplicaGroup) -> BTreeMap<String, String> {
389 self.generate_resource_labels()
390 .into_iter()
391 .chain(std::iter::once((
392 REPLICA_GROUP_LABEL.to_string(),
393 replica_group.name.clone(),
394 )))
395 .collect()
396 }
397
398 fn generate_sts_labels(
399 &self,
400 pod_labels: &BTreeMap<String, String>,
401 ) -> BTreeMap<String, String> {
402 pod_labels.clone()
403 }
404
405 fn generate_env_vars(&self, replica_group: &ReplicaGroup) -> Vec<EnvVar> {
406 let origin = match self.spec.origin.clone() {
407 Some(o) => o,
408 None => format!("https://{}", self.spec.domain.clone()),
409 };
410 let bind_address = match self.spec.ip_family {
411 IpFamily::Ipv4 => IPV4_BIND_ADDRESS,
412 IpFamily::Ipv6 => IPV6_BIND_ADDRESS,
413 };
414
415 self.spec
416 .env
417 .clone()
418 .unwrap_or_default()
419 .into_iter()
420 .chain(vec![
421 EnvVar {
422 name: "KANIDM_DOMAIN".to_string(),
423 value: Some(self.spec.domain.clone()),
424 ..EnvVar::default()
425 },
426 EnvVar {
427 name: "KANIDM_ORIGIN".to_string(),
428 value: Some(origin),
429 ..EnvVar::default()
430 },
431 EnvVar {
432 name: "KANIDM_DB_PATH".to_string(),
433 value: Some(format!("{VOLUME_DATA_PATH}/kanidm.db")),
434 ..EnvVar::default()
435 },
436 EnvVar {
437 name: "KANIDM_TLS_CHAIN".to_string(),
438 value: Some(format!("{VOLUME_TLS_PATH}/tls.crt")),
439 ..EnvVar::default()
440 },
441 EnvVar {
442 name: "KANIDM_TLS_KEY".to_string(),
443 value: Some(format!("{VOLUME_TLS_PATH}/tls.key")),
444 ..EnvVar::default()
445 },
446 EnvVar {
447 name: "KANIDM_BINDADDRESS".to_string(),
448 value: Some(format!("{bind_address}:{CONTAINER_HTTPS_PORT}")),
449 ..EnvVar::default()
450 },
451 EnvVar {
452 name: "KANIDM_ROLE".to_string(),
453 value: Some(serde_plain::to_string(&replica_group.role.clone()).unwrap()),
454 ..EnvVar::default()
455 },
456 EnvVar {
457 name: "KANIDM_LOG_LEVEL".to_string(),
458 value: Some(serde_plain::to_string(&self.spec.log_level.clone()).unwrap()),
459 ..EnvVar::default()
460 },
461 ])
462 .chain(
463 self.spec
464 .ldap_port_name
465 .clone()
466 .into_iter()
467 .map(|_| EnvVar {
468 name: "KANIDM_LDAPBINDADDRESS".to_string(),
469 value: Some(format!("{bind_address}:{CONTAINER_LDAP_PORT}")),
470 ..EnvVar::default()
471 }),
472 )
473 .collect()
474 }
475
476 fn generate_config_volume_mount(&self) -> VolumeMount {
477 VolumeMount {
478 name: VOLUME_CONFIG_NAME.to_string(),
479 mount_path: VOLUME_CONFIG_PATH.to_string(),
480 read_only: Some(false),
481 ..VolumeMount::default()
482 }
483 }
484
485 fn generate_volume_mounts(&self) -> Vec<VolumeMount> {
486 self.spec
487 .volume_mounts
488 .clone()
489 .unwrap_or_default()
490 .into_iter()
491 .chain([
492 VolumeMount {
493 name: VOLUME_DATA_NAME.to_string(),
494 mount_path: VOLUME_DATA_PATH.to_string(),
495 ..VolumeMount::default()
496 },
497 VolumeMount {
498 name: VOLUME_TLS_NAME.to_string(),
499 mount_path: VOLUME_TLS_PATH.to_string(),
500 read_only: Some(true),
501 ..VolumeMount::default()
502 },
503 ])
504 .chain(
505 self.uses_generated_config()
506 .then(|| self.generate_config_volume_mount()),
507 )
508 .collect()
509 }
510
511 fn generate_init_containers(&self, replica_group: &ReplicaGroup) -> Result<Vec<Container>> {
512 if self.uses_generated_config() {
513 let external_replica_nodes_envs = self
514 .spec
515 .external_replication_nodes
516 .iter()
517 .flat_map(|ern| {
518 [
519 EnvVar {
520 name: format!("EXTERNAL_REPLICATION_NODE_{}", ern.name),
521 value: Some(format!(
522 "repl://{host}:{port}",
523 host = ern.hostname.clone(),
524 port = ern.port
525 )),
526 ..EnvVar::default()
527 },
528 EnvVar {
529 name: format!("EXTERNAL_REPLICATION_NODE_{}_CERT", ern.name),
530 value_from: Some(EnvVarSource {
531 secret_key_ref: Some(ern.certificate.clone()),
532 ..EnvVarSource::default()
533 }),
534 ..EnvVar::default()
535 },
536 EnvVar {
537 name: format!("EXTERNAL_REPLICATION_NODE_{}_TYPE", ern.name),
538 value: serde_plain::to_string(&ern._type).ok(),
539 ..EnvVar::default()
540 },
541 EnvVar {
542 name: format!(
543 "EXTERNAL_REPLICATION_NODE_{}_AUTOMATIC_REFRESH",
544 ern.name
545 ),
546 value: Some(ern.automatic_refresh.to_string()),
547 ..EnvVar::default()
548 },
549 ]
550 })
551 .collect::<Vec<EnvVar>>();
552 let replica_secrets_envs = self
553 .spec
554 .replica_groups
555 .iter()
556 .flat_map(|rg| {
557 (0..rg.replicas).flat_map(move |i| {
558 let pod_name = self.pod_name(&rg.name, i);
559 let pod_env_prefix = self.pod_env_prefix(&pod_name);
560 let pod_host = match rg
561 .services
562 .as_ref()
563 .and_then(|s| s.replication_hostname_template.as_ref())
564 {
565 Some(template) => template
566 .replace("{pod_name}", &pod_name)
567 .replace("{replica_index}", &i.to_string())
568 .replace("{domain}", &self.spec.domain),
569 None => format!(
570 "{pod_name}.{}.{}.svc.{}",
571 self.service_name(),
572 self.get_namespace(),
573 cluster_domain()
574 ),
575 };
576 [
577 EnvVar {
578 name: pod_env_prefix.clone(),
579 value_from: Some(EnvVarSource {
580 secret_key_ref: Some(SecretKeySelector {
581 name: self.replica_secret_name(&pod_name),
582 key: REPLICA_SECRET_KEY.to_string(),
583 optional: Some(true),
584 }),
585 ..EnvVarSource::default()
586 }),
587 ..EnvVar::default()
588 },
589 EnvVar {
590 name: format!("{pod_env_prefix}_TYPE"),
591 value: replication_type(
592 replica_group.role.clone(),
593 rg.role.clone(),
594 )
595 .and_then(|t| serde_plain::to_string(&t).ok()),
596 ..EnvVar::default()
597 },
598 EnvVar {
599 name: format!("{pod_env_prefix}_HOST"),
600 value: Some(pod_host),
601 ..EnvVar::default()
602 },
603 ]
604 })
605 })
606 .collect::<Vec<EnvVar>>();
607
608 let primary_node = self
609 .spec
610 .replica_groups
611 .iter()
612 .find(|rg| rg.primary_node)
613 .map(|rg| format!("{}-0", self.statefulset_name(&rg.name)));
614
615 let bind_address = match self.spec.ip_family {
616 IpFamily::Ipv4 => IPV4_BIND_ADDRESS,
617 IpFamily::Ipv6 => IPV6_BIND_ADDRESS,
618 };
619
620 let env = external_replica_nodes_envs
621 .into_iter()
622 .chain(replica_secrets_envs)
623 .chain([
624 EnvVar {
625 name: "POD_NAME".to_string(),
626 value_from: Some(EnvVarSource {
627 field_ref: Some(ObjectFieldSelector {
628 api_version: Some("v1".to_string()),
629 field_path: "metadata.name".to_string(),
630 }),
631 ..EnvVarSource::default()
632 }),
633 ..EnvVar::default()
634 },
635 EnvVar {
636 name: "REPLICATION_PORT".to_string(),
637 value: Some(CONTAINER_REPLICATION_PORT.to_string()),
638 ..EnvVar::default()
639 },
640 EnvVar {
641 name: "BIND_ADDRESS".to_string(),
642 value: Some(bind_address.to_string()),
643 ..EnvVar::default()
644 },
645 EnvVar {
646 name: "KANIDM_CONFIG_PATH".to_string(),
647 value: Some(KANIDM_CONFIG_PATH.to_string()),
648 ..EnvVar::default()
649 },
650 EnvVar {
651 name: "KANIDM_NAME".to_string(),
652 value: Some(self.name_any()),
653 ..EnvVar::default()
654 },
655 EnvVar {
656 name: "KANIOP_REPLICATION_ENABLED".to_string(),
657 value: Some(self.is_replication_enabled().to_string()),
658 ..EnvVar::default()
659 },
660 EnvVar {
661 name: "KANIOP_BACKUP_ENABLED".to_string(),
662 value: Some(self.spec.backup.is_some().to_string()),
663 ..EnvVar::default()
664 },
665 ])
666 .chain(self.spec.backup.as_ref().into_iter().flat_map(|backup| {
667 [
668 EnvVar {
669 name: "KANIOP_BACKUP_SCHEDULE".to_string(),
670 value: Some(backup.schedule.clone()),
671 ..EnvVar::default()
672 },
673 EnvVar {
674 name: "KANIOP_BACKUP_VERSIONS".to_string(),
675 value: Some(backup.versions.to_string()),
676 ..EnvVar::default()
677 },
678 ]
679 }))
680 .chain(primary_node.map(|pn| EnvVar {
681 name: "KANIDM_PRIMARY_NODE".to_string(),
682 value: Some(pn),
683 ..EnvVar::default()
684 }))
685 .collect::<Vec<EnvVar>>();
686
687 let init_container = Container {
688 name: "kanidm-generate-replication-config".to_string(),
689 image: Some(REPLICATION_CONFIG_IMAGE.to_string()),
690 env: Some(env),
691 args: Some(vec![
692 "--script".to_string(),
693 REPLICATION_CONFIG_SCRIPT.to_string(),
694 ]),
695 volume_mounts: Some(vec![self.generate_config_volume_mount()]),
696 ..Container::default()
697 };
698
699 merge_containers(self.spec.init_containers.clone(), &init_container)
700 } else {
701 let filtered_init_containers = self
705 .spec
706 .init_containers
707 .clone()
708 .unwrap_or_default()
709 .into_iter()
710 .filter(|container| container.name != "kanidm-generate-replication-config")
711 .collect();
712 Ok(filtered_init_containers)
713 }
714 }
715
716 fn generate_container_ports(&self) -> Vec<ContainerPort> {
717 std::iter::once(ContainerPort {
718 name: Some(self.spec.port_name.clone()),
719 container_port: CONTAINER_HTTPS_PORT,
720 ..ContainerPort::default()
721 })
722 .chain(
723 self.spec
724 .ldap_port_name
725 .clone()
726 .into_iter()
727 .map(|port_name| ContainerPort {
728 name: Some(port_name.clone()),
729 container_port: CONTAINER_LDAP_PORT,
730 ..ContainerPort::default()
731 }),
732 )
733 .chain(self.is_replication_enabled().then(|| ContainerPort {
734 name: Some(CONTAINER_REPLICATION_PORT_NAME.to_string()),
735 container_port: CONTAINER_REPLICATION_PORT,
736 ..ContainerPort::default()
737 }))
738 .collect()
739 }
740
741 fn generate_probe(&self) -> Probe {
742 Probe {
743 http_get: Some(HTTPGetAction {
744 path: Some("/status".to_string()),
745 port: IntOrString::String(self.spec.port_name.clone()),
746 scheme: Some("HTTPS".to_string()),
747 ..HTTPGetAction::default()
748 }),
749 ..Probe::default()
750 }
751 }
752
753 fn generate_containers(
754 &self,
755 env: &[EnvVar],
756 volume_mounts: &[VolumeMount],
757 ports: &[ContainerPort],
758 probe: &Probe,
759 replica_group: &ReplicaGroup,
760 ) -> Result<Vec<Container>> {
761 let command = vec!["kanidmd".to_string(), "server".to_string()]
762 .into_iter()
763 .chain(
764 self.uses_generated_config()
765 .then(|| vec!["-c".to_string(), KANIDM_CONFIG_PATH.to_string()])
766 .into_iter()
767 .flatten(),
768 )
769 .collect::<Vec<String>>();
770 let kanidm_container = Container {
771 name: "kanidm".to_string(),
772 image: Some(self.spec.image.clone()),
773 image_pull_policy: self.spec.image_pull_policy.clone(),
774 command: Some(command),
775 env: Some(env.to_owned()),
776 ports: Some(ports.to_owned()),
777 volume_mounts: Some(volume_mounts.to_owned()),
778 resources: replica_group.resources.clone(),
779 readiness_probe: Some(probe.clone()),
780 liveness_probe: Some(probe.clone()),
781 ..Container::default()
782 };
783
784 merge_containers(self.spec.containers.clone(), &kanidm_container)
785 }
786
787 fn generate_dns_policy(&self) -> Option<String> {
788 match self.spec.host_network {
789 Some(true) => Some("ClusterFirstWithHostNet".to_string()),
790 _ => self.spec.dns_policy.clone(),
791 }
792 }
793
794 fn generate_volumes(&self) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>) {
795 let secret_name = self.effective_tls_secret_name();
796
797 self.expand_storage(
798 self.spec
799 .volumes
800 .clone()
801 .unwrap_or_default()
802 .into_iter()
803 .chain(std::iter::once(Volume {
804 name: VOLUME_TLS_NAME.to_string(),
805 secret: Some(SecretVolumeSource {
806 secret_name: Some(secret_name),
807 default_mode: Some(0o400),
808 ..SecretVolumeSource::default()
809 }),
810 ..Volume::default()
811 }))
812 .chain(self.uses_generated_config().then(|| Volume {
813 name: VOLUME_CONFIG_NAME.to_string(),
814 empty_dir: Some(EmptyDirVolumeSource {
815 medium: None,
816 size_limit: None,
817 }),
818 ..Volume::default()
819 }))
820 .collect(),
821 )
822 }
823
824 fn expand_storage(
825 &self,
826 volumes: Vec<Volume>,
827 ) -> (Vec<Volume>, Option<Vec<PersistentVolumeClaim>>) {
828 let default_expand_storage = |volumes: Vec<Volume>| {
829 (
830 volumes
831 .into_iter()
832 .chain(std::iter::once(Volume {
833 name: VOLUME_DATA_NAME.to_string(),
834 empty_dir: Some(EmptyDirVolumeSource {
835 medium: None,
836 size_limit: None,
837 }),
838 ..Volume::default()
839 }))
840 .collect(),
841 None,
842 )
843 };
844
845 match self.spec.storage.clone() {
846 Some(storage) => {
847 if let Some(empty_dir) = storage.empty_dir {
848 (
849 volumes
850 .into_iter()
851 .chain(std::iter::once(Volume {
852 name: VOLUME_DATA_NAME.to_string(),
853 empty_dir: Some(empty_dir),
854 ..Volume::default()
855 }))
856 .collect(),
857 None,
858 )
859 } else if let Some(ephemeral) = storage.ephemeral {
860 (
861 volumes
862 .into_iter()
863 .chain(std::iter::once(Volume {
864 name: VOLUME_DATA_NAME.to_string(),
865 ephemeral: Some(ephemeral),
866 ..Volume::default()
867 }))
868 .collect(),
869 None,
870 )
871 } else if let Some(volume_claim_template) = storage.volume_claim_template {
872 let pvc = volume_claim_template.to_persistent_volume_claim();
873 let named_template = PersistentVolumeClaim {
874 metadata: ObjectMeta {
875 name: Some(VOLUME_DATA_NAME.to_string()),
876 ..pvc.metadata
877 },
878 spec: pvc.spec,
879 ..pvc
880 };
881 (volumes, Some(vec![named_template]))
882 } else {
883 default_expand_storage(volumes)
884 }
885 }
886 None => default_expand_storage(volumes),
887 }
888 }
889
890 fn generate_metadata(
891 &self,
892 replica_group_name: &str,
893 annotations: &Option<BTreeMap<String, String>>,
894 labels: &BTreeMap<String, String>,
895 ) -> ObjectMeta {
896 ObjectMeta {
897 name: Some(self.statefulset_name(replica_group_name)),
898 namespace: self.namespace(),
899 labels: Some(labels.clone()),
900 owner_references: self.controller_owner_ref(&()).map(|oref| vec![oref]),
901 annotations: annotations.clone(),
902 ..ObjectMeta::default()
903 }
904 }
905
906 fn build_transport_sidecar(
907 &self,
908 config: &TransportSidecarConfig,
909 replica_group: &ReplicaGroup,
910 ) -> Result<Container> {
911 let primary_node = format!("{}-0", self.statefulset_name(&replica_group.name));
912
913 let mut env_vars = vec![
914 EnvVar {
915 name: "POD_NAME".to_string(),
916 value_from: Some(EnvVarSource {
917 field_ref: Some(ObjectFieldSelector {
918 api_version: Some("v1".to_string()),
919 field_path: "metadata.name".to_string(),
920 }),
921 ..EnvVarSource::default()
922 }),
923 ..EnvVar::default()
924 },
925 EnvVar {
926 name: "KANIDM_PRIMARY_NODE".to_string(),
927 value: Some(primary_node),
928 ..EnvVar::default()
929 },
930 ];
931
932 let auth_env = build_auth_env_vars(&config.auth_method, &self.name_any(), AuthRole::Writer);
933 env_vars.extend(auth_env);
934
935 if config.ca_bundle_ref.is_some() {
936 env_vars.push(ca_bundle_env_var());
937 }
938
939 let mut volume_mounts = vec![
940 VolumeMount {
941 name: VOLUME_DATA_NAME.to_string(),
942 mount_path: VOLUME_DATA_PATH.to_string(),
943 read_only: Some(true),
944 ..VolumeMount::default()
945 },
946 VolumeMount {
947 name: "kanidm-tmp".to_string(),
948 mount_path: "/tmp".to_string(),
949 ..VolumeMount::default()
950 },
951 ];
952
953 let auth_mounts = build_auth_volume_mounts(&config.auth_method);
954 volume_mounts.extend(auth_mounts);
955
956 if config.ca_bundle_ref.is_some() {
957 volume_mounts.push(build_ca_bundle_volume_mount());
958 }
959
960 Ok(Container {
961 name: super::transport::TRANSPORT_SIDECAR_NAME.to_string(),
962 image: Some(data_mover_image()),
963 command: Some(vec!["/bin/kaniop-data-mover".to_string()]),
964 args: Some(vec![
965 "transport".to_string(),
966 "--operation-doc".to_string(),
967 config.operation_doc_json.clone(),
968 ]),
969 env: Some(env_vars),
970 volume_mounts: Some(volume_mounts),
971 security_context: Some(hardened_security_context()),
972 resources: Some(default_resource_requirements()),
973 ..Container::default()
974 })
975 }
976}
977
978fn replication_type(
979 source_role: KanidmServerRole,
980 target_role: KanidmServerRole,
981) -> Option<ReplicationType> {
982 match (source_role, target_role) {
983 (
984 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUi,
985 KanidmServerRole::WriteReplicaNoUi | KanidmServerRole::WriteReplica,
986 ) => Some(ReplicationType::MutualPull),
987
988 (
989 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUi,
990 KanidmServerRole::ReadOnlyReplica,
991 ) => Some(ReplicationType::AllowPull),
992 (
993 KanidmServerRole::ReadOnlyReplica,
994 KanidmServerRole::WriteReplica | KanidmServerRole::WriteReplicaNoUi,
995 ) => Some(ReplicationType::Pull),
996 (KanidmServerRole::ReadOnlyReplica, KanidmServerRole::ReadOnlyReplica) => None,
997 }
998}
999
1000#[cfg(test)]
1001mod tests {
1002 use super::{
1003 StatefulSetApplyStrategy, StatefulSetExt, TLS_SECRET_HASH_ANNOTATION,
1004 classify_statefulset_change, preserve_defaulted_statefulset_fields,
1005 };
1006 use crate::kanidm::crd::{
1007 Kanidm, KanidmSpec, KanidmStorage, PersistentVolumeClaimTemplate, ReplicaGroup,
1008 };
1009 use k8s_openapi::api::apps::v1::{
1010 StatefulSet, StatefulSetPersistentVolumeClaimRetentionPolicy,
1011 };
1012 use k8s_openapi::api::core::v1::{
1013 EmptyDirVolumeSource, EphemeralVolumeSource, PersistentVolumeClaim,
1014 PersistentVolumeClaimSpec, Volume,
1015 };
1016 use kube::api::ObjectMeta;
1017
1018 fn create_kanidm_with_storage(storage: Option<KanidmStorage>) -> Kanidm {
1019 Kanidm {
1020 spec: KanidmSpec {
1021 storage,
1022 ..Default::default()
1023 },
1024 ..Default::default()
1025 }
1026 }
1027
1028 pub(super) fn create_kanidm_with_replica_group() -> (Kanidm, ReplicaGroup) {
1029 let replica_group = ReplicaGroup {
1030 name: "default".to_string(),
1031 replicas: 1,
1032 ..Default::default()
1033 };
1034 let kanidm = Kanidm {
1035 metadata: ObjectMeta {
1036 name: Some("test".to_string()),
1037 namespace: Some("default".to_string()),
1038 ..Default::default()
1039 },
1040 spec: KanidmSpec {
1041 domain: "idm.example.com".to_string(),
1042 replica_groups: vec![replica_group.clone()],
1043 ..Default::default()
1044 },
1045 ..Default::default()
1046 };
1047 (kanidm, replica_group)
1048 }
1049
1050 #[test]
1051 fn test_create_statefulset_with_tls_secret_hash_annotation() {
1052 let (kanidm, replica_group) = create_kanidm_with_replica_group();
1053 let sts = kanidm
1054 .create_statefulset(&replica_group, Some("abc123"), None)
1055 .unwrap();
1056
1057 let annotations = sts
1058 .spec
1059 .unwrap()
1060 .template
1061 .metadata
1062 .unwrap()
1063 .annotations
1064 .unwrap();
1065 assert_eq!(
1066 annotations.get(TLS_SECRET_HASH_ANNOTATION),
1067 Some(&"abc123".to_string())
1068 );
1069 }
1070
1071 #[test]
1072 fn test_create_statefulset_without_tls_secret_hash_annotation() {
1073 let (kanidm, replica_group) = create_kanidm_with_replica_group();
1074 let sts = kanidm
1075 .create_statefulset(&replica_group, None, None)
1076 .unwrap();
1077
1078 let annotations = sts.spec.unwrap().template.metadata.unwrap().annotations;
1079 assert!(annotations.is_none());
1080 }
1081
1082 #[test]
1083 fn test_generate_volumes_without_storage() {
1084 let kanidm = create_kanidm_with_storage(None);
1085 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1086
1087 assert_eq!(volumes.clone().len(), 1);
1088 assert_eq!(volumes.clone().first().unwrap().name, "kanidm-data");
1089 assert!(volumes.first().unwrap().empty_dir.is_some());
1090 assert!(volume_claim_template.is_none());
1091 }
1092
1093 fn generated_statefulset() -> StatefulSet {
1094 let (kanidm, replica_group) = create_kanidm_with_replica_group();
1095 kanidm
1096 .create_statefulset(&replica_group, None, None)
1097 .unwrap()
1098 }
1099
1100 #[test]
1101 fn statefulset_mutable_change_uses_apply() {
1102 let current = generated_statefulset();
1103 let mut desired = current.clone();
1104 desired.spec.as_mut().unwrap().replicas = Some(2);
1105
1106 assert_eq!(
1107 classify_statefulset_change(¤t, &desired),
1108 StatefulSetApplyStrategy::Apply
1109 );
1110 }
1111
1112 #[test]
1113 fn statefulset_selector_change_requires_recreation() {
1114 let current = generated_statefulset();
1115 let mut desired = current.clone();
1116 desired
1117 .spec
1118 .as_mut()
1119 .unwrap()
1120 .selector
1121 .match_labels
1122 .get_or_insert_default()
1123 .insert("immutable".to_string(), "changed".to_string());
1124
1125 assert_eq!(
1126 classify_statefulset_change(¤t, &desired),
1127 StatefulSetApplyStrategy::Recreate {
1128 immutable_fields: vec!["spec.selector"]
1129 }
1130 );
1131 }
1132
1133 #[test]
1134 fn statefulset_service_name_change_requires_recreation() {
1135 let current = generated_statefulset();
1136 let mut desired = current.clone();
1137 desired.spec.as_mut().unwrap().service_name = Some("different".to_string());
1138
1139 assert_eq!(
1140 classify_statefulset_change(¤t, &desired),
1141 StatefulSetApplyStrategy::Recreate {
1142 immutable_fields: vec!["spec.serviceName"]
1143 }
1144 );
1145 }
1146
1147 #[test]
1148 fn statefulset_pod_management_default_does_not_recreate() {
1149 let mut current = generated_statefulset();
1150 current.spec.as_mut().unwrap().pod_management_policy = Some("OrderedReady".to_string());
1151 let mut desired = generated_statefulset();
1152 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1153
1154 assert_eq!(
1155 classify_statefulset_change(¤t, &desired),
1156 StatefulSetApplyStrategy::Apply
1157 );
1158 }
1159
1160 #[test]
1161 fn statefulset_non_default_pod_management_policy_requires_recreation() {
1162 let mut current = generated_statefulset();
1163 current.spec.as_mut().unwrap().pod_management_policy = Some("Parallel".to_string());
1164 let mut desired = generated_statefulset();
1165 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1166
1167 assert_eq!(
1168 classify_statefulset_change(¤t, &desired),
1169 StatefulSetApplyStrategy::Recreate {
1170 immutable_fields: vec!["spec.podManagementPolicy"]
1171 }
1172 );
1173 }
1174
1175 #[test]
1176 fn statefulset_volume_claim_template_change_is_non_destructive() {
1177 let mut current = generated_statefulset();
1178 current.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1179 metadata: ObjectMeta {
1180 name: Some("kanidm-data".to_string()),
1181 ..Default::default()
1182 },
1183 spec: Some(PersistentVolumeClaimSpec {
1184 storage_class_name: Some("old".to_string()),
1185 ..Default::default()
1186 }),
1187 ..Default::default()
1188 }]);
1189 let mut desired = current.clone();
1190 desired
1191 .spec
1192 .as_mut()
1193 .unwrap()
1194 .volume_claim_templates
1195 .as_mut()
1196 .unwrap()[0]
1197 .spec
1198 .as_mut()
1199 .unwrap()
1200 .storage_class_name = Some("new".to_string());
1201
1202 assert_eq!(
1203 classify_statefulset_change(¤t, &desired),
1204 StatefulSetApplyStrategy::Apply
1205 );
1206 }
1207
1208 #[test]
1209 fn statefulset_storage_class_defaulting_preserves_live_value() {
1210 let mut current = generated_statefulset();
1211 current.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1212 metadata: ObjectMeta {
1213 name: Some("kanidm-data".to_string()),
1214 ..Default::default()
1215 },
1216 spec: Some(PersistentVolumeClaimSpec {
1217 storage_class_name: Some("fast".to_string()),
1218 ..Default::default()
1219 }),
1220 ..Default::default()
1221 }]);
1222 let mut desired = current.clone();
1223 desired
1224 .spec
1225 .as_mut()
1226 .unwrap()
1227 .volume_claim_templates
1228 .as_mut()
1229 .unwrap()[0]
1230 .spec
1231 .as_mut()
1232 .unwrap()
1233 .storage_class_name = None;
1234 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1235
1236 assert_eq!(
1239 desired
1240 .spec
1241 .as_ref()
1242 .unwrap()
1243 .volume_claim_templates
1244 .as_ref()
1245 .unwrap()[0]
1246 .spec
1247 .as_ref()
1248 .unwrap()
1249 .storage_class_name,
1250 Some("fast".to_string())
1251 );
1252 assert_eq!(
1253 classify_statefulset_change(¤t, &desired),
1254 StatefulSetApplyStrategy::Apply
1255 );
1256 }
1257
1258 #[test]
1259 fn statefulset_server_defaults_do_not_require_recreation() {
1260 let mut desired = generated_statefulset();
1261 desired.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1262 metadata: ObjectMeta {
1263 name: Some("kanidm-data".to_string()),
1264 ..Default::default()
1265 },
1266 spec: Some(PersistentVolumeClaimSpec::default()),
1267 ..Default::default()
1268 }]);
1269 let mut current = desired.clone();
1270 let current_spec = current.spec.as_mut().unwrap();
1271 current_spec.pod_management_policy = Some("OrderedReady".to_string());
1272 current_spec.volume_claim_templates.as_mut().unwrap()[0]
1273 .spec
1274 .as_mut()
1275 .unwrap()
1276 .volume_mode = Some("Filesystem".to_string());
1277
1278 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1279
1280 assert_eq!(
1281 classify_statefulset_change(¤t, &desired),
1282 StatefulSetApplyStrategy::Apply
1283 );
1284 }
1285
1286 #[test]
1287 fn statefulset_delete_retention_blocks_automatic_recreation() {
1288 let mut current = generated_statefulset();
1289 current
1290 .spec
1291 .as_mut()
1292 .unwrap()
1293 .persistent_volume_claim_retention_policy =
1294 Some(StatefulSetPersistentVolumeClaimRetentionPolicy {
1295 when_deleted: Some("Delete".to_string()),
1296 when_scaled: None,
1297 });
1298 let mut desired = current.clone();
1299 desired
1300 .spec
1301 .as_mut()
1302 .unwrap()
1303 .selector
1304 .match_labels
1305 .get_or_insert_default()
1306 .insert("immutable".to_string(), "changed".to_string());
1307
1308 assert_eq!(
1309 classify_statefulset_change(¤t, &desired),
1310 StatefulSetApplyStrategy::Apply
1311 );
1312 }
1313
1314 #[test]
1315 fn test_generate_volumes_with_emptydir() {
1316 let storage = Some(KanidmStorage {
1317 empty_dir: Some(EmptyDirVolumeSource::default()),
1318 ..Default::default()
1319 });
1320 let kanidm = create_kanidm_with_storage(storage);
1321 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1322
1323 assert_eq!(volumes.clone().len(), 1);
1324 assert!(
1325 volumes
1326 .iter()
1327 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1328 );
1329 assert!(volume_claim_template.is_none());
1330 }
1331
1332 #[test]
1333 fn test_generate_volumes_with_emptydir_and_ephemeral() {
1334 let storage = Some(KanidmStorage {
1335 empty_dir: Some(EmptyDirVolumeSource::default()),
1336 ephemeral: Some(EphemeralVolumeSource::default()),
1337 ..Default::default()
1338 });
1339 let kanidm = create_kanidm_with_storage(storage);
1340 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1341
1342 assert_eq!(volumes.clone().len(), 1);
1343 assert!(
1344 volumes
1345 .iter()
1346 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1347 );
1348 assert!(volume_claim_template.is_none());
1349 }
1350
1351 #[test]
1352 fn test_generate_volumes_with_emptydir_ephemeral_and_volumeclaimtemplate() {
1353 let storage = Some(KanidmStorage {
1354 empty_dir: Some(EmptyDirVolumeSource::default()),
1355 ephemeral: Some(EphemeralVolumeSource::default()),
1356 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
1357 });
1358 let kanidm = create_kanidm_with_storage(storage);
1359 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1360
1361 assert_eq!(volumes.len(), 1);
1362 assert!(
1363 volumes
1364 .iter()
1365 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1366 );
1367 assert!(volume_claim_template.is_none());
1368 }
1369
1370 #[test]
1371 fn test_generate_volumes_with_ephemeral() {
1372 let storage = Some(KanidmStorage {
1373 ephemeral: Some(EphemeralVolumeSource::default()),
1374 ..Default::default()
1375 });
1376 let kanidm = create_kanidm_with_storage(storage);
1377 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1378
1379 assert_eq!(volumes.len(), 1);
1380 assert!(
1381 volumes
1382 .iter()
1383 .any(|v| v.name == "kanidm-data" && v.ephemeral.is_some())
1384 );
1385 assert!(volume_claim_template.is_none());
1386 }
1387
1388 #[test]
1389 fn test_generate_volumes_with_ephemeral_and_volumeclaimtemplate() {
1390 let storage = Some(KanidmStorage {
1391 ephemeral: Some(EphemeralVolumeSource::default()),
1392 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
1393 ..Default::default()
1394 });
1395 let kanidm = create_kanidm_with_storage(storage);
1396 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1397
1398 assert_eq!(volumes.len(), 1);
1399 assert!(
1400 volumes
1401 .iter()
1402 .any(|v| v.name == "kanidm-data" && v.ephemeral.is_some())
1403 );
1404 assert!(volume_claim_template.is_none());
1405 }
1406
1407 #[test]
1408 fn test_generate_volumes_with_volumeclaimtemplate() {
1409 let storage = Some(KanidmStorage {
1410 volume_claim_template: Some(PersistentVolumeClaimTemplate::default()),
1411 ..Default::default()
1412 });
1413 let kanidm = create_kanidm_with_storage(storage);
1414 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![]);
1415
1416 assert!(volumes.is_empty());
1417 assert!(volume_claim_template.is_some());
1418 }
1419
1420 #[test]
1421 fn test_generate_volumes_with_existing_volumes() {
1422 let existing_volume = Volume {
1423 name: "existing-volume".to_string(),
1424 ..Volume::default()
1425 };
1426 let kanidm = create_kanidm_with_storage(None);
1427 let (volumes, volume_claim_template) = kanidm.expand_storage(vec![existing_volume.clone()]);
1428
1429 assert_eq!(volumes.len(), 2);
1430 assert!(volumes.clone().iter().any(|v| v.name == "existing-volume"));
1431 assert!(
1432 volumes
1433 .iter()
1434 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1435 );
1436 assert!(volume_claim_template.is_none());
1437 }
1438
1439 #[test]
1440 fn test_generate_volumes_with_multiple_existing_volumes() {
1441 let existing_volume1 = Volume {
1442 name: "existing-volume-1".to_string(),
1443 ..Volume::default()
1444 };
1445 let existing_volume2 = Volume {
1446 name: "existing-volume-2".to_string(),
1447 ..Volume::default()
1448 };
1449 let kanidm = create_kanidm_with_storage(None);
1450 let (volumes, volume_claim_template) =
1451 kanidm.expand_storage(vec![existing_volume1.clone(), existing_volume2.clone()]);
1452
1453 assert_eq!(volumes.len(), 3);
1454 assert!(
1455 volumes
1456 .clone()
1457 .iter()
1458 .any(|v| v.name == "existing-volume-1")
1459 );
1460 assert!(
1461 volumes
1462 .clone()
1463 .iter()
1464 .any(|v| v.name == "existing-volume-2")
1465 );
1466 assert!(
1467 volumes
1468 .iter()
1469 .any(|v| v.name == "kanidm-data" && v.empty_dir.is_some())
1470 );
1471 assert!(volume_claim_template.is_none());
1472 }
1473
1474 #[test]
1475 fn statefulset_storage_class_omission_preserves_live() {
1476 let mut current = generated_statefulset();
1477 current.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1478 metadata: ObjectMeta {
1479 name: Some("kanidm-data".to_string()),
1480 ..Default::default()
1481 },
1482 spec: Some(PersistentVolumeClaimSpec {
1483 storage_class_name: Some("standard".to_string()),
1484 ..Default::default()
1485 }),
1486 ..Default::default()
1487 }]);
1488 let mut desired = generated_statefulset();
1489 desired.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1490 metadata: ObjectMeta {
1491 name: Some("kanidm-data".to_string()),
1492 ..Default::default()
1493 },
1494 spec: Some(PersistentVolumeClaimSpec {
1495 storage_class_name: None,
1496 ..Default::default()
1497 }),
1498 ..Default::default()
1499 }]);
1500 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1501
1502 assert_eq!(
1504 desired
1505 .spec
1506 .as_ref()
1507 .unwrap()
1508 .volume_claim_templates
1509 .as_ref()
1510 .unwrap()[0]
1511 .spec
1512 .as_ref()
1513 .unwrap()
1514 .storage_class_name,
1515 Some("standard".to_string())
1516 );
1517 }
1518
1519 #[test]
1520 fn statefulset_storage_class_explicit_non_null_desired_is_preserved() {
1521 let mut current = generated_statefulset();
1522 current.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1523 metadata: ObjectMeta {
1524 name: Some("kanidm-data".to_string()),
1525 ..Default::default()
1526 },
1527 spec: Some(PersistentVolumeClaimSpec {
1528 storage_class_name: Some("old".to_string()),
1529 ..Default::default()
1530 }),
1531 ..Default::default()
1532 }]);
1533 let mut desired = generated_statefulset();
1534 desired.spec.as_mut().unwrap().volume_claim_templates = Some(vec![PersistentVolumeClaim {
1535 metadata: ObjectMeta {
1536 name: Some("kanidm-data".to_string()),
1537 ..Default::default()
1538 },
1539 spec: Some(PersistentVolumeClaimSpec {
1540 storage_class_name: Some("new".to_string()),
1541 ..Default::default()
1542 }),
1543 ..Default::default()
1544 }]);
1545 preserve_defaulted_statefulset_fields(&mut desired, ¤t);
1547
1548 assert_eq!(
1550 desired
1551 .spec
1552 .as_ref()
1553 .unwrap()
1554 .volume_claim_templates
1555 .as_ref()
1556 .unwrap()[0]
1557 .spec
1558 .as_ref()
1559 .unwrap()
1560 .storage_class_name,
1561 Some("new".to_string())
1562 );
1563 }
1564}
1565
1566#[cfg(all(test, feature = "integration-test"))]
1567mod integration_test {
1568 use super::{REPLICATION_CONFIG_IMAGE, REPLICATION_CONFIG_SCRIPT};
1569
1570 use std::fs;
1571 use std::path::Path;
1572
1573 use tempfile::tempdir;
1574 use testcontainers::ContainerRequest;
1575 use testcontainers::GenericImage;
1576 use testcontainers::ImageExt;
1577 use testcontainers::core::Mount;
1578 use testcontainers::runners::AsyncRunner;
1579 use tokio::io::{AsyncBufReadExt, BufReader};
1580
1581 struct TestCase<'a> {
1582 env_vars: Vec<(&'a str, &'a str)>,
1583 expected_result: &'a str,
1584 }
1585
1586 async fn run_test_case(
1587 image_parts: &[&str],
1588 cmd: &[&str],
1589 tmp_dir_path: &str,
1590 env_vars: &[(&str, &str)],
1591 expected_result: &str,
1592 ) {
1593 let container = GenericImage::new(image_parts[0], image_parts[1]);
1594 let mut container_request: ContainerRequest<GenericImage> = container.clone().into();
1595
1596 for (key, value) in env_vars {
1597 container_request =
1598 container_request.with_env_var((*key).to_string(), (*value).to_string());
1599 }
1600
1601 let container = container_request
1602 .with_cmd(cmd.iter().map(|&s| s.to_string()))
1603 .with_mount(Mount::bind_mount(tmp_dir_path.to_string(), "/tmp"))
1604 .with_user(nix::unistd::getuid().to_string())
1605 .start()
1606 .await
1607 .unwrap();
1608
1609 let stdout = container.stdout(true);
1610 let mut stdout_reader = BufReader::new(stdout).lines();
1611 let mut stdout_lines = Vec::new();
1612 while let Some(l) = stdout_reader.next_line().await.unwrap() {
1613 stdout_lines.push(l);
1614 }
1615 dbg!(stdout_lines.join("\n"));
1616
1617 let stderr = container.stderr(true);
1618 let mut stderr_reader = BufReader::new(stderr).lines();
1619 let mut stderr_lines = Vec::new();
1620 while let Some(l) = stderr_reader.next_line().await.unwrap() {
1621 stderr_lines.push(l);
1622 }
1623 dbg!(stderr_lines.join("\n"));
1624
1625 let server_toml_path = Path::new(tmp_dir_path).join("server.toml");
1626 let content = fs::read_to_string(server_toml_path).expect("Unable to read server.toml");
1627 assert_eq!(content, expected_result);
1628 }
1629
1630 #[tokio::test]
1631 async fn test_replication_config_generation() {
1632 let image_parts = REPLICATION_CONFIG_IMAGE.split(':').collect::<Vec<&str>>();
1633 let cmd = ["--script", REPLICATION_CONFIG_SCRIPT];
1634 let tmp_dir = tempdir().unwrap();
1635 let tmp_dir_path = tmp_dir.path().to_str().unwrap().to_string();
1636
1637 let test_cases = vec![
1638 TestCase {
1639 env_vars: vec![
1640 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1641 ("REPLICATION_PORT", "8444"),
1642 ("BIND_ADDRESS", "0.0.0.0"),
1643 ("KANIDM_NAME", "kanidm-test"),
1644 ("POD_NAME", "kanidm-test-default-0"),
1645 ("KANIOP_REPLICATION_ENABLED", "true"),
1646 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1647 (
1648 "KANIDM_TEST_DEFAULT_0_HOST",
1649 "kanidm-test-default-0.kanidm-test",
1650 ),
1651 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1652 (
1653 "KANIDM_TEST_DEFAULT_1_HOST",
1654 "kanidm-test-default-1.kanidm-test",
1655 ),
1656 ],
1657 expected_result: r#"version = "2"
1658
1659[replication]
1660origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1661bindaddress = "0.0.0.0:8444"
1662
1663"#,
1664 },
1665 TestCase {
1666 env_vars: vec![
1667 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1668 ("REPLICATION_PORT", "8444"),
1669 ("BIND_ADDRESS", "0.0.0.0"),
1670 ("KANIDM_NAME", "kanidm-test"),
1671 ("POD_NAME", "kanidm-test-default-0"),
1672 ("KANIOP_REPLICATION_ENABLED", "true"),
1673 (
1674 "EXTERNAL_REPLICATION_NODE_HOST_0",
1675 "repl://external-host-0:8444",
1676 ),
1677 (
1678 "EXTERNAL_REPLICATION_NODE_HOST_0_CERT",
1679 "dummy-cert-external-host-0",
1680 ),
1681 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
1682 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
1683 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1684 (
1685 "KANIDM_TEST_DEFAULT_0_HOST",
1686 "kanidm-test-default-0.kanidm-test",
1687 ),
1688 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1689 (
1690 "KANIDM_TEST_DEFAULT_1_HOST",
1691 "kanidm-test-default-1.kanidm-test",
1692 ),
1693 ],
1694 expected_result: r#"version = "2"
1695
1696[replication]
1697origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1698bindaddress = "0.0.0.0:8444"
1699
1700[replication."repl://external-host-0:8444"]
1701type = "mutual-pull"
1702partner_cert = "dummy-cert-external-host-0"
1703automatic_refresh = true
1704
1705"#,
1706 },
1707 TestCase {
1708 env_vars: vec![
1709 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1710 ("REPLICATION_PORT", "8444"),
1711 ("BIND_ADDRESS", "0.0.0.0"),
1712 ("KANIDM_NAME", "kanidm-test"),
1713 ("POD_NAME", "kanidm-test-default-0"),
1714 ("KANIOP_REPLICATION_ENABLED", "true"),
1715 (
1716 "EXTERNAL_REPLICATION_NODE_HOST_0",
1717 "repl://external-host-0:8444",
1718 ),
1719 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
1720 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
1721 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1722 (
1723 "KANIDM_TEST_DEFAULT_0_HOST",
1724 "kanidm-test-default-0.kanidm-test",
1725 ),
1726 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1727 (
1728 "KANIDM_TEST_DEFAULT_1_HOST",
1729 "kanidm-test-default-1.kanidm-test",
1730 ),
1731 ],
1732 expected_result: r#"version = "2"
1733
1734[replication]
1735origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1736bindaddress = "0.0.0.0:8444"
1737
1738"#,
1739 },
1740 TestCase {
1741 env_vars: vec![
1742 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1743 ("REPLICATION_PORT", "8444"),
1744 ("BIND_ADDRESS", "0.0.0.0"),
1745 ("KANIDM_NAME", "kanidm-test"),
1746 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1747 ("POD_NAME", "kanidm-test-default-0"),
1748 ("KANIOP_REPLICATION_ENABLED", "true"),
1749 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1750 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1751 (
1752 "KANIDM_TEST_DEFAULT_0_HOST",
1753 "kanidm-test-default-0.kanidm-test",
1754 ),
1755 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1756 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1757 (
1758 "KANIDM_TEST_DEFAULT_1_HOST",
1759 "kanidm-test-default-1.kanidm-test",
1760 ),
1761 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1762 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1763 (
1764 "KANIDM_TEST_DEFAULT_3_HOST",
1765 "kanidm-test-default-3.kanidm-test",
1766 ),
1767 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1768 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1769 (
1770 "KANIDM_TEST_READ_REPLICA_0_HOST",
1771 "kanidm-test-read-replica-0.kanidm-test",
1772 ),
1773 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1774 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1775 (
1776 "KANIDM_TEST_READ_REPLICA_1_HOST",
1777 "kanidm-test-read-replica-1.kanidm-test",
1778 ),
1779 ],
1780 expected_result: r#"version = "2"
1781
1782[replication]
1783origin = "repl://kanidm-test-default-0.kanidm-test:8444"
1784bindaddress = "0.0.0.0:8444"
1785
1786[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1787type = "mutual-pull"
1788partner_cert = "dummy-cert-default-1"
1789automatic_refresh = false
1790
1791[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1792type = "mutual-pull"
1793partner_cert = "dummy-cert-default-3"
1794automatic_refresh = false
1795
1796[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1797type = "allow-pull"
1798consumer_cert = "dummy-cert-read-replica-0"
1799
1800[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1801type = "allow-pull"
1802consumer_cert = "dummy-cert-read-replica-1"
1803
1804"#,
1805 },
1806 TestCase {
1807 env_vars: vec![
1808 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1809 ("REPLICATION_PORT", "8444"),
1810 ("BIND_ADDRESS", "0.0.0.0"),
1811 ("KANIDM_NAME", "kanidm-test"),
1812 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1813 ("POD_NAME", "kanidm-test-default-1"),
1814 ("KANIOP_REPLICATION_ENABLED", "true"),
1815 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1816 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1817 (
1818 "KANIDM_TEST_DEFAULT_0_HOST",
1819 "kanidm-test-default-0.kanidm-test",
1820 ),
1821 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1822 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1823 (
1824 "KANIDM_TEST_DEFAULT_1_HOST",
1825 "kanidm-test-default-1.kanidm-test",
1826 ),
1827 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1828 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1829 (
1830 "KANIDM_TEST_DEFAULT_3_HOST",
1831 "kanidm-test-default-3.kanidm-test",
1832 ),
1833 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1834 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1835 (
1836 "KANIDM_TEST_READ_REPLICA_0_HOST",
1837 "kanidm-test-read-replica-0.kanidm-test",
1838 ),
1839 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1840 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1841 (
1842 "KANIDM_TEST_READ_REPLICA_1_HOST",
1843 "kanidm-test-read-replica-1.kanidm-test",
1844 ),
1845 ],
1846 expected_result: r#"version = "2"
1847
1848[replication]
1849origin = "repl://kanidm-test-default-1.kanidm-test:8444"
1850bindaddress = "0.0.0.0:8444"
1851
1852[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1853type = "mutual-pull"
1854partner_cert = "dummy-cert-default-0"
1855automatic_refresh = true
1856
1857[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1858type = "mutual-pull"
1859partner_cert = "dummy-cert-default-3"
1860automatic_refresh = false
1861
1862[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1863type = "allow-pull"
1864consumer_cert = "dummy-cert-read-replica-0"
1865
1866[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1867type = "allow-pull"
1868consumer_cert = "dummy-cert-read-replica-1"
1869
1870"#,
1871 },
1872 TestCase {
1873 env_vars: vec![
1874 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1875 ("REPLICATION_PORT", "8444"),
1876 ("BIND_ADDRESS", "0.0.0.0"),
1877 ("KANIDM_NAME", "kanidm-test"),
1878 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1879 ("POD_NAME", "kanidm-test-default-3"),
1880 ("KANIOP_REPLICATION_ENABLED", "true"),
1881 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1882 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
1883 (
1884 "KANIDM_TEST_DEFAULT_0_HOST",
1885 "kanidm-test-default-0.kanidm-test",
1886 ),
1887 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1888 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
1889 (
1890 "KANIDM_TEST_DEFAULT_1_HOST",
1891 "kanidm-test-default-1.kanidm-test",
1892 ),
1893 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1894 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
1895 (
1896 "KANIDM_TEST_DEFAULT_3_HOST",
1897 "kanidm-test-default-3.kanidm-test",
1898 ),
1899 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1900 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
1901 (
1902 "KANIDM_TEST_READ_REPLICA_0_HOST",
1903 "kanidm-test-read-replica-0.kanidm-test",
1904 ),
1905 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1906 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
1907 (
1908 "KANIDM_TEST_READ_REPLICA_1_HOST",
1909 "kanidm-test-read-replica-1.kanidm-test",
1910 ),
1911 ],
1912 expected_result: r#"version = "2"
1913
1914[replication]
1915origin = "repl://kanidm-test-default-3.kanidm-test:8444"
1916bindaddress = "0.0.0.0:8444"
1917
1918[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1919type = "mutual-pull"
1920partner_cert = "dummy-cert-default-0"
1921automatic_refresh = true
1922
1923[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1924type = "mutual-pull"
1925partner_cert = "dummy-cert-default-1"
1926automatic_refresh = false
1927
1928[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
1929type = "allow-pull"
1930consumer_cert = "dummy-cert-read-replica-0"
1931
1932[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
1933type = "allow-pull"
1934consumer_cert = "dummy-cert-read-replica-1"
1935
1936"#,
1937 },
1938 TestCase {
1939 env_vars: vec![
1940 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
1941 ("REPLICATION_PORT", "8444"),
1942 ("BIND_ADDRESS", "0.0.0.0"),
1943 ("KANIDM_NAME", "kanidm-test"),
1944 ("REPLICA_GROUP", "read-replica"),
1945 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
1946 ("POD_NAME", "kanidm-test-read-replica-0"),
1947 ("KANIOP_REPLICATION_ENABLED", "true"),
1948 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
1949 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
1950 (
1951 "KANIDM_TEST_DEFAULT_0_HOST",
1952 "kanidm-test-default-0.kanidm-test",
1953 ),
1954 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
1955 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
1956 (
1957 "KANIDM_TEST_DEFAULT_1_HOST",
1958 "kanidm-test-default-1.kanidm-test",
1959 ),
1960 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
1961 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
1962 (
1963 "KANIDM_TEST_DEFAULT_3_HOST",
1964 "kanidm-test-default-3.kanidm-test",
1965 ),
1966 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
1967 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
1968 (
1969 "KANIDM_TEST_READ_REPLICA_0_HOST",
1970 "kanidm-test-read-replica-0.kanidm-test",
1971 ),
1972 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
1973 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
1974 (
1975 "KANIDM_TEST_READ_REPLICA_1_HOST",
1976 "kanidm-test-read-replica-1.kanidm-test",
1977 ),
1978 ],
1979 expected_result: r#"version = "2"
1980
1981[replication]
1982origin = "repl://kanidm-test-read-replica-0.kanidm-test:8444"
1983bindaddress = "0.0.0.0:8444"
1984
1985[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
1986type = "pull"
1987supplier_cert = "dummy-cert-default-0"
1988automatic_refresh = true
1989
1990[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
1991type = "pull"
1992supplier_cert = "dummy-cert-default-1"
1993automatic_refresh = false
1994
1995[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
1996type = "pull"
1997supplier_cert = "dummy-cert-default-3"
1998automatic_refresh = false
1999
2000"#,
2001 },
2002 TestCase {
2003 env_vars: vec![
2004 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
2005 ("REPLICATION_PORT", "8444"),
2006 ("BIND_ADDRESS", "0.0.0.0"),
2007 ("KANIDM_NAME", "kanidm-test"),
2008 ("REPLICA_GROUP", "read-replica"),
2009 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
2010 ("POD_NAME", "kanidm-test-read-replica-1"),
2011 ("KANIOP_REPLICATION_ENABLED", "true"),
2012 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
2013 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
2014 (
2015 "KANIDM_TEST_DEFAULT_0_HOST",
2016 "kanidm-test-default-0.kanidm-test",
2017 ),
2018 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
2019 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
2020 (
2021 "KANIDM_TEST_DEFAULT_1_HOST",
2022 "kanidm-test-default-1.kanidm-test",
2023 ),
2024 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
2025 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
2026 (
2027 "KANIDM_TEST_DEFAULT_3_HOST",
2028 "kanidm-test-default-3.kanidm-test",
2029 ),
2030 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
2031 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
2032 (
2033 "KANIDM_TEST_READ_REPLICA_0_HOST",
2034 "kanidm-test-read-replica-0.kanidm-test",
2035 ),
2036 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
2037 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
2038 (
2039 "KANIDM_TEST_READ_REPLICA_1_HOST",
2040 "kanidm-test-read-replica-1.kanidm-test",
2041 ),
2042 ],
2043 expected_result: r#"version = "2"
2044
2045[replication]
2046origin = "repl://kanidm-test-read-replica-1.kanidm-test:8444"
2047bindaddress = "0.0.0.0:8444"
2048
2049[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
2050type = "pull"
2051supplier_cert = "dummy-cert-default-0"
2052automatic_refresh = true
2053
2054[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
2055type = "pull"
2056supplier_cert = "dummy-cert-default-1"
2057automatic_refresh = false
2058
2059[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
2060type = "pull"
2061supplier_cert = "dummy-cert-default-3"
2062automatic_refresh = false
2063
2064"#,
2065 },
2066 TestCase {
2067 env_vars: vec![
2068 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
2069 ("REPLICATION_PORT", "8444"),
2070 ("BIND_ADDRESS", "0.0.0.0"),
2071 ("KANIDM_NAME", "kanidm-test"),
2072 ("REPLICA_GROUP", "read-replica"),
2073 ("KANIDM_PRIMARY_NODE", "kanidm-test-default-0"),
2074 ("POD_NAME", "kanidm-test-read-replica-1"),
2075 (
2076 "EXTERNAL_REPLICATION_NODE_HOST_0",
2077 "repl://external-host-0:8444",
2078 ),
2079 (
2080 "EXTERNAL_REPLICATION_NODE_HOST_0_CERT",
2081 "dummy-cert-external-host-0",
2082 ),
2083 ("EXTERNAL_REPLICATION_NODE_HOST_0_TYPE", "mutual-pull"),
2084 ("EXTERNAL_REPLICATION_NODE_HOST_0_AUTOMATIC_REFRESH", "true"),
2085 ("KANIOP_REPLICATION_ENABLED", "true"),
2086 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
2087 ("KANIDM_TEST_DEFAULT_0_TYPE", "pull"),
2088 (
2089 "KANIDM_TEST_DEFAULT_0_HOST",
2090 "kanidm-test-default-0.kanidm-test",
2091 ),
2092 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
2093 ("KANIDM_TEST_DEFAULT_1_TYPE", "pull"),
2094 (
2095 "KANIDM_TEST_DEFAULT_1_HOST",
2096 "kanidm-test-default-1.kanidm-test",
2097 ),
2098 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
2099 ("KANIDM_TEST_DEFAULT_3_TYPE", "pull"),
2100 (
2101 "KANIDM_TEST_DEFAULT_3_HOST",
2102 "kanidm-test-default-3.kanidm-test",
2103 ),
2104 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
2105 ("KANIDM_TEST_READ_REPLICA_0_TYPE", ""),
2106 (
2107 "KANIDM_TEST_READ_REPLICA_0_HOST",
2108 "kanidm-test-read-replica-0.kanidm-test",
2109 ),
2110 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
2111 ("KANIDM_TEST_READ_REPLICA_1_TYPE", ""),
2112 (
2113 "KANIDM_TEST_READ_REPLICA_1_HOST",
2114 "kanidm-test-read-replica-1.kanidm-test",
2115 ),
2116 ],
2117 expected_result: r#"version = "2"
2118
2119[replication]
2120origin = "repl://kanidm-test-read-replica-1.kanidm-test:8444"
2121bindaddress = "0.0.0.0:8444"
2122
2123[replication."repl://external-host-0:8444"]
2124type = "mutual-pull"
2125partner_cert = "dummy-cert-external-host-0"
2126automatic_refresh = true
2127
2128[replication."repl://kanidm-test-default-0.kanidm-test:8444"]
2129type = "pull"
2130supplier_cert = "dummy-cert-default-0"
2131automatic_refresh = true
2132
2133[replication."repl://kanidm-test-default-1.kanidm-test:8444"]
2134type = "pull"
2135supplier_cert = "dummy-cert-default-1"
2136automatic_refresh = false
2137
2138[replication."repl://kanidm-test-default-3.kanidm-test:8444"]
2139type = "pull"
2140supplier_cert = "dummy-cert-default-3"
2141automatic_refresh = false
2142
2143"#,
2144 },
2145 TestCase {
2146 env_vars: vec![
2147 ("KANIDM_CONFIG_PATH", "/tmp/server.toml"),
2148 ("REPLICATION_PORT", "8444"),
2149 ("BIND_ADDRESS", "0.0.0.0"),
2150 ("KANIDM_NAME", "kanidm-test"),
2151 ("POD_NAME", "kanidm-test-default-0"),
2152 ("KANIOP_REPLICATION_ENABLED", "true"),
2153 ("KANIDM_TEST_DEFAULT_0", "dummy-cert-default-0"),
2154 ("KANIDM_TEST_DEFAULT_0_HOST", "10.200.20.1"),
2155 ("KANIDM_TEST_DEFAULT_0_TYPE", "mutual-pull"),
2156 ("KANIDM_TEST_DEFAULT_1", "dummy-cert-default-1"),
2157 ("KANIDM_TEST_DEFAULT_1_HOST", "10.200.20.2"),
2158 ("KANIDM_TEST_DEFAULT_1_TYPE", "mutual-pull"),
2159 ("KANIDM_TEST_DEFAULT_3", "dummy-cert-default-3"),
2160 ("KANIDM_TEST_DEFAULT_3_HOST", "10.200.20.4"),
2161 ("KANIDM_TEST_DEFAULT_3_TYPE", "mutual-pull"),
2162 ("KANIDM_TEST_READ_REPLICA_0", "dummy-cert-read-replica-0"),
2163 ("KANIDM_TEST_READ_REPLICA_0_TYPE", "allow-pull"),
2164 (
2165 "KANIDM_TEST_READ_REPLICA_0_HOST",
2166 "kanidm-test-read-replica-0.kanidm-test",
2167 ),
2168 ("KANIDM_TEST_READ_REPLICA_1", "dummy-cert-read-replica-1"),
2169 ("KANIDM_TEST_READ_REPLICA_1_TYPE", "allow-pull"),
2170 (
2171 "KANIDM_TEST_READ_REPLICA_1_HOST",
2172 "kanidm-test-read-replica-1.kanidm-test",
2173 ),
2174 ],
2175 expected_result: r#"version = "2"
2176
2177[replication]
2178origin = "repl://10.200.20.1:8444"
2179bindaddress = "0.0.0.0:8444"
2180
2181[replication."repl://10.200.20.2:8444"]
2182type = "mutual-pull"
2183partner_cert = "dummy-cert-default-1"
2184automatic_refresh = false
2185
2186[replication."repl://10.200.20.4:8444"]
2187type = "mutual-pull"
2188partner_cert = "dummy-cert-default-3"
2189automatic_refresh = false
2190
2191[replication."repl://kanidm-test-read-replica-0.kanidm-test:8444"]
2192type = "allow-pull"
2193consumer_cert = "dummy-cert-read-replica-0"
2194
2195[replication."repl://kanidm-test-read-replica-1.kanidm-test:8444"]
2196type = "allow-pull"
2197consumer_cert = "dummy-cert-read-replica-1"
2198
2199"#,
2200 },
2201 ];
2202
2203 for test_case in test_cases {
2204 run_test_case(
2205 &image_parts,
2206 &cmd,
2207 &tmp_dir_path,
2208 &test_case.env_vars,
2209 test_case.expected_result,
2210 )
2211 .await;
2212 }
2213 }
2214 #[test]
2215 fn backup_enables_generated_config_and_native_online_backup_stanza() {
2216 use crate::kanidm::crd::{KanidmBackupSpec, KanidmStorage, PersistentVolumeClaimTemplate};
2217 use k8s_openapi::api::core::v1::PersistentVolumeClaimSpec;
2218
2219 use super::StatefulSetExt;
2220
2221 let (mut kanidm, mut replica_group) = super::tests::create_kanidm_with_replica_group();
2222 replica_group.primary_node = true;
2223 kanidm.spec.replica_groups = vec![replica_group.clone()];
2224 kanidm.spec.backup = Some(KanidmBackupSpec {
2225 schedule: "0 2 * * *".to_string(),
2226 versions: 7,
2227 });
2228 kanidm.spec.storage = Some(KanidmStorage {
2229 volume_claim_template: Some(PersistentVolumeClaimTemplate {
2230 metadata: None,
2231 spec: Some(PersistentVolumeClaimSpec::default()),
2232 }),
2233 ..Default::default()
2234 });
2235
2236 let sts = kanidm
2237 .create_statefulset(&replica_group, None, None)
2238 .unwrap();
2239 let pod = sts.spec.unwrap().template.spec.unwrap();
2240 let init = pod
2241 .init_containers
2242 .unwrap()
2243 .into_iter()
2244 .find(|c| c.name == "kanidm-generate-replication-config")
2245 .unwrap();
2246 let env = init.env.unwrap();
2247 assert!(
2248 env.iter()
2249 .any(|e| e.name == "KANIOP_BACKUP_ENABLED" && e.value.as_deref() == Some("true"))
2250 );
2251 assert!(
2252 env.iter()
2253 .any(|e| e.name == "KANIOP_BACKUP_SCHEDULE"
2254 && e.value.as_deref() == Some("0 2 * * *"))
2255 );
2256 assert!(
2257 env.iter()
2258 .any(|e| e.name == "KANIOP_BACKUP_VERSIONS" && e.value.as_deref() == Some("7"))
2259 );
2260 let script = init.args.unwrap().join("\n");
2261 assert!(script.contains("[online_backup]"));
2262 assert!(script.contains("env.POD_NAME == env.KANIDM_PRIMARY_NODE"));
2263 }
2264
2265 #[test]
2266 fn transport_sidecar_present_for_primary_group_with_config() {
2267 use super::StatefulSetExt;
2268 use crate::kanidm::reconcile::transport::TransportSidecarConfig;
2269 use kaniop_backup_core::crd::{AuthMethod, SecretRef};
2270
2271 use super::tests::create_kanidm_with_replica_group;
2272 let (mut kanidm, mut replica_group) = create_kanidm_with_replica_group();
2273 replica_group.primary_node = true;
2274 kanidm.spec.replica_groups = vec![replica_group.clone()];
2275
2276 let config = TransportSidecarConfig {
2277 operation_doc_json: r#"{"operation":"transport","bucket":"test"}"#.to_string(),
2278 auth_method: AuthMethod {
2279 workload_identity: None,
2280 secret_ref: Some(SecretRef {
2281 name: "writer-secret".to_string(),
2282 }),
2283 },
2284 ca_bundle_ref: None,
2285 };
2286
2287 let sts = kanidm
2288 .create_statefulset(&replica_group, None, Some(&config))
2289 .unwrap();
2290 let pod = sts.spec.unwrap().template.spec.unwrap();
2291 let containers = pod.containers;
2292
2293 let sidecar = containers.iter().find(|c| c.name == "data-mover-transport");
2294 assert!(sidecar.is_some());
2295 let sidecar = sidecar.unwrap();
2296 assert_eq!(
2297 sidecar.image.as_deref(),
2298 Some("ghcr.io/pando85/kaniop-data-mover:latest")
2299 );
2300 assert_eq!(
2301 sidecar.command.as_ref().unwrap(),
2302 &vec!["/bin/kaniop-data-mover".to_string()]
2303 );
2304 assert_eq!(
2305 sidecar.args.as_ref().unwrap(),
2306 &vec![
2307 "transport".to_string(),
2308 "--operation-doc".to_string(),
2309 r#"{"operation":"transport","bucket":"test"}"#.to_string(),
2310 ]
2311 );
2312
2313 let env = sidecar.env.as_ref().unwrap();
2314 assert!(env.iter().any(|e| e.name == "POD_NAME"));
2315 assert!(env.iter().any(|e| e.name == "KANIDM_PRIMARY_NODE"));
2316 assert!(env.iter().any(|e| e.name == "AWS_ACCESS_KEY_ID"));
2317
2318 let mounts = sidecar.volume_mounts.as_ref().unwrap();
2319 assert!(
2320 mounts
2321 .iter()
2322 .any(|m| m.name == "kanidm-data" && m.read_only == Some(true))
2323 );
2324 assert!(
2325 mounts
2326 .iter()
2327 .any(|m| m.name == "kanidm-tmp" && m.mount_path == "/tmp")
2328 );
2329
2330 let volumes = pod.volumes.as_ref().unwrap();
2331 assert!(volumes.iter().any(|v| v.name == "kanidm-tmp"));
2332
2333 let sc = sidecar.security_context.as_ref().unwrap();
2334 assert_eq!(sc.run_as_non_root, Some(true));
2335 assert_eq!(sc.allow_privilege_escalation, Some(false));
2336 assert_eq!(sc.read_only_root_filesystem, Some(true));
2337 assert!(sc.run_as_user.is_none());
2338 assert!(
2339 sc.capabilities
2340 .as_ref()
2341 .unwrap()
2342 .drop
2343 .as_ref()
2344 .unwrap()
2345 .contains(&"ALL".to_string())
2346 );
2347 }
2348
2349 #[test]
2350 fn transport_sidecar_absent_for_non_primary_group() {
2351 use super::StatefulSetExt;
2352 use crate::kanidm::reconcile::transport::TransportSidecarConfig;
2353 use kaniop_backup_core::crd::{AuthMethod, SecretRef};
2354
2355 use super::tests::create_kanidm_with_replica_group;
2356 let (mut kanidm, mut replica_group) = create_kanidm_with_replica_group();
2357 replica_group.primary_node = false;
2358 kanidm.spec.replica_groups = vec![replica_group.clone()];
2359
2360 let config = TransportSidecarConfig {
2361 operation_doc_json: r#"{"operation":"transport"}"#.to_string(),
2362 auth_method: AuthMethod {
2363 workload_identity: None,
2364 secret_ref: Some(SecretRef {
2365 name: "writer-secret".to_string(),
2366 }),
2367 },
2368 ca_bundle_ref: None,
2369 };
2370
2371 let sts = kanidm
2372 .create_statefulset(&replica_group, None, Some(&config))
2373 .unwrap();
2374 let pod = sts.spec.unwrap().template.spec.unwrap();
2375 let containers = pod.containers;
2376
2377 let sidecar = containers.iter().find(|c| c.name == "data-mover-transport");
2378 assert!(sidecar.is_none());
2379 }
2380
2381 #[test]
2382 fn transport_sidecar_absent_without_config() {
2383 use super::StatefulSetExt;
2384 use super::tests::create_kanidm_with_replica_group;
2385 let (mut kanidm, mut replica_group) = create_kanidm_with_replica_group();
2386 replica_group.primary_node = true;
2387 kanidm.spec.replica_groups = vec![replica_group.clone()];
2388
2389 let sts = kanidm
2390 .create_statefulset(&replica_group, None, None)
2391 .unwrap();
2392 let pod = sts.spec.unwrap().template.spec.unwrap();
2393 let containers = pod.containers;
2394
2395 let sidecar = containers.iter().find(|c| c.name == "data-mover-transport");
2396 assert!(sidecar.is_none());
2397 }
2398
2399 #[test]
2400 fn transport_sidecar_with_ca_bundle() {
2401 use super::StatefulSetExt;
2402 use crate::kanidm::reconcile::transport::TransportSidecarConfig;
2403 use kaniop_backup_core::crd::{AuthMethod, SecretRef};
2404
2405 use super::tests::create_kanidm_with_replica_group;
2406 let (mut kanidm, mut replica_group) = create_kanidm_with_replica_group();
2407 replica_group.primary_node = true;
2408 kanidm.spec.replica_groups = vec![replica_group.clone()];
2409
2410 let config = TransportSidecarConfig {
2411 operation_doc_json: r#"{"operation":"transport"}"#.to_string(),
2412 auth_method: AuthMethod {
2413 workload_identity: None,
2414 secret_ref: Some(SecretRef {
2415 name: "writer-secret".to_string(),
2416 }),
2417 },
2418 ca_bundle_ref: Some("ca-config-map".to_string()),
2419 };
2420
2421 let sts = kanidm
2422 .create_statefulset(&replica_group, None, Some(&config))
2423 .unwrap();
2424 let pod = sts.spec.unwrap().template.spec.unwrap();
2425
2426 let sidecar = pod
2427 .containers
2428 .iter()
2429 .find(|c| c.name == "data-mover-transport")
2430 .unwrap();
2431 let env = sidecar.env.as_ref().unwrap();
2432 assert!(env.iter().any(|e| e.name == "SSL_CERT_FILE"));
2433
2434 let mounts = sidecar.volume_mounts.as_ref().unwrap();
2435 assert!(mounts.iter().any(|m| m.name == "ca-bundle"));
2436
2437 let volumes = pod.volumes.as_ref().unwrap();
2438 assert!(volumes.iter().any(|v| v.name == "ca-bundle"));
2439 }
2440}