1use crate::crd::{
2 KanidmGroup, KanidmGroupAccountPolicyAttributes, KanidmGroupPosixAttributes, KanidmGroupStatus,
3};
4
5use kaniop_k8s_util::error::{Error, Result};
6use kaniop_k8s_util::types::{compare_mail, compare_names, get_first_cloned, normalize_spn};
7use kaniop_operator::controller::kanidm::{KanidmResource, is_resource_watched};
8use kaniop_operator::controller::{
9 context::{Context, IdmClientContext},
10 idm_reconcile_interval,
11};
12use kaniop_operator::metrics::{
13 KANIDM_OP_ACCOUNT_POLICY, KANIDM_OP_CREATE, KANIDM_OP_DELETE, KANIDM_OP_GET,
14 KANIDM_OP_PURGE_ATTR, KANIDM_OP_SET_MAIL, KANIDM_OP_SET_MEMBERS, KANIDM_OP_UNIX_EXTEND,
15 KANIDM_OP_UPDATE, KANIDM_OUTCOME_CHANGED, KANIDM_OUTCOME_ERROR, KANIDM_OUTCOME_UNCHANGED,
16 KANIDM_RESOURCE_GROUP, record_kanidm_sdk_call,
17};
18use kaniop_operator::telemetry;
19
20use std::sync::Arc;
21use std::time::Duration;
22
23use k8s_openapi::apimachinery::pkg::apis::meta::v1::{Condition, Time};
24use k8s_openapi::jiff::Timestamp;
25use kanidm_client::{ClientError, KanidmClient};
26use kanidm_proto::constants::{
27 ATTR_ALLOW_PRIMARY_CRED_FALLBACK, ATTR_CREDENTIAL_TYPE_MINIMUM, ATTR_DESCRIPTION,
28 ATTR_ENTRY_MANAGED_BY, ATTR_MAIL, ATTR_MEMBER,
29};
30use kanidm_proto::v1::Entry;
31use kube::api::{Api, Patch, PatchParams};
32use kube::runtime::controller::Action;
33use kube::runtime::events::{Event, EventType};
34use kube::runtime::finalizer::{Error as FinalizerError, Event as Finalizer, finalizer};
35use kube::{Resource, ResourceExt};
36use tracing::{Span, debug, field, info, instrument, trace, warn};
37
38pub static GROUP_OPERATOR_NAME: &str = "kanidmgroups.kaniop.rs";
39pub static GROUP_FINALIZER: &str = "kanidmgroups.kaniop.rs/finalizer";
40
41const TYPE_EXISTS: &str = "Exists";
42const TYPE_DESCRIPTION_UPDATED: &str = "DescriptionUpdated";
43const TYPE_MAIL_UPDATED: &str = "MailUpdated";
44const TYPE_MANAGED_UPDATED: &str = "ManagedUpdated";
45const TYPE_MEMBERS_UPDATED: &str = "MembersUpdated";
46const TYPE_POSIX_INITIALIZED: &str = "PosixInitialized";
47const TYPE_POSIX_UPDATED: &str = "PosixUpdated";
48const TYPE_ACCOUNT_POLICY_ENABLED: &str = "AccountPolicyEnabled";
49const TYPE_ACCOUNT_POLICY_UPDATED: &str = "AccountPolicyUpdated";
50const REASON_ATTRIBUTE_MATCH: &str = "AttributeMatch";
51const REASON_ATTRIBUTE_NOT_MATCH: &str = "AttributeNotMatch";
52const REASON_ATTRIBUTES_MATCH: &str = "AttributesMatch";
53const REASON_ATTRIBUTES_NOT_MATCH: &str = "AttributesNotMatch";
54const CONDITION_TRUE: &str = "True";
55const CONDITION_FALSE: &str = "False";
56
57pub async fn watched_resource(group: &KanidmGroup, ctx: Arc<Context<KanidmGroup>>) -> bool {
58 let kanidm = if let Some(k) = ctx.get_kanidm(group) {
59 k
60 } else {
61 trace!("no kanidm found");
62 return false;
63 };
64
65 is_resource_watched(group, &kanidm, &ctx.namespace_store, &ctx.client).await
66}
67
68#[instrument(skip(ctx, group))]
69pub async fn reconcile_group(
70 group: Arc<KanidmGroup>,
71 ctx: Arc<Context<KanidmGroup>>,
72) -> Result<(Action, bool)> {
73 let trace_id = telemetry::get_trace_id();
74 Span::current().record("trace_id", field::display(&trace_id));
75 let _timer = ctx.metrics.reconcile_count_and_measure(&trace_id);
76 if !ctx.kanidm_write_allowed(&group) {
77 debug!("Kanidm restore in progress, pausing identity writes");
78 return Ok((Action::requeue(Duration::from_secs(5)), false));
79 }
80 let kanidm_client = ctx.get_idm_client(&group).await?;
81
82 if !watched_resource(&group, ctx.clone()).await {
83 debug!("resource not watched, skipping reconcile");
84 ctx.recorder
85 .publish(
86 &Event {
87 type_: EventType::Warning,
88 reason: "ResourceNotWatched".to_string(),
89 note: Some("configure `groupNamespaceSelector` on Kanidm resource to watch this namespace".to_string()),
90 action: "Reconcile".to_string(),
91 secondary: None,
92 },
93 &group.object_ref(&()),
94 )
95 .await
96 .map_err(|e| {
97 warn!(error = %e, "failed to publish ResourceNotWatched event");
98 Error::kube_error("publish", "event", group.get_namespace(), group.name_any(), e)
99 })?;
100 return Ok((Action::requeue(idm_reconcile_interval()), false));
101 }
102
103 info!("reconciling group");
104
105 let namespace = group.get_namespace();
107 let status = group
108 .update_status(kanidm_client.clone(), ctx.clone())
109 .await
110 .map_err(|e| {
111 debug!(error = %e, "failed to reconcile status");
112 ctx.metrics.status_update_errors_inc();
113 e
114 })?;
115 let groups_api: Api<KanidmGroup> = Api::namespaced(ctx.client.clone(), &namespace);
116 let outcome = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
117 let outcome_clone = outcome.clone();
118 let action = finalizer(&groups_api, GROUP_FINALIZER, group, move |event| {
119 let outcome = outcome_clone.clone();
120 let ctx = ctx.clone();
121 let status = status.clone();
122 let kanidm_client = kanidm_client.clone();
123 async move {
124 match event {
125 Finalizer::Apply(g) => {
126 let (action, changed) = g.reconcile(kanidm_client, status, ctx).await?;
127 outcome.store(changed, std::sync::atomic::Ordering::Relaxed);
128 Ok(action)
129 }
130 Finalizer::Cleanup(g) => {
131 let (action, changed) = g.cleanup(kanidm_client, status, ctx).await?;
132 outcome.store(changed, std::sync::atomic::Ordering::Relaxed);
133 Ok(action)
134 }
135 }
136 }
137 })
138 .await
139 .or_else(|e| match e {
140 FinalizerError::RemoveFinalizer(kube::Error::Api(ae)) if ae.code == 404 => {
141 debug!("resource already removed during finalizer cleanup");
142 Ok(Action::requeue(idm_reconcile_interval()))
143 }
144 _ => Err(Error::FinalizerError(
145 "failed on group finalizer".to_string(),
146 Box::new(e),
147 )),
148 })?;
149 let changed = outcome.load(std::sync::atomic::Ordering::Relaxed);
150 Ok((action, changed))
151}
152
153impl KanidmGroup {
154 #[inline]
155 fn get_namespace(&self) -> String {
156 self.namespace().unwrap()
158 }
159
160 #[inline]
161 async fn reconcile(
162 &self,
163 kanidm_client: Arc<KanidmClient>,
164 status: KanidmGroupStatus,
165 ctx: Arc<Context<KanidmGroup>>,
166 ) -> Result<(Action, bool)> {
167 match self
168 .internal_reconcile(kanidm_client, status, ctx.clone())
169 .await
170 {
171 Ok(result) => Ok(result),
172 Err(e) => match e {
173 Error::KanidmClientError(_, _) => {
174 ctx.recorder
175 .publish(
176 &Event {
177 type_: EventType::Warning,
178 reason: "KanidmError".to_string(),
179 note: Some(format!("{e:?}")),
180 action: "KanidmRequest".to_string(),
181 secondary: None,
182 },
183 &self.object_ref(&()),
184 )
185 .await
186 .map_err(|e| {
187 warn!(error = %e, "failed to publish KanidmError event");
188 Error::kube_error(
189 "publish",
190 "event",
191 self.get_namespace(),
192 self.name_any(),
193 e,
194 )
195 })?;
196 Err(e)
197 }
198 _ => Err(e),
199 },
200 }
201 }
202
203 #[inline]
204 async fn internal_reconcile(
205 &self,
206 kanidm_client: Arc<KanidmClient>,
207 status: KanidmGroupStatus,
208 ctx: Arc<Context<KanidmGroup>>,
209 ) -> Result<(Action, bool)> {
210 let name = &self.kanidm_entity_name();
211 let metrics = &ctx.metrics;
212 let mut require_status_update = false;
213 let mut changed = false;
214 if is_group_false(TYPE_EXISTS, status.clone()) {
215 record_kanidm_sdk_call(
216 metrics,
217 KANIDM_RESOURCE_GROUP,
218 KANIDM_OP_CREATE,
219 KANIDM_OUTCOME_CHANGED,
220 self.create(&kanidm_client, name),
221 )
222 .await?;
223 require_status_update = true;
224 changed = true;
225 }
226
227 if is_group_false(TYPE_MANAGED_UPDATED, status.clone()) {
228 record_kanidm_sdk_call(
229 metrics,
230 KANIDM_RESOURCE_GROUP,
231 KANIDM_OP_UPDATE,
232 KANIDM_OUTCOME_CHANGED,
233 self.update_managed_by(&kanidm_client, name),
234 )
235 .await?;
236 require_status_update = true;
237 changed = true;
238 }
239
240 if is_group_false(TYPE_DESCRIPTION_UPDATED, status.clone()) {
241 record_kanidm_sdk_call(
242 metrics,
243 KANIDM_RESOURCE_GROUP,
244 KANIDM_OP_UPDATE,
245 KANIDM_OUTCOME_CHANGED,
246 self.update_description(&kanidm_client, name),
247 )
248 .await?;
249 require_status_update = true;
250 changed = true;
251 }
252
253 if is_group_false(TYPE_MAIL_UPDATED, status.clone()) {
254 record_kanidm_sdk_call(
255 metrics,
256 KANIDM_RESOURCE_GROUP,
257 KANIDM_OP_SET_MAIL,
258 KANIDM_OUTCOME_CHANGED,
259 self.update_mail(&kanidm_client, name),
260 )
261 .await?;
262 require_status_update = true;
263 changed = true;
264 }
265
266 if is_group_false(TYPE_MEMBERS_UPDATED, status.clone()) {
267 record_kanidm_sdk_call(
268 metrics,
269 KANIDM_RESOURCE_GROUP,
270 KANIDM_OP_SET_MEMBERS,
271 KANIDM_OUTCOME_CHANGED,
272 self.update_members(&kanidm_client, name),
273 )
274 .await?;
275 require_status_update = true;
276 changed = true;
277 }
278
279 if is_group_false(TYPE_POSIX_UPDATED, status.clone())
280 || (is_group_false(TYPE_POSIX_INITIALIZED, status.clone())
281 && is_group(TYPE_POSIX_UPDATED, status.clone()))
282 {
283 record_kanidm_sdk_call(
284 metrics,
285 KANIDM_RESOURCE_GROUP,
286 KANIDM_OP_UNIX_EXTEND,
287 KANIDM_OUTCOME_CHANGED,
288 self.update_posix_attributes(&kanidm_client, name),
289 )
290 .await?;
291 require_status_update = true;
292 changed = true;
293 }
294
295 if is_group_false(TYPE_ACCOUNT_POLICY_ENABLED, status.clone()) {
297 record_kanidm_sdk_call(
298 metrics,
299 KANIDM_RESOURCE_GROUP,
300 KANIDM_OP_ACCOUNT_POLICY,
301 KANIDM_OUTCOME_CHANGED,
302 self.enable_account_policy(&kanidm_client, name),
303 )
304 .await?;
305 require_status_update = true;
306 changed = true;
307 }
308
309 if is_group_false(TYPE_ACCOUNT_POLICY_UPDATED, status.clone()) {
310 self.update_account_policy(&kanidm_client, name, metrics)
311 .await?;
312 require_status_update = true;
313 changed = true;
314 }
315
316 if require_status_update {
317 trace!("status update required, requeueing in 500ms");
318 Ok((Action::requeue(Duration::from_millis(500)), changed))
319 } else {
320 Ok((Action::requeue(idm_reconcile_interval()), changed))
321 }
322 }
323
324 async fn create(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
325 debug!("create");
326 kanidm_client
327 .idm_group_create(name, self.spec.entry_managed_by.as_deref())
328 .await
329 .map_err(|e| {
330 Error::kanidm_client_error(
331 "create",
332 name,
333 self.kanidm_namespace(),
334 self.kanidm_name(),
335 e,
336 )
337 })?;
338 Ok(())
339 }
340
341 async fn update_managed_by(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
342 debug!(attribute = ATTR_ENTRY_MANAGED_BY, "updating attribute");
343 let entry_managed_by =
344 self.spec.entry_managed_by.as_ref().ok_or_else(|| {
345 Error::MissingData("group entryManagedBy is not defined".to_string())
346 })?;
347
348 kanidm_client
349 .idm_group_set_entry_managed_by(name, entry_managed_by)
350 .await
351 .map_err(|e| {
352 Error::kanidm_client_error_attr(
353 "update",
354 ATTR_ENTRY_MANAGED_BY,
355 name,
356 self.kanidm_namespace(),
357 self.kanidm_name(),
358 e,
359 )
360 })?;
361 Ok(())
362 }
363
364 async fn update_description(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
365 debug!(attribute = ATTR_DESCRIPTION, "updating attribute");
366 let description =
367 self.spec.description.as_deref().ok_or_else(|| {
368 Error::MissingData("group description is not defined".to_string())
369 })?;
370
371 let result = if description.is_empty() {
372 kanidm_client.idm_group_purge_description(name).await
373 } else {
374 kanidm_client
375 .idm_group_set_description(name, description)
376 .await
377 };
378 result.map_err(|e| {
379 Error::kanidm_client_error_attr(
380 "update",
381 ATTR_DESCRIPTION,
382 name,
383 self.kanidm_namespace(),
384 self.kanidm_name(),
385 e,
386 )
387 })?;
388 Ok(())
389 }
390
391 async fn update_mail(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
392 debug!(attribute = ATTR_MAIL, "updating attribute");
393 let mail = self
394 .spec
395 .mail
396 .as_ref()
397 .ok_or_else(|| Error::MissingData("group mail is not defined".to_string()))?;
398
399 if mail.is_empty() {
400 kanidm_client
401 .idm_group_purge_mail(name)
402 .await
403 .map_err(|e| {
404 Error::kanidm_client_error_attr(
405 "purge",
406 ATTR_MAIL,
407 name,
408 self.kanidm_namespace(),
409 self.kanidm_name(),
410 e,
411 )
412 })?;
413 } else {
414 kanidm_client
415 .idm_group_set_mail(name, mail)
416 .await
417 .map_err(|e| {
418 Error::kanidm_client_error_attr(
419 "update",
420 ATTR_MAIL,
421 name,
422 self.kanidm_namespace(),
423 self.kanidm_name(),
424 e,
425 )
426 })?;
427 }
428 Ok(())
429 }
430
431 async fn update_members(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
432 debug!(attribute = ATTR_MEMBER, "updating attribute");
433 let members = self
434 .spec
435 .members
436 .as_ref()
437 .ok_or_else(|| Error::MissingData("group members is not defined".to_string()))?
438 .iter()
439 .map(|m| m.as_str())
440 .collect::<Vec<&str>>();
441
442 kanidm_client
443 .idm_group_set_members(name, &members)
444 .await
445 .map_err(|e| {
446 Error::kanidm_client_error_attr(
447 "update",
448 ATTR_MEMBER,
449 name,
450 self.kanidm_namespace(),
451 self.kanidm_name(),
452 e,
453 )
454 })?;
455 Ok(())
456 }
457
458 async fn update_posix_attributes(
459 &self,
460 kanidm_client: &KanidmClient,
461 name: &str,
462 ) -> Result<()> {
463 debug!("updating posix attributes");
464 trace!(posix_attributes = ?self.spec.posix_attributes, "updating posix attributes");
465 kanidm_client
466 .idm_group_unix_extend(
467 name,
468 self.spec
469 .posix_attributes
470 .as_ref()
471 .and_then(|posix| posix.gidnumber),
472 )
473 .await
474 .map_err(|e| {
475 Error::kanidm_client_error(
476 "unix extend",
477 name,
478 self.kanidm_namespace(),
479 self.kanidm_name(),
480 e,
481 )
482 })?;
483 Ok(())
484 }
485
486 async fn enable_account_policy(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
487 debug!("enabling account policy");
488 kanidm_client
489 .group_account_policy_enable(name)
490 .await
491 .map_err(|e| {
492 Error::kanidm_client_error(
493 "enable account policy for",
494 name,
495 self.kanidm_namespace(),
496 self.kanidm_name(),
497 e,
498 )
499 })?;
500 Ok(())
501 }
502
503 async fn update_account_policy(
504 &self,
505 kanidm_client: &KanidmClient,
506 name: &str,
507 metrics: &kaniop_operator::metrics::ControllerMetrics,
508 ) -> Result<()> {
509 debug!("updating account policy");
510 let policy =
511 self.spec.account_policy.as_ref().ok_or_else(|| {
512 Error::MissingData("group accountPolicy is not defined".to_string())
513 })?;
514 trace!(policy = ?policy, "updating account policy");
515
516 if let Some(expiry) = policy.auth_session_expiry {
518 record_kanidm_sdk_call(
519 metrics,
520 KANIDM_RESOURCE_GROUP,
521 KANIDM_OP_ACCOUNT_POLICY,
522 KANIDM_OUTCOME_CHANGED,
523 kanidm_client.group_account_policy_authsession_expiry_set(name, expiry),
524 )
525 .await
526 .map_err(|e| {
527 Error::kanidm_client_error_attr(
528 "set",
529 "auth session expiry",
530 name,
531 self.kanidm_namespace(),
532 self.kanidm_name(),
533 e,
534 )
535 })?;
536 } else {
537 record_kanidm_sdk_call(
538 metrics,
539 KANIDM_RESOURCE_GROUP,
540 KANIDM_OP_ACCOUNT_POLICY,
541 KANIDM_OUTCOME_CHANGED,
542 kanidm_client.group_account_policy_authsession_expiry_reset(name),
543 )
544 .await
545 .map_err(|e| {
546 Error::kanidm_client_error_attr(
547 "reset",
548 "auth session expiry",
549 name,
550 self.kanidm_namespace(),
551 self.kanidm_name(),
552 e,
553 )
554 })?;
555 }
556
557 if let Some(ref cred_type) = policy.credential_type_minimum {
559 record_kanidm_sdk_call(
560 metrics,
561 KANIDM_RESOURCE_GROUP,
562 KANIDM_OP_ACCOUNT_POLICY,
563 KANIDM_OUTCOME_CHANGED,
564 kanidm_client
565 .group_account_policy_credential_type_minimum_set(name, &cred_type.to_string()),
566 )
567 .await
568 .map_err(|e| {
569 Error::kanidm_client_error_attr(
570 "set",
571 ATTR_CREDENTIAL_TYPE_MINIMUM,
572 name,
573 self.kanidm_namespace(),
574 self.kanidm_name(),
575 e,
576 )
577 })?;
578 } else {
579 record_kanidm_sdk_call(
580 metrics,
581 KANIDM_RESOURCE_GROUP,
582 KANIDM_OP_PURGE_ATTR,
583 KANIDM_OUTCOME_CHANGED,
584 kanidm_client.idm_group_purge_attr(name, ATTR_CREDENTIAL_TYPE_MINIMUM),
585 )
586 .await
587 .map_err(|e| {
588 Error::kanidm_client_error_attr(
589 "reset",
590 ATTR_CREDENTIAL_TYPE_MINIMUM,
591 name,
592 self.kanidm_namespace(),
593 self.kanidm_name(),
594 e,
595 )
596 })?;
597 }
598
599 if let Some(length) = policy.password_minimum_length {
601 record_kanidm_sdk_call(
602 metrics,
603 KANIDM_RESOURCE_GROUP,
604 KANIDM_OP_ACCOUNT_POLICY,
605 KANIDM_OUTCOME_CHANGED,
606 kanidm_client.group_account_policy_password_minimum_length_set(name, length),
607 )
608 .await
609 .map_err(|e| {
610 Error::kanidm_client_error_attr(
611 "set",
612 "password minimum length",
613 name,
614 self.kanidm_namespace(),
615 self.kanidm_name(),
616 e,
617 )
618 })?;
619 } else {
620 record_kanidm_sdk_call(
621 metrics,
622 KANIDM_RESOURCE_GROUP,
623 KANIDM_OP_ACCOUNT_POLICY,
624 KANIDM_OUTCOME_CHANGED,
625 kanidm_client.group_account_policy_password_minimum_length_reset(name),
626 )
627 .await
628 .map_err(|e| {
629 Error::kanidm_client_error_attr(
630 "reset",
631 "password minimum length",
632 name,
633 self.kanidm_namespace(),
634 self.kanidm_name(),
635 e,
636 )
637 })?;
638 }
639
640 if let Some(expiry) = policy.privilege_expiry {
642 record_kanidm_sdk_call(
643 metrics,
644 KANIDM_RESOURCE_GROUP,
645 KANIDM_OP_ACCOUNT_POLICY,
646 KANIDM_OUTCOME_CHANGED,
647 kanidm_client.group_account_policy_privilege_expiry_set(name, expiry),
648 )
649 .await
650 .map_err(|e| {
651 Error::kanidm_client_error_attr(
652 "set",
653 "privilege expiry",
654 name,
655 self.kanidm_namespace(),
656 self.kanidm_name(),
657 e,
658 )
659 })?;
660 } else {
661 record_kanidm_sdk_call(
662 metrics,
663 KANIDM_RESOURCE_GROUP,
664 KANIDM_OP_ACCOUNT_POLICY,
665 KANIDM_OUTCOME_CHANGED,
666 kanidm_client.group_account_policy_privilege_expiry_reset(name),
667 )
668 .await
669 .map_err(|e| {
670 Error::kanidm_client_error_attr(
671 "reset",
672 "privilege expiry",
673 name,
674 self.kanidm_namespace(),
675 self.kanidm_name(),
676 e,
677 )
678 })?;
679 }
680
681 if let Some(ref ca_list) = policy.webauthn_attestation_ca_list {
683 record_kanidm_sdk_call(
684 metrics,
685 KANIDM_RESOURCE_GROUP,
686 KANIDM_OP_ACCOUNT_POLICY,
687 KANIDM_OUTCOME_CHANGED,
688 kanidm_client.group_account_policy_webauthn_attestation_set(name, ca_list),
689 )
690 .await
691 .map_err(|e| {
692 Error::kanidm_client_error_attr(
693 "set",
694 "webauthn attestation CA list",
695 name,
696 self.kanidm_namespace(),
697 self.kanidm_name(),
698 e,
699 )
700 })?;
701 } else {
702 record_kanidm_sdk_call(
703 metrics,
704 KANIDM_RESOURCE_GROUP,
705 KANIDM_OP_ACCOUNT_POLICY,
706 KANIDM_OUTCOME_CHANGED,
707 kanidm_client.group_account_policy_webauthn_attestation_reset(name),
708 )
709 .await
710 .map_err(|e| {
711 Error::kanidm_client_error_attr(
712 "reset",
713 "webauthn attestation CA list",
714 name,
715 self.kanidm_namespace(),
716 self.kanidm_name(),
717 e,
718 )
719 })?;
720 }
721
722 if let Some(allow) = policy.allow_primary_cred_fallback {
724 record_kanidm_sdk_call(
725 metrics,
726 KANIDM_RESOURCE_GROUP,
727 KANIDM_OP_ACCOUNT_POLICY,
728 KANIDM_OUTCOME_CHANGED,
729 kanidm_client.group_account_policy_allow_primary_cred_fallback(name, allow),
730 )
731 .await
732 .map_err(|e| {
733 Error::kanidm_client_error_attr(
734 "set",
735 ATTR_ALLOW_PRIMARY_CRED_FALLBACK,
736 name,
737 self.kanidm_namespace(),
738 self.kanidm_name(),
739 e,
740 )
741 })?;
742 } else {
743 record_kanidm_sdk_call(
744 metrics,
745 KANIDM_RESOURCE_GROUP,
746 KANIDM_OP_PURGE_ATTR,
747 KANIDM_OUTCOME_CHANGED,
748 kanidm_client.idm_group_purge_attr(name, ATTR_ALLOW_PRIMARY_CRED_FALLBACK),
749 )
750 .await
751 .map_err(|e| {
752 Error::kanidm_client_error_attr(
753 "reset",
754 ATTR_ALLOW_PRIMARY_CRED_FALLBACK,
755 name,
756 self.kanidm_namespace(),
757 self.kanidm_name(),
758 e,
759 )
760 })?;
761 }
762
763 if let Some(max_results) = policy.limit_search_max_results {
765 record_kanidm_sdk_call(
766 metrics,
767 KANIDM_RESOURCE_GROUP,
768 KANIDM_OP_ACCOUNT_POLICY,
769 KANIDM_OUTCOME_CHANGED,
770 kanidm_client.group_account_policy_limit_search_max_results(name, max_results),
771 )
772 .await
773 .map_err(|e| {
774 Error::kanidm_client_error_attr(
775 "set",
776 "limit search max results",
777 name,
778 self.kanidm_namespace(),
779 self.kanidm_name(),
780 e,
781 )
782 })?;
783 } else {
784 record_kanidm_sdk_call(
785 metrics,
786 KANIDM_RESOURCE_GROUP,
787 KANIDM_OP_ACCOUNT_POLICY,
788 KANIDM_OUTCOME_CHANGED,
789 kanidm_client.group_account_policy_limit_search_max_results_reset(name),
790 )
791 .await
792 .map_err(|e| {
793 Error::kanidm_client_error_attr(
794 "reset",
795 "limit search max results",
796 name,
797 self.kanidm_namespace(),
798 self.kanidm_name(),
799 e,
800 )
801 })?;
802 }
803
804 if let Some(max_filter_test) = policy.limit_search_max_filter_test {
806 record_kanidm_sdk_call(
807 metrics,
808 KANIDM_RESOURCE_GROUP,
809 KANIDM_OP_ACCOUNT_POLICY,
810 KANIDM_OUTCOME_CHANGED,
811 kanidm_client
812 .group_account_policy_limit_search_max_filter_test(name, max_filter_test),
813 )
814 .await
815 .map_err(|e| {
816 Error::kanidm_client_error_attr(
817 "set",
818 "limit search max filter test",
819 name,
820 self.kanidm_namespace(),
821 self.kanidm_name(),
822 e,
823 )
824 })?;
825 } else {
826 record_kanidm_sdk_call(
827 metrics,
828 KANIDM_RESOURCE_GROUP,
829 KANIDM_OP_ACCOUNT_POLICY,
830 KANIDM_OUTCOME_CHANGED,
831 kanidm_client.group_account_policy_limit_search_max_filter_test_reset(name),
832 )
833 .await
834 .map_err(|e| {
835 Error::kanidm_client_error_attr(
836 "reset",
837 "limit search max filter test",
838 name,
839 self.kanidm_namespace(),
840 self.kanidm_name(),
841 e,
842 )
843 })?;
844 }
845
846 Ok(())
847 }
848
849 async fn cleanup(
850 &self,
851 kanidm_client: Arc<KanidmClient>,
852 status: KanidmGroupStatus,
853 ctx: Arc<Context<KanidmGroup>>,
854 ) -> Result<(Action, bool)> {
855 let name = &self.kanidm_entity_name();
856 let mut changed = false;
857
858 if is_group(TYPE_EXISTS, status.clone()) {
859 debug!("delete");
860 let start = tokio::time::Instant::now();
861 let result = kanidm_client.idm_group_delete(name).await;
862 match result {
863 Ok(()) => {
864 ctx.metrics.record_kanidm_sdk_outcome(
865 KANIDM_RESOURCE_GROUP,
866 KANIDM_OP_DELETE,
867 KANIDM_OUTCOME_CHANGED,
868 start.elapsed(),
869 );
870 changed = true;
871 }
872 Err(ClientError::Http(status, _, _)) if status == 403 => {
873 debug!("group cannot be deleted (likely a built-in group), skipping deletion");
874 ctx.metrics.record_kanidm_sdk_outcome(
875 KANIDM_RESOURCE_GROUP,
876 KANIDM_OP_DELETE,
877 KANIDM_OUTCOME_UNCHANGED,
878 start.elapsed(),
879 );
880 }
881 Err(e) => {
882 ctx.metrics.record_kanidm_sdk_outcome(
883 KANIDM_RESOURCE_GROUP,
884 KANIDM_OP_DELETE,
885 KANIDM_OUTCOME_ERROR,
886 start.elapsed(),
887 );
888 return Err(Error::kanidm_client_error(
889 "delete",
890 name,
891 self.kanidm_namespace(),
892 self.kanidm_name(),
893 e,
894 ));
895 }
896 }
897 }
898 Ok((Action::requeue(idm_reconcile_interval()), changed))
899 }
900
901 async fn update_status(
902 &self,
903 kanidm_client: Arc<KanidmClient>,
904 ctx: Arc<Context<KanidmGroup>>,
905 ) -> Result<KanidmGroupStatus> {
906 let namespace = self.get_namespace();
908 let name = self.kanidm_entity_name();
909 let start = tokio::time::Instant::now();
910 let current_group = kanidm_client.idm_group_get(&name).await.map_err(|e| {
911 ctx.metrics.record_kanidm_sdk_outcome(
912 KANIDM_RESOURCE_GROUP,
913 KANIDM_OP_GET,
914 KANIDM_OUTCOME_ERROR,
915 start.elapsed(),
916 );
917 Error::kanidm_client_error("get", &name, self.kanidm_namespace(), self.kanidm_name(), e)
918 })?;
919 ctx.metrics.record_kanidm_sdk_outcome(
920 KANIDM_RESOURCE_GROUP,
921 KANIDM_OP_GET,
922 KANIDM_OUTCOME_UNCHANGED,
923 start.elapsed(),
924 );
925
926 let status = self.generate_status(current_group)?;
927 let status_patch = Patch::Apply(KanidmGroup {
928 status: Some(status.clone()),
929 ..KanidmGroup::default()
930 });
931 debug!("updating status");
932 trace!(status_patch = ?status_patch, "status patch");
933 let patch = PatchParams::apply(GROUP_OPERATOR_NAME).force();
934 let kanidm_api = Api::<KanidmGroup>::namespaced(ctx.client.clone(), &namespace);
935 let _o = kanidm_api
936 .patch_status(&self.name_any(), &patch, &status_patch)
937 .await
938 .map_err(|e| Error::kube_status_error("KanidmGroup", namespace, self.name_any(), e))?;
939 Ok(status)
940 }
941
942 fn generate_account_policy_conditions(
948 &self,
949 current: &KanidmGroupAccountPolicyAttributes,
950 now: Timestamp,
951 ) -> Vec<Condition> {
952 let mut conditions = Vec::new();
953
954 if let Some(ref policy) = self.spec.account_policy {
956 let enabled_condition = if current.enabled {
958 Condition {
959 type_: TYPE_ACCOUNT_POLICY_ENABLED.to_string(),
960 status: CONDITION_TRUE.to_string(),
961 reason: "AccountPolicyEnabled".to_string(),
962 message: "Account policy is enabled on this group.".to_string(),
963 last_transition_time: Time(now),
964 observed_generation: self.metadata.generation,
965 }
966 } else {
967 Condition {
968 type_: TYPE_ACCOUNT_POLICY_ENABLED.to_string(),
969 status: CONDITION_FALSE.to_string(),
970 reason: "AccountPolicyNotEnabled".to_string(),
971 message: "Account policy is not enabled on this group.".to_string(),
972 last_transition_time: Time(now),
973 observed_generation: self.metadata.generation,
974 }
975 };
976 conditions.push(enabled_condition);
977
978 if current.enabled {
981 let settings_match = self.account_policy_settings_match(policy, current);
982 let updated_condition = if settings_match {
983 Condition {
984 type_: TYPE_ACCOUNT_POLICY_UPDATED.to_string(),
985 status: CONDITION_TRUE.to_string(),
986 reason: REASON_ATTRIBUTES_MATCH.to_string(),
987 message: "Account policy settings match desired state.".to_string(),
988 last_transition_time: Time(now),
989 observed_generation: self.metadata.generation,
990 }
991 } else {
992 Condition {
993 type_: TYPE_ACCOUNT_POLICY_UPDATED.to_string(),
994 status: CONDITION_FALSE.to_string(),
995 reason: REASON_ATTRIBUTES_NOT_MATCH.to_string(),
996 message: "Account policy settings do not match desired state.".to_string(),
997 last_transition_time: Time(now),
998 observed_generation: self.metadata.generation,
999 }
1000 };
1001 conditions.push(updated_condition);
1002 }
1003 }
1004
1005 conditions
1006 }
1007
1008 fn account_policy_settings_match(
1012 &self,
1013 policy: &crate::crd::KanidmGroupAccountPolicy,
1014 current: &KanidmGroupAccountPolicyAttributes,
1015 ) -> bool {
1016 let auth_session_match = policy.auth_session_expiry == current.auth_session_expiry;
1019
1020 let cred_type_match = policy.credential_type_minimum == current.credential_type_minimum;
1021
1022 let password_len_match = policy.password_minimum_length == current.password_minimum_length;
1023
1024 let privilege_match = policy.privilege_expiry == current.privilege_expiry;
1025
1026 let webauthn_match =
1027 policy.webauthn_attestation_ca_list == current.webauthn_attestation_ca_list;
1028
1029 let primary_cred_match =
1030 policy.allow_primary_cred_fallback == current.allow_primary_cred_fallback;
1031
1032 let max_results_match = policy.limit_search_max_results == current.limit_search_max_results;
1033
1034 let max_filter_match =
1035 policy.limit_search_max_filter_test == current.limit_search_max_filter_test;
1036
1037 auth_session_match
1038 && cred_type_match
1039 && password_len_match
1040 && privilege_match
1041 && webauthn_match
1042 && primary_cred_match
1043 && max_results_match
1044 && max_filter_match
1045 }
1046
1047 fn generate_status(&self, group: Option<Entry>) -> Result<KanidmGroupStatus> {
1048 let now = Timestamp::now();
1049 match group {
1050 Some(g) => {
1051 let exist_condition = Condition {
1052 type_: TYPE_EXISTS.to_string(),
1053 status: CONDITION_TRUE.to_string(),
1054 reason: "Exists".to_string(),
1055 message: "Group exists.".to_string(),
1056 last_transition_time: Time(now),
1057 observed_generation: self.metadata.generation,
1058 };
1059 let managed_by_condition = self.spec.entry_managed_by.as_ref().map(|managed_by| {
1060 if Some(managed_by)
1061 == get_first_cloned(&g, ATTR_ENTRY_MANAGED_BY)
1062 .as_ref()
1063 .map(|s| normalize_spn(s.as_str()))
1064 .as_ref()
1065 {
1066 Condition {
1067 type_: TYPE_MANAGED_UPDATED.to_string(),
1068 status: CONDITION_TRUE.to_string(),
1069 reason: REASON_ATTRIBUTE_MATCH.to_string(),
1070 message: format!(
1071 "Group exists with desired {ATTR_ENTRY_MANAGED_BY} attribute."
1072 ),
1073 last_transition_time: Time(now),
1074 observed_generation: self.metadata.generation,
1075 }
1076 } else {
1077 Condition {
1078 type_: TYPE_MANAGED_UPDATED.to_string(),
1079 status: CONDITION_FALSE.to_string(),
1080 reason: REASON_ATTRIBUTE_NOT_MATCH.to_string(),
1081 message: format!(
1082 "Group exists with different {ATTR_ENTRY_MANAGED_BY} attribute."
1083 ),
1084 last_transition_time: Time(now),
1085 observed_generation: self.metadata.generation,
1086 }
1087 }
1088 });
1089
1090 let description_condition = self.spec.description.as_ref().map(|description| {
1091 let actual = get_first_cloned(&g, ATTR_DESCRIPTION).unwrap_or_default();
1092 let (status, reason, message) = if description == &actual {
1093 (
1094 CONDITION_TRUE,
1095 REASON_ATTRIBUTE_MATCH,
1096 "Group exists with desired description attribute.",
1097 )
1098 } else {
1099 (
1100 CONDITION_FALSE,
1101 REASON_ATTRIBUTE_NOT_MATCH,
1102 "Group exists with different description attribute.",
1103 )
1104 };
1105 Condition {
1106 type_: TYPE_DESCRIPTION_UPDATED.to_string(),
1107 status: status.to_string(),
1108 reason: reason.to_string(),
1109 message: message.to_string(),
1110 last_transition_time: Time(now),
1111 observed_generation: self.metadata.generation,
1112 }
1113 });
1114
1115 let mail_condition = self.spec.mail.as_ref().map(|mail| {
1116 let empty_mail = Vec::new();
1117 let current_mail = g.attrs.get(ATTR_MAIL).unwrap_or(&empty_mail);
1118 if compare_mail(mail, current_mail) {
1119 Condition {
1120 type_: TYPE_MAIL_UPDATED.to_string(),
1121 status: CONDITION_TRUE.to_string(),
1122 reason: REASON_ATTRIBUTE_MATCH.to_string(),
1123 message: format!("Group exists with desired {ATTR_MAIL} attribute."),
1124 last_transition_time: Time(now),
1125 observed_generation: self.metadata.generation,
1126 }
1127 } else {
1128 Condition {
1129 type_: TYPE_MAIL_UPDATED.to_string(),
1130 status: CONDITION_FALSE.to_string(),
1131 reason: REASON_ATTRIBUTE_NOT_MATCH.to_string(),
1132 message: format!("Group exists with different {ATTR_MAIL} attribute."),
1133 last_transition_time: Time(now),
1134 observed_generation: self.metadata.generation,
1135 }
1136 }
1137 });
1138
1139 let members_condition = self.spec.members.as_ref().map(|members| {
1140 if compare_names(members, g.attrs.get(ATTR_MEMBER).unwrap_or(&Vec::new())) {
1141 Condition {
1142 type_: TYPE_MEMBERS_UPDATED.to_string(),
1143 status: CONDITION_TRUE.to_string(),
1144 reason: REASON_ATTRIBUTES_MATCH.to_string(),
1145 message: format!("Group exists with desired {ATTR_MEMBER} attributes."),
1146 last_transition_time: Time(now),
1147 observed_generation: self.metadata.generation,
1148 }
1149 } else {
1150 Condition {
1151 type_: TYPE_MEMBERS_UPDATED.to_string(),
1152 status: CONDITION_FALSE.to_string(),
1153 reason: REASON_ATTRIBUTES_NOT_MATCH.to_string(),
1154 message: format!(
1155 "Group exists with different {ATTR_MEMBER} attributes."
1156 ),
1157 last_transition_time: Time(now),
1158 observed_generation: self.metadata.generation,
1159 }
1160 }
1161 });
1162
1163 let current_account_policy = KanidmGroupAccountPolicyAttributes::from(&g);
1165 let account_policy_conditions =
1166 self.generate_account_policy_conditions(¤t_account_policy, now);
1167
1168 let current_group_posix = KanidmGroupPosixAttributes::from(g);
1169 let posix_initialized_condition = if current_group_posix.gidnumber.is_some() {
1170 Condition {
1171 type_: TYPE_POSIX_INITIALIZED.to_string(),
1172 status: CONDITION_TRUE.to_string(),
1173 reason: "PosixInitialized".to_string(),
1174 message: "Group exists with POSIX attributes.".to_string(),
1175 last_transition_time: Time(now),
1176 observed_generation: self.metadata.generation,
1177 }
1178 } else {
1179 Condition {
1180 type_: TYPE_POSIX_INITIALIZED.to_string(),
1181 status: CONDITION_FALSE.to_string(),
1182 reason: "PosixNotInitialized".to_string(),
1183 message: "Group exists without POSIX attributes.".to_string(),
1184 last_transition_time: Time(now),
1185 observed_generation: self.metadata.generation,
1186 }
1187 };
1188
1189 let posix_updated_condition = self.spec.posix_attributes.as_ref().map(|posix| {
1190 if posix == ¤t_group_posix {
1191 Condition {
1192 type_: TYPE_POSIX_UPDATED.to_string(),
1193 status: CONDITION_TRUE.to_string(),
1194 reason: REASON_ATTRIBUTES_MATCH.to_string(),
1195 message: "Group exists with desired POSIX attributes.".to_string(),
1196 last_transition_time: Time(now),
1197 observed_generation: self.metadata.generation,
1198 }
1199 } else {
1200 Condition {
1201 type_: TYPE_POSIX_UPDATED.to_string(),
1202 status: CONDITION_FALSE.to_string(),
1203 reason: REASON_ATTRIBUTES_NOT_MATCH.to_string(),
1204 message: "Group exists with different POSIX attributes.".to_string(),
1205 last_transition_time: Time(now),
1206 observed_generation: self.metadata.generation,
1207 }
1208 }
1209 });
1210 let conditions = vec![exist_condition, posix_initialized_condition]
1211 .into_iter()
1212 .chain(managed_by_condition)
1213 .chain(description_condition)
1214 .chain(mail_condition)
1215 .chain(members_condition)
1216 .chain(posix_updated_condition)
1217 .chain(account_policy_conditions)
1218 .collect::<Vec<_>>();
1219 let status = conditions
1220 .iter()
1221 .filter(|c| {
1222 c.type_ != TYPE_POSIX_INITIALIZED && c.type_ != TYPE_ACCOUNT_POLICY_ENABLED
1223 })
1224 .all(|c| c.status == CONDITION_TRUE);
1225 Ok(KanidmGroupStatus {
1226 conditions: Some(conditions),
1227 ready: status,
1228 gid: current_group_posix.gidnumber,
1229 kanidm_ref: self.kanidm_ref(),
1230 })
1231 }
1232 None => {
1233 let conditions = vec![Condition {
1234 type_: TYPE_EXISTS.to_string(),
1235 status: CONDITION_FALSE.to_string(),
1236 reason: "NotExists".to_string(),
1237 message: "Group is not present.".to_string(),
1238 last_transition_time: Time(now),
1239 observed_generation: self.metadata.generation,
1240 }];
1241 Ok(KanidmGroupStatus {
1242 conditions: Some(conditions),
1243 ready: false,
1244 gid: None,
1245 kanidm_ref: self.kanidm_ref(),
1246 })
1247 }
1248 }
1249 }
1250}
1251
1252pub fn is_group(type_: &str, status: KanidmGroupStatus) -> bool {
1253 status
1254 .conditions
1255 .unwrap_or_default()
1256 .iter()
1257 .any(|c| c.type_ == type_ && c.status == CONDITION_TRUE)
1258}
1259
1260pub fn is_group_false(type_: &str, status: KanidmGroupStatus) -> bool {
1261 status
1262 .conditions
1263 .unwrap_or_default()
1264 .iter()
1265 .any(|c| c.type_ == type_ && c.status == CONDITION_FALSE)
1266}