kaniop_group/
reconcile.rs

1use crate::crd::{KanidmGroup, KanidmGroupPosixAttributes, KanidmGroupStatus};
2
3use kaniop_k8s_util::types::{compare_names, get_first_cloned, normalize_spn};
4use kaniop_operator::controller::kanidm::KanidmResource;
5use kaniop_operator::controller::{
6    DEFAULT_RECONCILE_INTERVAL,
7    context::{Context, IdmClientContext},
8};
9use kaniop_operator::error::{Error, Result};
10use kaniop_operator::telemetry;
11
12use std::sync::Arc;
13use std::time::Duration;
14
15use futures::TryFutureExt;
16use k8s_openapi::apimachinery::pkg::apis::meta::v1::{Condition, Time};
17use k8s_openapi::chrono::Utc;
18use kanidm_client::KanidmClient;
19use kanidm_proto::constants::{ATTR_ENTRY_MANAGED_BY, ATTR_MAIL, ATTR_MEMBER};
20use kanidm_proto::v1::Entry;
21use kube::api::{Api, Patch, PatchParams};
22use kube::runtime::controller::Action;
23use kube::runtime::events::{Event, EventType};
24use kube::runtime::finalizer::{Event as Finalizer, finalizer};
25use kube::{Resource, ResourceExt};
26use tracing::{Span, debug, field, info, instrument, trace, warn};
27
28pub static GROUP_OPERATOR_NAME: &str = "kanidmgroups.kaniop.rs";
29pub static GROUP_FINALIZER: &str = "kanidms.kaniop.rs/group";
30
31const TYPE_EXISTS: &str = "Exists";
32const TYPE_MAIL_UPDATED: &str = "MailUpdated";
33const TYPE_MANAGED_UPDATED: &str = "ManagedUpdated";
34const TYPE_MEMBERS_UPDATED: &str = "MembersUpdated";
35const TYPE_POSIX_INITIALIZED: &str = "PosixInitialized";
36const TYPE_POSIX_UPDATED: &str = "PosixUpdated";
37const REASON_ATTRIBUTE_MATCH: &str = "AttributeMatch";
38const REASON_ATTRIBUTE_NOT_MATCH: &str = "AttributeNotMatch";
39const REASON_ATTRIBUTES_MATCH: &str = "AttributesMatch";
40const REASON_ATTRIBUTES_NOT_MATCH: &str = "AttributesNotMatch";
41const CONDITION_TRUE: &str = "True";
42const CONDITION_FALSE: &str = "False";
43
44#[instrument(skip(ctx, group))]
45pub async fn reconcile_group(
46    group: Arc<KanidmGroup>,
47    ctx: Arc<Context<KanidmGroup>>,
48) -> Result<Action> {
49    let trace_id = telemetry::get_trace_id();
50    Span::current().record("trace_id", field::display(&trace_id));
51    let _timer = ctx.metrics.reconcile_count_and_measure(&trace_id);
52    info!(msg = "reconciling group");
53
54    // safe unwrap: group is namespaced scoped
55    let namespace = group.get_namespace();
56    let kanidm_client = ctx.get_idm_client(&group).await?;
57    let status = group
58        .update_status(kanidm_client.clone(), ctx.clone())
59        .await
60        .map_err(|e| {
61            debug!(msg = "failed to reconcile status", %e);
62            ctx.metrics.status_update_errors_inc();
63            e
64        })?;
65    let persons_api: Api<KanidmGroup> = Api::namespaced(ctx.client.clone(), &namespace);
66    finalizer(&persons_api, GROUP_FINALIZER, group, |event| async {
67        match event {
68            Finalizer::Apply(p) => p.reconcile(kanidm_client, status, ctx).await,
69            Finalizer::Cleanup(p) => p.cleanup(kanidm_client, status).await,
70        }
71    })
72    .await
73    .map_err(|e| Error::FinalizerError("failed on group finalizer".to_string(), Box::new(e)))
74}
75
76impl KanidmGroup {
77    #[inline]
78    fn get_namespace(&self) -> String {
79        // safe unwrap: group is namespaced scoped
80        self.namespace().unwrap()
81    }
82
83    #[inline]
84    async fn reconcile(
85        &self,
86        kanidm_client: Arc<KanidmClient>,
87        status: KanidmGroupStatus,
88        ctx: Arc<Context<KanidmGroup>>,
89    ) -> Result<Action> {
90        match self.internal_reconcile(kanidm_client, status).await {
91            Ok(action) => Ok(action),
92            Err(e) => match e {
93                Error::KanidmClientError(_, _) => {
94                    ctx.recorder
95                        .publish(
96                            &Event {
97                                type_: EventType::Warning,
98                                reason: "KanidmError".to_string(),
99                                note: Some(format!("{e:?}")),
100                                action: "KanidmRequest".to_string(),
101                                secondary: None,
102                            },
103                            &self.object_ref(&()),
104                        )
105                        .await
106                        .map_err(|e| {
107                            warn!(msg = "failed to publish KanidmError event", %e);
108                            Error::KubeError("failed to publish event".to_string(), Box::new(e))
109                        })?;
110                    Err(e)
111                }
112                _ => Err(e),
113            },
114        }
115    }
116
117    #[inline]
118    async fn internal_reconcile(
119        &self,
120        kanidm_client: Arc<KanidmClient>,
121        status: KanidmGroupStatus,
122    ) -> Result<Action> {
123        let name = &self.name_any();
124        let mut require_status_update = false;
125        if is_group_false(TYPE_EXISTS, status.clone()) {
126            self.create(&kanidm_client, name).await?;
127            require_status_update = true;
128        }
129
130        if is_group_false(TYPE_MANAGED_UPDATED, status.clone()) {
131            self.update_managed_by(&kanidm_client, name).await?;
132            require_status_update = true;
133        }
134
135        if is_group_false(TYPE_MAIL_UPDATED, status.clone()) {
136            self.update_mail(&kanidm_client, name).await?;
137            require_status_update = true;
138        }
139
140        if is_group_false(TYPE_MEMBERS_UPDATED, status.clone()) {
141            self.update_members(&kanidm_client, name).await?;
142            require_status_update = true;
143        }
144
145        if is_group_false(TYPE_POSIX_UPDATED, status.clone())
146            || (is_group_false(TYPE_POSIX_INITIALIZED, status.clone())
147                && is_group(TYPE_POSIX_UPDATED, status.clone()))
148        {
149            self.update_posix_attributes(&kanidm_client, name).await?;
150            require_status_update = true;
151        }
152
153        if require_status_update {
154            trace!(msg = "status update required, requeueing in 500ms");
155            Ok(Action::requeue(Duration::from_millis(500)))
156        } else {
157            Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL))
158        }
159    }
160
161    async fn create(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
162        debug!(msg = "create");
163        kanidm_client
164            .idm_group_create(name, self.spec.entry_managed_by.as_deref())
165            .await
166            .map_err(|e| {
167                Error::KanidmClientError(
168                    format!(
169                        "failed to create {name} from {namespace}/{kanidm}",
170                        namespace = self.kanidm_namespace(),
171                        kanidm = self.kanidm_name(),
172                    ),
173                    Box::new(e),
174                )
175            })?;
176        Ok(())
177    }
178
179    async fn update_managed_by(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
180        debug!(msg = format!("update {ATTR_ENTRY_MANAGED_BY} attribute"));
181        let entry_managed_by =
182            self.spec.entry_managed_by.as_ref().ok_or_else(|| {
183                Error::MissingData("group entryManagedBy is not defined".to_string())
184            })?;
185
186        kanidm_client
187            .idm_group_set_entry_managed_by(name, entry_managed_by)
188            .await
189            .map_err(|e| {
190                Error::KanidmClientError(
191                    format!(
192                        "failed to update {ATTR_ENTRY_MANAGED_BY} for {name} from {namespace}/{kanidm}",
193                        namespace = self.kanidm_namespace(),
194                        kanidm = self.kanidm_name(),
195                    ),
196                    Box::new(e),
197                )
198            })?;
199        Ok(())
200    }
201
202    async fn update_mail(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
203        debug!(msg = format!("update {ATTR_MAIL} attribute"));
204        let mail = self
205            .spec
206            .mail
207            .as_ref()
208            .ok_or_else(|| Error::MissingData("group mail is not defined".to_string()))?;
209
210        if mail.is_empty() {
211            kanidm_client
212                .idm_group_purge_mail(name)
213                .await
214                .map_err(|e| {
215                    Error::KanidmClientError(
216                        format!(
217                            "failed to purge {ATTR_MAIL} for {name} from {namespace}/{kanidm}",
218                            namespace = self.kanidm_namespace(),
219                            kanidm = self.kanidm_name(),
220                        ),
221                        Box::new(e),
222                    )
223                })?;
224        } else {
225            kanidm_client
226                .idm_group_set_mail(name, mail)
227                .await
228                .map_err(|e| {
229                    Error::KanidmClientError(
230                        format!(
231                            "failed to update {ATTR_MAIL} for {name} from {namespace}/{kanidm}",
232                            namespace = self.kanidm_namespace(),
233                            kanidm = self.kanidm_name(),
234                        ),
235                        Box::new(e),
236                    )
237                })?;
238        }
239        Ok(())
240    }
241
242    async fn update_members(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
243        debug!(msg = format!("update {ATTR_MEMBER} attribute"));
244        let members = self
245            .spec
246            .members
247            .as_ref()
248            .ok_or_else(|| Error::MissingData("group members is not defined".to_string()))?
249            .iter()
250            .map(|m| m.as_str())
251            .collect::<Vec<&str>>();
252
253        kanidm_client
254            .idm_group_set_members(name, &members)
255            .await
256            .map_err(|e| {
257                Error::KanidmClientError(
258                    format!(
259                        "failed to update {ATTR_MEMBER} for {name} from {namespace}/{kanidm}",
260                        namespace = self.kanidm_namespace(),
261                        kanidm = self.kanidm_name(),
262                    ),
263                    Box::new(e),
264                )
265            })?;
266        Ok(())
267    }
268
269    async fn update_posix_attributes(
270        &self,
271        kanidm_client: &KanidmClient,
272        name: &str,
273    ) -> Result<()> {
274        debug!(msg = "update posix attributes");
275        trace!(msg = format!("update posix attributes {:?}", self.spec.posix_attributes));
276        kanidm_client
277            .idm_group_unix_extend(
278                name,
279                self.spec
280                    .posix_attributes
281                    .as_ref()
282                    .and_then(|posix| posix.gidnumber),
283            )
284            .await
285            .map_err(|e| {
286                Error::KanidmClientError(
287                    format!(
288                        "failed to unix extend {name} from {namespace}/{kanidm}",
289                        namespace = self.kanidm_namespace(),
290                        kanidm = self.kanidm_name(),
291                    ),
292                    Box::new(e),
293                )
294            })?;
295        Ok(())
296    }
297
298    async fn cleanup(
299        &self,
300        kanidm_client: Arc<KanidmClient>,
301        status: KanidmGroupStatus,
302    ) -> Result<Action> {
303        let name = &self.name_any();
304
305        if is_group(TYPE_EXISTS, status.clone()) {
306            debug!(msg = "delete");
307            kanidm_client.idm_group_delete(name).await.map_err(|e| {
308                Error::KanidmClientError(
309                    format!(
310                        "failed to delete {name} from {namespace}/{kanidm}",
311                        namespace = self.kanidm_namespace(),
312                        kanidm = self.kanidm_name(),
313                    ),
314                    Box::new(e),
315                )
316            })?;
317        }
318        Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL))
319    }
320
321    async fn update_status(
322        &self,
323        kanidm_client: Arc<KanidmClient>,
324        ctx: Arc<Context<KanidmGroup>>,
325    ) -> Result<KanidmGroupStatus> {
326        // safe unwrap: person is namespaced scoped
327        let namespace = self.get_namespace();
328        let name = self.name_any();
329        let current_group = kanidm_client
330            .idm_group_get(&name)
331            .map_err(|e| {
332                Error::KanidmClientError(
333                    format!(
334                        "failed to get {name} from {namespace}/{kanidm}",
335                        namespace = self.kanidm_namespace(),
336                        kanidm = self.kanidm_name(),
337                    ),
338                    Box::new(e),
339                )
340            })
341            .await?;
342
343        let status = self.generate_status(current_group)?;
344        let status_patch = Patch::Apply(KanidmGroup {
345            status: Some(status.clone()),
346            ..KanidmGroup::default()
347        });
348        debug!(msg = "updating status");
349        trace!(msg = format!("status patch {:?}", status_patch));
350        let patch = PatchParams::apply(GROUP_OPERATOR_NAME).force();
351        let kanidm_api = Api::<KanidmGroup>::namespaced(ctx.client.clone(), &namespace);
352        let _o = kanidm_api
353            .patch_status(&name, &patch, &status_patch)
354            .await
355            .map_err(|e| {
356                Error::KubeError(
357                    format!("failed to patch KanidmGroup/status {namespace}/{name}"),
358                    Box::new(e),
359                )
360            })?;
361        Ok(status)
362    }
363
364    fn generate_status(&self, group: Option<Entry>) -> Result<KanidmGroupStatus> {
365        let now = Utc::now();
366        match group {
367            Some(g) => {
368                let exist_condition = Condition {
369                    type_: TYPE_EXISTS.to_string(),
370                    status: CONDITION_TRUE.to_string(),
371                    reason: "Exists".to_string(),
372                    message: "Group exists.".to_string(),
373                    last_transition_time: Time(now),
374                    observed_generation: self.metadata.generation,
375                };
376                let managed_by_condition = self.spec.entry_managed_by.as_ref().map(|managed_by| {
377                    if Some(managed_by)
378                        == get_first_cloned(&g, ATTR_ENTRY_MANAGED_BY)
379                            .as_ref()
380                            .map(|s| normalize_spn(s.as_str()))
381                            .as_ref()
382                    {
383                        Condition {
384                            type_: TYPE_MANAGED_UPDATED.to_string(),
385                            status: CONDITION_TRUE.to_string(),
386                            reason: REASON_ATTRIBUTE_MATCH.to_string(),
387                            message: format!(
388                                "Group exists with desired {ATTR_ENTRY_MANAGED_BY} attribute."
389                            ),
390                            last_transition_time: Time(now),
391                            observed_generation: self.metadata.generation,
392                        }
393                    } else {
394                        Condition {
395                            type_: TYPE_MANAGED_UPDATED.to_string(),
396                            status: CONDITION_FALSE.to_string(),
397                            reason: REASON_ATTRIBUTE_NOT_MATCH.to_string(),
398                            message: format!(
399                                "Group exists with different {ATTR_ENTRY_MANAGED_BY} attribute."
400                            ),
401                            last_transition_time: Time(now),
402                            observed_generation: self.metadata.generation,
403                        }
404                    }
405                });
406
407                let mail_condition = self.spec.mail.as_ref().map(|mail| {
408                    if Some(mail) == g.attrs.get(ATTR_MAIL) {
409                        Condition {
410                            type_: TYPE_MAIL_UPDATED.to_string(),
411                            status: CONDITION_TRUE.to_string(),
412                            reason: REASON_ATTRIBUTE_MATCH.to_string(),
413                            message: format!("Group exists with desired {ATTR_MAIL} attribute."),
414                            last_transition_time: Time(now),
415                            observed_generation: self.metadata.generation,
416                        }
417                    } else {
418                        Condition {
419                            type_: TYPE_MAIL_UPDATED.to_string(),
420                            status: CONDITION_FALSE.to_string(),
421                            reason: REASON_ATTRIBUTE_NOT_MATCH.to_string(),
422                            message: format!("Group exists with different {ATTR_MAIL} attribute."),
423                            last_transition_time: Time(now),
424                            observed_generation: self.metadata.generation,
425                        }
426                    }
427                });
428
429                let members_condition = self.spec.members.as_ref().map(|members| {
430                    if compare_names(members, g.attrs.get(ATTR_MEMBER).unwrap_or(&Vec::new())) {
431                        Condition {
432                            type_: TYPE_MEMBERS_UPDATED.to_string(),
433                            status: CONDITION_TRUE.to_string(),
434                            reason: REASON_ATTRIBUTES_MATCH.to_string(),
435                            message: format!("Group exists with desired {ATTR_MEMBER} attributes."),
436                            last_transition_time: Time(now),
437                            observed_generation: self.metadata.generation,
438                        }
439                    } else {
440                        Condition {
441                            type_: TYPE_MEMBERS_UPDATED.to_string(),
442                            status: CONDITION_FALSE.to_string(),
443                            reason: REASON_ATTRIBUTES_NOT_MATCH.to_string(),
444                            message: format!(
445                                "Group exists with different {ATTR_MEMBER} attributes."
446                            ),
447                            last_transition_time: Time(now),
448                            observed_generation: self.metadata.generation,
449                        }
450                    }
451                });
452                let current_group_posix = KanidmGroupPosixAttributes::from(g);
453                let posix_initialized_condition = if current_group_posix.gidnumber.is_some() {
454                    Condition {
455                        type_: TYPE_POSIX_INITIALIZED.to_string(),
456                        status: CONDITION_TRUE.to_string(),
457                        reason: "PosixInitialized".to_string(),
458                        message: "Group exists with POSIX attributes.".to_string(),
459                        last_transition_time: Time(now),
460                        observed_generation: self.metadata.generation,
461                    }
462                } else {
463                    Condition {
464                        type_: TYPE_POSIX_INITIALIZED.to_string(),
465                        status: CONDITION_FALSE.to_string(),
466                        reason: "PosixNotInitialized".to_string(),
467                        message: "Group exists without POSIX attributes.".to_string(),
468                        last_transition_time: Time(now),
469                        observed_generation: self.metadata.generation,
470                    }
471                };
472
473                let posix_updated_condition = self.spec.posix_attributes.as_ref().map(|posix| {
474                    if posix == &current_group_posix {
475                        Condition {
476                            type_: TYPE_POSIX_UPDATED.to_string(),
477                            status: CONDITION_TRUE.to_string(),
478                            reason: REASON_ATTRIBUTES_MATCH.to_string(),
479                            message: "Group exists with desired POSIX attributes.".to_string(),
480                            last_transition_time: Time(now),
481                            observed_generation: self.metadata.generation,
482                        }
483                    } else {
484                        Condition {
485                            type_: TYPE_POSIX_UPDATED.to_string(),
486                            status: CONDITION_FALSE.to_string(),
487                            reason: REASON_ATTRIBUTES_NOT_MATCH.to_string(),
488                            message: "Group exists with different POSIX attributes.".to_string(),
489                            last_transition_time: Time(now),
490                            observed_generation: self.metadata.generation,
491                        }
492                    }
493                });
494                let conditions = vec![exist_condition, posix_initialized_condition]
495                    .into_iter()
496                    .chain(managed_by_condition)
497                    .chain(mail_condition)
498                    .chain(members_condition)
499                    .chain(posix_updated_condition)
500                    .collect::<Vec<_>>();
501                let status = conditions
502                    .iter()
503                    .filter(|c| c.type_ != TYPE_POSIX_INITIALIZED)
504                    .all(|c| c.status == CONDITION_TRUE);
505                Ok(KanidmGroupStatus {
506                    conditions: Some(conditions),
507                    ready: status,
508                    gid: current_group_posix.gidnumber,
509                    kanidm_ref: self.kanidm_ref(),
510                })
511            }
512            None => {
513                let conditions = vec![Condition {
514                    type_: TYPE_EXISTS.to_string(),
515                    status: CONDITION_FALSE.to_string(),
516                    reason: "NotExists".to_string(),
517                    message: "Group is not present.".to_string(),
518                    last_transition_time: Time(now),
519                    observed_generation: self.metadata.generation,
520                }];
521                Ok(KanidmGroupStatus {
522                    conditions: Some(conditions),
523                    ready: false,
524                    gid: None,
525                    kanidm_ref: self.kanidm_ref(),
526                })
527            }
528        }
529    }
530}
531
532pub fn is_group(type_: &str, status: KanidmGroupStatus) -> bool {
533    status
534        .conditions
535        .unwrap_or_default()
536        .iter()
537        .any(|c| c.type_ == type_ && c.status == CONDITION_TRUE)
538}
539
540pub fn is_group_false(type_: &str, status: KanidmGroupStatus) -> bool {
541    status
542        .conditions
543        .unwrap_or_default()
544        .iter()
545        .any(|c| c.type_ == type_ && c.status == CONDITION_FALSE)
546}