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