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 = "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
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 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 persons_api: Api<KanidmGroup> = Api::namespaced(ctx.client.clone(), &namespace);
99 finalizer(&persons_api, GROUP_FINALIZER, group, |event| async {
100 match event {
101 Finalizer::Apply(p) => p.reconcile(kanidm_client, status, ctx).await,
102 Finalizer::Cleanup(p) => p.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 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 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 if Some(mail) == g.attrs.get(ATTR_MAIL) {
442 Condition {
443 type_: TYPE_MAIL_UPDATED.to_string(),
444 status: CONDITION_TRUE.to_string(),
445 reason: REASON_ATTRIBUTE_MATCH.to_string(),
446 message: format!("Group exists with desired {ATTR_MAIL} attribute."),
447 last_transition_time: Time(now),
448 observed_generation: self.metadata.generation,
449 }
450 } else {
451 Condition {
452 type_: TYPE_MAIL_UPDATED.to_string(),
453 status: CONDITION_FALSE.to_string(),
454 reason: REASON_ATTRIBUTE_NOT_MATCH.to_string(),
455 message: format!("Group exists with different {ATTR_MAIL} attribute."),
456 last_transition_time: Time(now),
457 observed_generation: self.metadata.generation,
458 }
459 }
460 });
461
462 let members_condition = self.spec.members.as_ref().map(|members| {
463 if compare_names(members, g.attrs.get(ATTR_MEMBER).unwrap_or(&Vec::new())) {
464 Condition {
465 type_: TYPE_MEMBERS_UPDATED.to_string(),
466 status: CONDITION_TRUE.to_string(),
467 reason: REASON_ATTRIBUTES_MATCH.to_string(),
468 message: format!("Group exists with desired {ATTR_MEMBER} attributes."),
469 last_transition_time: Time(now),
470 observed_generation: self.metadata.generation,
471 }
472 } else {
473 Condition {
474 type_: TYPE_MEMBERS_UPDATED.to_string(),
475 status: CONDITION_FALSE.to_string(),
476 reason: REASON_ATTRIBUTES_NOT_MATCH.to_string(),
477 message: format!(
478 "Group exists with different {ATTR_MEMBER} attributes."
479 ),
480 last_transition_time: Time(now),
481 observed_generation: self.metadata.generation,
482 }
483 }
484 });
485 let current_group_posix = KanidmGroupPosixAttributes::from(g);
486 let posix_initialized_condition = if current_group_posix.gidnumber.is_some() {
487 Condition {
488 type_: TYPE_POSIX_INITIALIZED.to_string(),
489 status: CONDITION_TRUE.to_string(),
490 reason: "PosixInitialized".to_string(),
491 message: "Group exists with POSIX attributes.".to_string(),
492 last_transition_time: Time(now),
493 observed_generation: self.metadata.generation,
494 }
495 } else {
496 Condition {
497 type_: TYPE_POSIX_INITIALIZED.to_string(),
498 status: CONDITION_FALSE.to_string(),
499 reason: "PosixNotInitialized".to_string(),
500 message: "Group exists without POSIX attributes.".to_string(),
501 last_transition_time: Time(now),
502 observed_generation: self.metadata.generation,
503 }
504 };
505
506 let posix_updated_condition = self.spec.posix_attributes.as_ref().map(|posix| {
507 if posix == ¤t_group_posix {
508 Condition {
509 type_: TYPE_POSIX_UPDATED.to_string(),
510 status: CONDITION_TRUE.to_string(),
511 reason: REASON_ATTRIBUTES_MATCH.to_string(),
512 message: "Group exists with desired POSIX attributes.".to_string(),
513 last_transition_time: Time(now),
514 observed_generation: self.metadata.generation,
515 }
516 } else {
517 Condition {
518 type_: TYPE_POSIX_UPDATED.to_string(),
519 status: CONDITION_FALSE.to_string(),
520 reason: REASON_ATTRIBUTES_NOT_MATCH.to_string(),
521 message: "Group exists with different POSIX attributes.".to_string(),
522 last_transition_time: Time(now),
523 observed_generation: self.metadata.generation,
524 }
525 }
526 });
527 let conditions = vec![exist_condition, posix_initialized_condition]
528 .into_iter()
529 .chain(managed_by_condition)
530 .chain(mail_condition)
531 .chain(members_condition)
532 .chain(posix_updated_condition)
533 .collect::<Vec<_>>();
534 let status = conditions
535 .iter()
536 .filter(|c| c.type_ != TYPE_POSIX_INITIALIZED)
537 .all(|c| c.status == CONDITION_TRUE);
538 Ok(KanidmGroupStatus {
539 conditions: Some(conditions),
540 ready: status,
541 gid: current_group_posix.gidnumber,
542 kanidm_ref: self.kanidm_ref(),
543 })
544 }
545 None => {
546 let conditions = vec![Condition {
547 type_: TYPE_EXISTS.to_string(),
548 status: CONDITION_FALSE.to_string(),
549 reason: "NotExists".to_string(),
550 message: "Group is not present.".to_string(),
551 last_transition_time: Time(now),
552 observed_generation: self.metadata.generation,
553 }];
554 Ok(KanidmGroupStatus {
555 conditions: Some(conditions),
556 ready: false,
557 gid: None,
558 kanidm_ref: self.kanidm_ref(),
559 })
560 }
561 }
562 }
563}
564
565pub fn is_group(type_: &str, status: KanidmGroupStatus) -> bool {
566 status
567 .conditions
568 .unwrap_or_default()
569 .iter()
570 .any(|c| c.type_ == type_ && c.status == CONDITION_TRUE)
571}
572
573pub fn is_group_false(type_: &str, status: KanidmGroupStatus) -> bool {
574 status
575 .conditions
576 .unwrap_or_default()
577 .iter()
578 .any(|c| c.type_ == type_ && c.status == CONDITION_FALSE)
579}