Skip to main content

kaniop_group/
reconcile.rs

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    // safe unwrap: group is namespaced scoped
106    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        // safe unwrap: group is namespaced scoped
157        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        // Account policy reconciliation: enable first if needed, then update settings
296        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        // Update or reset auth session expiry
517        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        // Update or reset credential type minimum
558        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        // Update or reset password minimum length
600        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        // Update or reset privilege expiry
641        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        // Update or reset webauthn attestation CA list
682        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        // Update or reset allow primary cred fallback
723        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        // Update or reset limit search max results
764        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        // Update or reset limit search max filter test
805        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        // safe unwrap: person is namespaced scoped
907        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    /// Generate account policy conditions by comparing desired spec with current state.
943    ///
944    /// Returns conditions for:
945    /// - AccountPolicyEnabled: Whether account policy is enabled on the group
946    /// - AccountPolicyUpdated: Whether all policy settings match desired state (only if policy is in spec)
947    fn generate_account_policy_conditions(
948        &self,
949        current: &KanidmGroupAccountPolicyAttributes,
950        now: Timestamp,
951    ) -> Vec<Condition> {
952        let mut conditions = Vec::new();
953
954        // Only generate conditions if account_policy is specified in the spec
955        if let Some(ref policy) = self.spec.account_policy {
956            // AccountPolicyEnabled condition - check if policy is enabled in Kanidm
957            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            // AccountPolicyUpdated condition - check if all settings match
979            // Only check if policy is already enabled
980            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    /// Check if account policy settings in spec match current state in Kanidm.
1009    /// When a setting is specified in spec, it must match the current state.
1010    /// When a setting is None in spec, the current state should also be None (reset behavior).
1011    fn account_policy_settings_match(
1012        &self,
1013        policy: &crate::crd::KanidmGroupAccountPolicy,
1014        current: &KanidmGroupAccountPolicyAttributes,
1015    ) -> bool {
1016        // For each setting: if spec has Some(v), current must have Some(v)
1017        // If spec has None, current must also be None (to ensure reset happened)
1018        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                // Account policy conditions
1164                let current_account_policy = KanidmGroupAccountPolicyAttributes::from(&g);
1165                let account_policy_conditions =
1166                    self.generate_account_policy_conditions(&current_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 == &current_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}