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