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 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 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 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 == ¤t_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}