1mod secret;
2mod status;
3
4use self::secret::SecretExt;
5use self::status::{
6 CONDITION_FALSE, CONDITION_TRUE, StatusExt, TYPE_ALLOW_LOCALHOST_REDIRECT_UPDATED,
7 TYPE_CLAIMS_MAP_UPDATED, TYPE_DISABLE_CONSENT_PROMPT_UPDATED, TYPE_DISABLE_PKCE_UPDATED,
8 TYPE_EXISTS, TYPE_IMAGE_UPDATED, TYPE_LEGACY_CRYPTO_UPDATED, TYPE_PREFER_SHORT_NAME_UPDATED,
9 TYPE_REDIRECT_URL_UPDATED, TYPE_SCOPE_MAP_UPDATED, TYPE_SECRET_INITIALIZED,
10 TYPE_SECRET_KEY_ALIASES_SYNCED, TYPE_SECRET_ROTATED, TYPE_SECRET_TEMPLATE_SYNCED,
11 TYPE_STRICT_REDIRECT_URL_UPDATED, TYPE_SUP_SCOPE_MAP_UPDATED, TYPE_UPDATED,
12};
13use kaniop_k8s_util::image::{ImageOperation, publish_image_error_event, update_image_if_needed};
14
15use crate::{
16 controller::Context,
17 crd::{
18 KanidmClaimMap, KanidmOAuth2Client, KanidmOAuth2ClientStatus, KanidmScopeMap,
19 OAuth2ClientImageStatus,
20 },
21};
22
23use kanidm_proto::internal::OperationError;
24use kaniop_k8s_util::error::{Error, Result};
25use kaniop_operator::controller::context::{IdmClientContext, KubeOperations};
26use kaniop_operator::controller::idm_reconcile_interval;
27use kaniop_operator::controller::kanidm::{KanidmResource, is_resource_watched};
28use kaniop_operator::metrics::{
29 KANIDM_OP_ADD_ORIGIN, KANIDM_OP_CREATE, KANIDM_OP_DELETE, KANIDM_OP_DELETE_CLAIM_MAP,
30 KANIDM_OP_DELETE_IMAGE, KANIDM_OP_DELETE_SCOPE_MAP, KANIDM_OP_DELETE_SUP_SCOPE_MAP,
31 KANIDM_OP_GET_SECRET, KANIDM_OP_REMOVE_ORIGIN, KANIDM_OP_RESET_SECRET, KANIDM_OP_UPDATE,
32 KANIDM_OP_UPDATE_CLAIM_MAP, KANIDM_OP_UPDATE_CLAIM_MAP_JOIN, KANIDM_OP_UPDATE_IMAGE,
33 KANIDM_OP_UPDATE_SCOPE_MAP, KANIDM_OP_UPDATE_SUP_SCOPE_MAP, KANIDM_OUTCOME_CHANGED,
34 KANIDM_RESOURCE_OAUTH2, record_kanidm_sdk_call,
35};
36use kaniop_operator::object_meta_template::ObjectMetaTemplateExt;
37use kaniop_operator::telemetry;
38
39use std::collections::BTreeSet;
40use std::sync::Arc;
41use std::time::Duration;
42
43use futures::future::TryJoinAll;
44use futures::try_join;
45
46use k8s_openapi::NamespaceResourceScope;
47use k8s_openapi::api::core::v1::Secret;
48use kanidm_client::{ClientError, KanidmClient, StatusCode};
49use kanidm_proto::constants::{
50 ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE, ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT,
51 ATTR_OAUTH2_CONSENT_PROMPT_ENABLE, ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE,
52 ATTR_OAUTH2_PREFER_SHORT_USERNAME, ATTR_OAUTH2_RS_CLAIM_MAP, ATTR_OAUTH2_RS_ORIGIN,
53 ATTR_OAUTH2_RS_SCOPE_MAP, ATTR_OAUTH2_RS_SUP_SCOPE_MAP, ATTR_OAUTH2_STRICT_REDIRECT_URI,
54};
55use kube::api::{Api, Patch, PatchParams};
56use kube::runtime::controller::Action;
57use kube::runtime::events::{Event, EventType};
58use kube::runtime::finalizer::{Error as FinalizerError, Event as Finalizer, finalizer};
59use kube::{Resource, ResourceExt};
60use serde::{Deserialize, Serialize};
61use serde_json::json;
62
63use tracing::{Span, debug, field, info, instrument, trace, warn};
64
65static OAUTH2_OPERATOR_NAME: &str = "kanidmoauth2clients.kaniop.rs";
66static OAUTH2_FINALIZER: &str = "kanidmoauth2clients.kaniop.rs/finalizer";
67pub const FORCE_SECRET_ROTATION_ANNOTATION: &str = "kaniop.rs/force-secret-rotation";
68pub const SECRET_KEY_ALIASES_GENERATION_ANNOTATION: &str =
69 "kaniop.rs/secret-key-aliases-generation";
70
71pub async fn watched_resource(oauth2: &KanidmOAuth2Client, ctx: Arc<Context>) -> bool {
72 let kanidm = if let Some(k) = ctx.kaniop_ctx.get_kanidm(oauth2) {
73 k
74 } else {
75 trace!("no kanidm found");
76 return false;
77 };
78
79 is_resource_watched(
80 oauth2,
81 &kanidm,
82 &ctx.kaniop_ctx.namespace_store,
83 &ctx.kaniop_ctx.client,
84 )
85 .await
86}
87
88#[instrument(skip(ctx, oauth2))]
89pub async fn reconcile_oauth2(
90 oauth2: Arc<KanidmOAuth2Client>,
91 ctx: Arc<Context>,
92) -> Result<(Action, bool)> {
93 let trace_id = telemetry::get_trace_id();
94 Span::current().record("trace_id", field::display(&trace_id));
95 let _timer = ctx
96 .kaniop_ctx
97 .metrics
98 .reconcile_count_and_measure(&trace_id);
99 if !ctx.kaniop_ctx.kanidm_write_allowed(&oauth2) {
100 debug!("Kanidm restore in progress, pausing identity writes");
101 return Ok((Action::requeue(Duration::from_secs(5)), false));
102 }
103 let kanidm_client = ctx.get_idm_client(&oauth2).await?;
104
105 if !watched_resource(&oauth2, ctx.clone()).await {
106 debug!("resource not watched, skipping reconcile");
107 ctx.kaniop_ctx.recorder
108 .publish(
109 &Event {
110 type_: EventType::Warning,
111 reason: "ResourceNotWatched".to_string(),
112 note: Some("configure `oauth2ClientNamespaceSelector` on Kanidm resource to watch this namespace".to_string()),
113 action: "Reconcile".to_string(),
114 secondary: None,
115 },
116 &oauth2.object_ref(&()),
117 )
118 .await
119 .map_err(|e| {
120 warn!(%e, "failed to publish KanidmError event");
121 Error::kube_error("publish", "event", oauth2.get_namespace(), oauth2.name_any(), e)
122 })?;
123 return Ok((Action::requeue(idm_reconcile_interval()), false));
124 }
125
126 info!("reconciling oauth2 client");
127 let namespace = oauth2.get_namespace();
128 let status = oauth2
129 .update_status(kanidm_client.clone(), ctx.clone())
130 .await
131 .map_err(|e| {
132 debug!(%e, "failed to reconcile status");
133 ctx.kaniop_ctx.metrics.status_update_errors_inc();
134 e
135 })?;
136 let persons_api: Api<KanidmOAuth2Client> =
137 Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
138 let outcome = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
139 let outcome_clone = outcome.clone();
140 let action = finalizer(&persons_api, OAUTH2_FINALIZER, oauth2, move |event| {
141 let outcome = outcome_clone.clone();
142 let ctx = ctx.clone();
143 let status = status.clone();
144 let kanidm_client = kanidm_client.clone();
145 async move {
146 match event {
147 Finalizer::Apply(p) => {
148 let (action, changed) = p.reconcile(kanidm_client, status, ctx.clone()).await?;
149 outcome.store(changed, std::sync::atomic::Ordering::Relaxed);
150 Ok(action)
151 }
152 Finalizer::Cleanup(p) => {
153 let (action, changed) = p.cleanup(kanidm_client, status, ctx).await?;
154 outcome.store(changed, std::sync::atomic::Ordering::Relaxed);
155 Ok(action)
156 }
157 }
158 }
159 })
160 .await
161 .or_else(|e| match e {
162 FinalizerError::RemoveFinalizer(kube::Error::Api(ae)) if ae.code == 404 => {
163 debug!("resource already removed during finalizer cleanup");
164 Ok(Action::requeue(idm_reconcile_interval()))
165 }
166 _ => Err(Error::FinalizerError(
167 "failed on oauth2 client finalizer".to_string(),
168 Box::new(e),
169 )),
170 })?;
171 let changed = outcome.load(std::sync::atomic::Ordering::Relaxed);
172 Ok((action, changed))
173}
174
175impl KanidmOAuth2Client {
176 pub async fn patch<K>(&self, ctx: &Context, resource: K) -> Result<K>
178 where
179 K: Resource<Scope = NamespaceResourceScope>
180 + Serialize
181 + Clone
182 + std::fmt::Debug
183 + for<'de> Deserialize<'de>,
184 <K as kube::Resource>::DynamicType: Default,
185 <K as Resource>::Scope: std::marker::Sized,
186 {
187 self.kube_patch(
188 ctx.kaniop_ctx.client.clone(),
189 &ctx.kaniop_ctx.metrics,
190 resource,
191 OAUTH2_OPERATOR_NAME,
192 )
193 .await
194 }
195
196 async fn apply_secret(&self, ctx: &Context, secret: Secret) -> Result<Secret> {
197 self.patch(ctx, secret).await
198 }
199
200 #[inline]
201 fn get_namespace(&self) -> String {
202 self.namespace().unwrap()
204 }
205
206 #[inline]
207 fn force_secret_rotation_requested(&self) -> bool {
208 self.annotations()
209 .get(FORCE_SECRET_ROTATION_ANNOTATION)
210 .is_some()
211 }
212
213 async fn clear_force_secret_rotation_annotation(&self, ctx: Arc<Context>) -> Result<()> {
214 let namespace = self.get_namespace();
215 let patch = Patch::Merge(json!({
216 "metadata": {
217 "annotations": {
218 FORCE_SECRET_ROTATION_ANNOTATION: null
219 }
220 }
221 }));
222 let params = PatchParams::default();
223 let oauth2_api =
224 Api::<KanidmOAuth2Client>::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
225 oauth2_api
226 .patch(&self.name_any(), ¶ms, &patch)
227 .await
228 .map_err(|e| {
229 Error::KubeError(
230 format!(
231 "failed to clear annotation {FORCE_SECRET_ROTATION_ANNOTATION} on {namespace}/{}",
232 self.name_any()
233 ),
234 Box::new(e),
235 )
236 })?;
237 Ok(())
238 }
239
240 async fn patch_alias_generation_annotation(
241 &self,
242 ctx: Arc<Context>,
243 generation: i64,
244 ) -> Result<()> {
245 let namespace = self.get_namespace();
246 let patch = Patch::Merge(json!({
247 "metadata": {
248 "annotations": {
249 SECRET_KEY_ALIASES_GENERATION_ANNOTATION: generation.to_string()
250 }
251 }
252 }));
253 let params = PatchParams::default();
254 let oauth2_api =
255 Api::<KanidmOAuth2Client>::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
256 oauth2_api
257 .patch(&self.name_any(), ¶ms, &patch)
258 .await
259 .map_err(|e| {
260 Error::KubeError(
261 format!(
262 "failed to set annotation {SECRET_KEY_ALIASES_GENERATION_ANNOTATION} on {namespace}/{}",
263 self.name_any()
264 ),
265 Box::new(e),
266 )
267 })?;
268 Ok(())
269 }
270
271 #[inline]
272 async fn reconcile(
273 &self,
274 kanidm_client: Arc<KanidmClient>,
275 status: KanidmOAuth2ClientStatus,
276 ctx: Arc<Context>,
277 ) -> Result<(Action, bool)> {
278 match self
279 .internal_reconcile(kanidm_client, status, ctx.clone())
280 .await
281 {
282 Ok(result) => Ok(result),
283 Err(e) => match &e {
284 Error::KanidmClientError(msg, client_err) => {
285 let event_note = match client_err.as_ref() {
286 ClientError::Http(
287 StatusCode::NOT_FOUND,
288 Some(OperationError::NoMatchingEntries),
289 kopid,
290 ) => {
291 format!("group not found: {msg}. KOpId: {kopid}")
292 }
293 _ => {
294 format!("{msg}: KanidmClientError: {client_err:?}")
295 }
296 };
297 ctx.kaniop_ctx
298 .recorder
299 .publish(
300 &Event {
301 type_: EventType::Warning,
302 reason: "KanidmError".to_string(),
303 note: Some(event_note),
304 action: "KanidmRequest".to_string(),
305 secondary: None,
306 },
307 &self.object_ref(&()),
308 )
309 .await
310 .map_err(|e| {
311 warn!(%e, "failed to publish KanidmError event");
312 Error::kube_error(
313 "publish",
314 "event",
315 self.get_namespace(),
316 self.name_any(),
317 e,
318 )
319 })?;
320 Err(e)
321 }
322 _ => Err(e),
323 },
324 }
325 }
326
327 #[inline]
328 async fn internal_reconcile(
329 &self,
330 kanidm_client: Arc<KanidmClient>,
331 status: KanidmOAuth2ClientStatus,
332 ctx: Arc<Context>,
333 ) -> Result<(Action, bool)> {
334 let name = &self.kanidm_entity_name();
335 let namespace = self.get_namespace();
336 let metrics = &ctx.kaniop_ctx.metrics;
337 let mut require_status_update = false;
338 let mut changed = false;
339 let force_secret_rotation_requested = self.force_secret_rotation_requested();
340
341 if is_oauth2_false(TYPE_EXISTS, status.clone()) {
342 self.create(&kanidm_client, name, metrics).await?;
343 require_status_update = true;
344 changed = true;
345 }
346
347 if is_oauth2_false(TYPE_SECRET_INITIALIZED, status.clone()) {
348 let secret = record_kanidm_sdk_call(
349 metrics,
350 KANIDM_RESOURCE_OAUTH2,
351 KANIDM_OP_GET_SECRET,
352 KANIDM_OUTCOME_CHANGED,
353 self.generate_secret(
354 &kanidm_client,
355 self.spec.secret_rotation.as_ref(),
356 self.spec.secret_key_aliases.as_ref(),
357 ),
358 )
359 .await?;
360 self.apply_secret(&ctx, secret).await?;
361 return Ok((Action::requeue(Duration::from_millis(500)), true));
362 }
363
364 if is_oauth2_false(TYPE_SECRET_KEY_ALIASES_SYNCED, status.clone())
365 && !force_secret_rotation_requested
366 {
367 info!("regenerating secret due to secretKeyAliases not synced");
373 let secret = record_kanidm_sdk_call(
374 metrics,
375 KANIDM_RESOURCE_OAUTH2,
376 KANIDM_OP_GET_SECRET,
377 KANIDM_OUTCOME_CHANGED,
378 self.generate_secret(
379 &kanidm_client,
380 self.spec.secret_rotation.as_ref(),
381 self.spec.secret_key_aliases.as_ref(),
382 ),
383 )
384 .await?;
385 self.apply_secret(&ctx, secret).await?;
386 return Ok((Action::requeue(Duration::from_millis(500)), true));
387 }
388
389 let current_generation = self.metadata.generation.unwrap_or(0);
390 let annotation_generation = self
391 .annotations()
392 .get(SECRET_KEY_ALIASES_GENERATION_ANNOTATION)
393 .and_then(|v| v.parse::<i64>().ok())
394 .unwrap_or(0);
395 if is_oauth2(TYPE_SECRET_KEY_ALIASES_SYNCED, status.clone())
396 && current_generation > annotation_generation
397 {
398 self.patch_alias_generation_annotation(ctx.clone(), current_generation)
401 .await?;
402 require_status_update = true;
403 }
404
405 if force_secret_rotation_requested {
406 if self.spec.public {
407 info!("skipping forced secret rotation annotation for public OAuth2 client");
408 } else {
409 info!("rotating OAuth2 client secret due to force annotation");
410 self.rotate_secret(&kanidm_client, name, ctx.clone(), metrics)
411 .await?;
412 }
413 self.clear_force_secret_rotation_annotation(ctx.clone())
414 .await?;
415 require_status_update = true;
416 changed = true;
417 } else if is_oauth2_false(TYPE_SECRET_ROTATED, status.clone()) {
418 self.rotate_secret(&kanidm_client, name, ctx.clone(), metrics)
420 .await?;
421 require_status_update = true;
422 changed = true;
423 }
424
425 if is_oauth2_false(TYPE_SECRET_TEMPLATE_SYNCED, status.clone()) {
426 match ctx.secret_store.find(|s| {
431 s.name_any() == self.secret_name() && s.namespace().as_ref() == Some(&namespace)
432 }) {
433 None => debug!("secret not yet in store, deferring secretTemplate apply"),
434 Some(secret_meta) => {
435 if let Some(filtered) = self.needs_meta_template_apply(&secret_meta) {
440 if filtered.has_discards() {
441 warn!(discarded_labels = ?filtered.discarded_labels, discarded_annotations = ?filtered.discarded_annotations, "secretTemplate contains keys already owned by the operator; they will be ignored");
442 ctx.kaniop_ctx
443 .recorder
444 .publish(
445 &Event {
446 type_: EventType::Warning,
447 reason: "SecretTemplateConflict".to_string(),
448 note: Some(format!(
449 "secretTemplate contains keys already owned by the \
450 operator and will be ignored. Labels: [{}]. \
451 Annotations: [{}].",
452 filtered
453 .discarded_labels
454 .iter()
455 .cloned()
456 .collect::<Vec<_>>()
457 .join(", "),
458 filtered
459 .discarded_annotations
460 .iter()
461 .cloned()
462 .collect::<Vec<_>>()
463 .join(", "),
464 )),
465 action: "ApplySecretTemplate".to_string(),
466 secondary: None,
467 },
468 &self.object_ref(&()),
469 )
470 .await
471 .map_err(|e| {
472 warn!(%e, "failed to publish SecretTemplateConflict event");
473 Error::kube_error(
474 "publish",
475 "event",
476 self.get_namespace(),
477 self.name_any(),
478 e,
479 )
480 })?;
481 }
482 self.apply_meta_template(
483 ctx.kaniop_ctx.client.clone(),
484 &ctx.kaniop_ctx.metrics,
485 filtered,
486 )
487 .await?;
488 require_status_update = true;
489 changed = true;
490 }
491 }
492 }
493 }
494
495 if is_oauth2_false(TYPE_UPDATED, status.clone()) {
496 self.update(&kanidm_client, name, metrics).await?;
497 require_status_update = true;
498 changed = true;
499 }
500
501 if is_oauth2_false(TYPE_REDIRECT_URL_UPDATED, status.clone()) {
502 self.update_redirect_url(&kanidm_client, name, &status, metrics)
503 .await?;
504 require_status_update = true;
505 changed = true;
506 }
507
508 if is_oauth2_false(TYPE_SCOPE_MAP_UPDATED, status.clone()) {
509 self.update_scope_map(&kanidm_client, name, &status, metrics)
510 .await?;
511 require_status_update = true;
512 changed = true;
513 }
514
515 if is_oauth2_false(TYPE_SUP_SCOPE_MAP_UPDATED, status.clone()) {
516 self.update_sup_scope_map(&kanidm_client, name, &status, metrics)
517 .await?;
518 require_status_update = true;
519 changed = true;
520 }
521
522 if is_oauth2_false(TYPE_CLAIMS_MAP_UPDATED, status.clone()) {
523 self.update_claims_map(&kanidm_client, name, &status, metrics)
524 .await?;
525 require_status_update = true;
526 changed = true;
527 }
528
529 if is_oauth2_false(TYPE_STRICT_REDIRECT_URL_UPDATED, status.clone()) {
530 self.update_strict_redirect_url(&kanidm_client, name, metrics)
531 .await?;
532 require_status_update = true;
533 changed = true;
534 }
535
536 if is_oauth2_false(TYPE_DISABLE_PKCE_UPDATED, status.clone()) {
537 self.update_disable_pkce(&kanidm_client, name, metrics)
538 .await?;
539 require_status_update = true;
540 changed = true;
541 }
542
543 if is_oauth2_false(TYPE_PREFER_SHORT_NAME_UPDATED, status.clone()) {
544 self.update_prefer_short_name(&kanidm_client, name, metrics)
545 .await?;
546 require_status_update = true;
547 changed = true;
548 }
549
550 if is_oauth2_false(TYPE_ALLOW_LOCALHOST_REDIRECT_UPDATED, status.clone()) {
551 self.update_allow_localhost_redirect(&kanidm_client, name, metrics)
552 .await?;
553 require_status_update = true;
554 changed = true;
555 }
556
557 if is_oauth2_false(TYPE_LEGACY_CRYPTO_UPDATED, status.clone()) {
558 self.update_legacy_crypto(&kanidm_client, name, metrics)
559 .await?;
560 require_status_update = true;
561 changed = true;
562 }
563
564 if is_oauth2_false(TYPE_DISABLE_CONSENT_PROMPT_UPDATED, status.clone()) {
565 self.update_consent_prompt(&kanidm_client, name, metrics)
566 .await?;
567 require_status_update = true;
568 changed = true;
569 }
570
571 if is_oauth2_false(TYPE_IMAGE_UPDATED, status.clone()) {
572 let image_changed = self
573 .update_image(&kanidm_client, name, &status, ctx.clone(), metrics)
574 .await?;
575 require_status_update = true;
576 changed = changed || image_changed;
577 }
578
579 if require_status_update {
580 trace!("status update required, requeueing in 500ms");
581 Ok((Action::requeue(Duration::from_millis(500)), changed))
582 } else {
583 Ok((Action::requeue(idm_reconcile_interval()), changed))
584 }
585 }
586
587 async fn create(
588 &self,
589 kanidm_client: &KanidmClient,
590 name: &str,
591 metrics: &kaniop_operator::metrics::ControllerMetrics,
592 ) -> Result<()> {
593 debug!("create");
594 if self.spec.public {
595 debug!("create public client");
596 record_kanidm_sdk_call(
597 metrics,
598 KANIDM_RESOURCE_OAUTH2,
599 KANIDM_OP_CREATE,
600 KANIDM_OUTCOME_CHANGED,
601 kanidm_client.idm_oauth2_rs_public_create(
602 name,
603 &self.spec.displayname,
604 &self.spec.origin,
605 ),
606 )
607 .await
608 .map_err(|e| {
609 Error::kanidm_client_error(
610 "create",
611 name,
612 self.kanidm_namespace(),
613 self.kanidm_name(),
614 e,
615 )
616 })?;
617 } else {
618 record_kanidm_sdk_call(
619 metrics,
620 KANIDM_RESOURCE_OAUTH2,
621 KANIDM_OP_CREATE,
622 KANIDM_OUTCOME_CHANGED,
623 kanidm_client.idm_oauth2_rs_basic_create(
624 name,
625 &self.spec.displayname,
626 &self.spec.origin,
627 ),
628 )
629 .await
630 .map_err(|e| {
631 Error::kanidm_client_error(
632 "create",
633 name,
634 self.kanidm_namespace(),
635 self.kanidm_name(),
636 e,
637 )
638 })?;
639 }
640 Ok(())
641 }
642
643 async fn update(
644 &self,
645 kanidm_client: &KanidmClient,
646 name: &str,
647 metrics: &kaniop_operator::metrics::ControllerMetrics,
648 ) -> Result<()> {
649 debug!("update");
650 record_kanidm_sdk_call(
651 metrics,
652 KANIDM_RESOURCE_OAUTH2,
653 KANIDM_OP_UPDATE,
654 KANIDM_OUTCOME_CHANGED,
655 kanidm_client.idm_oauth2_rs_update(
656 name,
657 None,
658 Some(&self.spec.displayname),
659 Some(&self.spec.origin),
660 false,
661 ),
662 )
663 .await
664 .map_err(|e| {
665 Error::kanidm_client_error(
666 "update",
667 name,
668 self.kanidm_namespace(),
669 self.kanidm_name(),
670 e,
671 )
672 })?;
673 Ok(())
674 }
675
676 async fn rotate_secret(
677 &self,
678 kanidm_client: &KanidmClient,
679 name: &str,
680 ctx: Arc<Context>,
681 metrics: &kaniop_operator::metrics::ControllerMetrics,
682 ) -> Result<()> {
683 info!("rotating OAuth2 client secret");
684 record_kanidm_sdk_call(
686 metrics,
687 KANIDM_RESOURCE_OAUTH2,
688 KANIDM_OP_RESET_SECRET,
689 KANIDM_OUTCOME_CHANGED,
690 kanidm_client.idm_oauth2_rs_update(name, None, None, None, true),
691 )
692 .await
693 .map_err(|e| {
694 Error::kanidm_client_error_attr(
695 "rotate",
696 "secret",
697 name,
698 self.kanidm_namespace(),
699 self.kanidm_name(),
700 e,
701 )
702 })?;
703
704 let secret = record_kanidm_sdk_call(
706 metrics,
707 KANIDM_RESOURCE_OAUTH2,
708 KANIDM_OP_GET_SECRET,
709 KANIDM_OUTCOME_CHANGED,
710 self.generate_secret(
711 kanidm_client,
712 self.spec.secret_rotation.as_ref(),
713 self.spec.secret_key_aliases.as_ref(),
714 ),
715 )
716 .await?;
717 self.apply_secret(&ctx, secret).await?;
718 Ok(())
719 }
720
721 async fn update_redirect_url(
722 &self,
723 kanidm_client: &KanidmClient,
724 name: &str,
725 status: &KanidmOAuth2ClientStatus,
726 metrics: &kaniop_operator::metrics::ControllerMetrics,
727 ) -> Result<()> {
728 debug!("update {ATTR_OAUTH2_RS_ORIGIN} attribute");
729
730 let current_urls: BTreeSet<_> = status
731 .origin
732 .as_ref()
733 .map(|o| o.iter().filter_map(|u| url::Url::parse(u).ok()).collect())
734 .unwrap_or_default();
735
736 let redirect_url = self
737 .spec
738 .redirect_url
739 .iter()
740 .map(|u| {
741 url::Url::parse(u).map_err(|e| {
742 Error::UrlParseError(
743 format!(
744 "failed to parse redirect URL {u} for {name} from {namespace}/{kanidm}",
745 namespace = self.kanidm_namespace(),
746 kanidm = self.kanidm_name(),
747 ),
748 e,
749 )
750 })
751 })
752 .collect::<Result<BTreeSet<_>>>()?;
753
754 let metrics_remove = metrics.clone();
755 let delete_futures = current_urls
756 .difference(&redirect_url)
757 .map(|url| {
758 let metrics = metrics_remove.clone();
759 async move {
760 record_kanidm_sdk_call(
761 &metrics,
762 KANIDM_RESOURCE_OAUTH2,
763 KANIDM_OP_REMOVE_ORIGIN,
764 KANIDM_OUTCOME_CHANGED,
765 kanidm_client.idm_oauth2_client_remove_origin(name, url),
766 )
767 .await
768 }
769 })
770 .collect::<TryJoinAll<_>>();
771
772 let metrics_add = metrics.clone();
773 let add_futures = redirect_url
774 .difference(¤t_urls)
775 .map(|url| {
776 let metrics = metrics_add.clone();
777 async move {
778 record_kanidm_sdk_call(
779 &metrics,
780 KANIDM_RESOURCE_OAUTH2,
781 KANIDM_OP_ADD_ORIGIN,
782 KANIDM_OUTCOME_CHANGED,
783 kanidm_client.idm_oauth2_client_add_origin(name, url),
784 )
785 .await
786 }
787 })
788 .collect::<TryJoinAll<_>>();
789
790 futures::try_join!(delete_futures, add_futures).map_err(|e| {
791 Error::kanidm_client_error_attr(
792 "modify",
793 ATTR_OAUTH2_RS_ORIGIN,
794 name,
795 self.kanidm_namespace(),
796 self.kanidm_name(),
797 e,
798 )
799 })?;
800
801 Ok(())
802 }
803
804 async fn update_scope_map(
805 &self,
806 kanidm_client: &KanidmClient,
807 name: &str,
808 status: &KanidmOAuth2ClientStatus,
809 metrics: &kaniop_operator::metrics::ControllerMetrics,
810 ) -> Result<()> {
811 debug!("update {ATTR_OAUTH2_RS_SCOPE_MAP} attribute");
812
813 let current_scope_map: BTreeSet<_> = status
814 .scope_map
815 .as_ref()
816 .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
817 .unwrap_or_default();
818
819 let scope_map: BTreeSet<KanidmScopeMap> = self
820 .spec
821 .scope_map
822 .clone()
823 .unwrap_or_default()
824 .clone()
825 .into_iter()
826 .collect();
827
828 let metrics_del = metrics.clone();
829 let delete_futures = current_scope_map
830 .difference(&scope_map)
831 .map(|s| {
832 let metrics = metrics_del.clone();
833 async move {
834 record_kanidm_sdk_call(
835 &metrics,
836 KANIDM_RESOURCE_OAUTH2,
837 KANIDM_OP_DELETE_SCOPE_MAP,
838 KANIDM_OUTCOME_CHANGED,
839 kanidm_client.idm_oauth2_rs_delete_scope_map(name, &s.group),
840 )
841 .await
842 }
843 })
844 .collect::<TryJoinAll<_>>();
845
846 let metrics_add = metrics.clone();
847 let add_futures = scope_map
848 .difference(¤t_scope_map)
849 .map(|s| {
850 let metrics = metrics_add.clone();
851 let scopes: Vec<&str> = s.scopes.iter().map(|s| s.as_str()).collect();
852 async move {
853 record_kanidm_sdk_call(
854 &metrics,
855 KANIDM_RESOURCE_OAUTH2,
856 KANIDM_OP_UPDATE_SCOPE_MAP,
857 KANIDM_OUTCOME_CHANGED,
858 kanidm_client.idm_oauth2_rs_update_scope_map(name, &s.group, scopes),
859 )
860 .await
861 }
862 })
863 .collect::<TryJoinAll<_>>();
864
865 try_join!(delete_futures, add_futures).map_err(|e| {
866 Error::kanidm_client_error_attr(
867 "modify",
868 ATTR_OAUTH2_RS_SCOPE_MAP,
869 name,
870 self.kanidm_namespace(),
871 self.kanidm_name(),
872 e,
873 )
874 })?;
875 Ok(())
876 }
877
878 async fn update_sup_scope_map(
879 &self,
880 kanidm_client: &KanidmClient,
881 name: &str,
882 status: &KanidmOAuth2ClientStatus,
883 metrics: &kaniop_operator::metrics::ControllerMetrics,
884 ) -> Result<()> {
885 debug!("update {ATTR_OAUTH2_RS_SUP_SCOPE_MAP} attribute");
886
887 let current_sup_scope_map: BTreeSet<_> = status
888 .sup_scope_map
889 .as_ref()
890 .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
891 .unwrap_or_default();
892
893 let sup_scope_map: BTreeSet<KanidmScopeMap> = self
894 .spec
895 .sup_scope_map
896 .clone()
897 .unwrap_or_default()
898 .clone()
899 .into_iter()
900 .collect();
901
902 let metrics_del = metrics.clone();
903 let delete_futures = current_sup_scope_map
904 .difference(&sup_scope_map)
905 .map(|s| {
906 let metrics = metrics_del.clone();
907 async move {
908 record_kanidm_sdk_call(
909 &metrics,
910 KANIDM_RESOURCE_OAUTH2,
911 KANIDM_OP_DELETE_SUP_SCOPE_MAP,
912 KANIDM_OUTCOME_CHANGED,
913 kanidm_client.idm_oauth2_rs_delete_sup_scope_map(name, &s.group),
914 )
915 .await
916 }
917 })
918 .collect::<TryJoinAll<_>>();
919
920 let metrics_add = metrics.clone();
921 let add_futures = sup_scope_map
922 .difference(¤t_sup_scope_map)
923 .map(|s| {
924 let metrics = metrics_add.clone();
925 let scopes: Vec<&str> = s.scopes.iter().map(|s| s.as_str()).collect();
926 async move {
927 record_kanidm_sdk_call(
928 &metrics,
929 KANIDM_RESOURCE_OAUTH2,
930 KANIDM_OP_UPDATE_SUP_SCOPE_MAP,
931 KANIDM_OUTCOME_CHANGED,
932 kanidm_client.idm_oauth2_rs_update_sup_scope_map(name, &s.group, scopes),
933 )
934 .await
935 }
936 })
937 .collect::<TryJoinAll<_>>();
938
939 try_join!(delete_futures, add_futures).map_err(|e| {
940 Error::kanidm_client_error_attr(
941 "modify",
942 ATTR_OAUTH2_RS_SUP_SCOPE_MAP,
943 name,
944 self.kanidm_namespace(),
945 self.kanidm_name(),
946 e,
947 )
948 })?;
949 Ok(())
950 }
951
952 async fn update_claims_map(
953 &self,
954 kanidm_client: &KanidmClient,
955 name: &str,
956 status: &KanidmOAuth2ClientStatus,
957 metrics: &kaniop_operator::metrics::ControllerMetrics,
958 ) -> Result<()> {
959 debug!("update {ATTR_OAUTH2_RS_CLAIM_MAP} attribute");
960
961 let current_claims_map: BTreeSet<_> = status
962 .claims_map
963 .as_ref()
964 .map(|v| {
965 KanidmClaimMap::group(
966 &v.iter()
967 .filter_map(|c| KanidmClaimMap::from(c))
968 .collect::<Vec<_>>(),
969 )
970 })
971 .unwrap_or_default();
972
973 let claims_map: BTreeSet<KanidmClaimMap> = self
974 .spec
975 .claim_map
976 .clone()
977 .unwrap_or_default()
978 .clone()
979 .into_iter()
980 .collect();
981
982 let metrics_del = metrics.clone();
983 let delete_futures = current_claims_map
984 .difference(&claims_map)
985 .flat_map(|c| {
986 c.values_map
987 .iter()
988 .map(|v| {
989 let metrics = metrics_del.clone();
990 async move {
991 record_kanidm_sdk_call(
992 &metrics,
993 KANIDM_RESOURCE_OAUTH2,
994 KANIDM_OP_DELETE_CLAIM_MAP,
995 KANIDM_OUTCOME_CHANGED,
996 kanidm_client
997 .idm_oauth2_rs_delete_claim_map(name, &c.name, &v.group),
998 )
999 .await
1000 }
1001 })
1002 .collect::<Vec<_>>()
1003 })
1004 .collect::<TryJoinAll<_>>();
1005
1006 let claims_to_add = claims_map.difference(¤t_claims_map);
1007 let metrics_add = metrics.clone();
1008 let add_futures = claims_to_add
1009 .clone()
1010 .flat_map(|c| {
1011 c.values_map
1012 .iter()
1013 .map(|v| {
1014 let metrics = metrics_add.clone();
1015 let values = v.values.clone();
1016 async move {
1017 record_kanidm_sdk_call(
1018 &metrics,
1019 KANIDM_RESOURCE_OAUTH2,
1020 KANIDM_OP_UPDATE_CLAIM_MAP,
1021 KANIDM_OUTCOME_CHANGED,
1022 kanidm_client.idm_oauth2_rs_update_claim_map(
1023 name, &c.name, &v.group, &values,
1024 ),
1025 )
1026 .await
1027 }
1028 })
1029 .collect::<Vec<_>>()
1030 })
1031 .collect::<TryJoinAll<_>>();
1032
1033 let metrics_join = metrics.clone();
1034 let join_strategy_futures = claims_to_add
1035 .map(|c| {
1036 let metrics = metrics_join.clone();
1037 let join_strategy = c.join_strategy.to_oauth2_claim_map_join();
1038 async move {
1039 record_kanidm_sdk_call(
1040 &metrics,
1041 KANIDM_RESOURCE_OAUTH2,
1042 KANIDM_OP_UPDATE_CLAIM_MAP_JOIN,
1043 KANIDM_OUTCOME_CHANGED,
1044 kanidm_client.idm_oauth2_rs_update_claim_map_join(
1045 name,
1046 &c.name,
1047 join_strategy,
1048 ),
1049 )
1050 .await
1051 }
1052 })
1053 .collect::<TryJoinAll<_>>();
1054
1055 try_join!(delete_futures, add_futures, join_strategy_futures).map_err(|e| {
1056 Error::kanidm_client_error_attr(
1057 "modify",
1058 ATTR_OAUTH2_RS_CLAIM_MAP,
1059 name,
1060 self.kanidm_namespace(),
1061 self.kanidm_name(),
1062 e,
1063 )
1064 })?;
1065 Ok(())
1066 }
1067
1068 async fn update_strict_redirect_url(
1069 &self,
1070 kanidm_client: &KanidmClient,
1071 name: &str,
1072 metrics: &kaniop_operator::metrics::ControllerMetrics,
1073 ) -> Result<()> {
1074 debug!("update {ATTR_OAUTH2_STRICT_REDIRECT_URI} attribute");
1075 if let Some(strict_redirect_url_enabled) = self.spec.strict_redirect_url {
1076 if strict_redirect_url_enabled {
1077 record_kanidm_sdk_call(
1078 metrics,
1079 KANIDM_RESOURCE_OAUTH2,
1080 KANIDM_OP_UPDATE,
1081 KANIDM_OUTCOME_CHANGED,
1082 kanidm_client.idm_oauth2_rs_enable_strict_redirect_uri(name),
1083 )
1084 .await
1085 .map_err(|e| {
1086 Error::kanidm_client_error_attr(
1087 "update",
1088 ATTR_OAUTH2_STRICT_REDIRECT_URI,
1089 name,
1090 self.kanidm_namespace(),
1091 self.kanidm_name(),
1092 e,
1093 )
1094 })?;
1095 } else {
1096 record_kanidm_sdk_call(
1097 metrics,
1098 KANIDM_RESOURCE_OAUTH2,
1099 KANIDM_OP_UPDATE,
1100 KANIDM_OUTCOME_CHANGED,
1101 kanidm_client.idm_oauth2_rs_disable_strict_redirect_uri(name),
1102 )
1103 .await
1104 .map_err(|e| {
1105 Error::kanidm_client_error_attr(
1106 "update",
1107 ATTR_OAUTH2_STRICT_REDIRECT_URI,
1108 name,
1109 self.kanidm_namespace(),
1110 self.kanidm_name(),
1111 e,
1112 )
1113 })?;
1114 }
1115 };
1116 Ok(())
1117 }
1118
1119 async fn update_disable_pkce(
1120 &self,
1121 kanidm_client: &KanidmClient,
1122 name: &str,
1123 metrics: &kaniop_operator::metrics::ControllerMetrics,
1124 ) -> Result<()> {
1125 debug!("update {ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE} attribute");
1126 if let Some(disable_pkce) = self.spec.allow_insecure_client_disable_pkce {
1127 if disable_pkce {
1128 record_kanidm_sdk_call(
1129 metrics,
1130 KANIDM_RESOURCE_OAUTH2,
1131 KANIDM_OP_UPDATE,
1132 KANIDM_OUTCOME_CHANGED,
1133 kanidm_client.idm_oauth2_rs_disable_pkce(name),
1134 )
1135 .await
1136 .map_err(|e| {
1137 Error::kanidm_client_error_attr(
1138 "update",
1139 ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE,
1140 name,
1141 self.kanidm_namespace(),
1142 self.kanidm_name(),
1143 e,
1144 )
1145 })?;
1146 } else {
1147 record_kanidm_sdk_call(
1148 metrics,
1149 KANIDM_RESOURCE_OAUTH2,
1150 KANIDM_OP_UPDATE,
1151 KANIDM_OUTCOME_CHANGED,
1152 kanidm_client.idm_oauth2_rs_enable_pkce(name),
1153 )
1154 .await
1155 .map_err(|e| {
1156 Error::kanidm_client_error_attr(
1157 "update",
1158 ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE,
1159 name,
1160 self.kanidm_namespace(),
1161 self.kanidm_name(),
1162 e,
1163 )
1164 })?;
1165 }
1166 };
1167 Ok(())
1168 }
1169
1170 async fn update_prefer_short_name(
1171 &self,
1172 kanidm_client: &KanidmClient,
1173 name: &str,
1174 metrics: &kaniop_operator::metrics::ControllerMetrics,
1175 ) -> Result<()> {
1176 debug!("update {ATTR_OAUTH2_PREFER_SHORT_USERNAME} attribute");
1177 if let Some(prefer_short_username) = self.spec.prefer_short_username {
1178 if prefer_short_username {
1179 record_kanidm_sdk_call(
1180 metrics,
1181 KANIDM_RESOURCE_OAUTH2,
1182 KANIDM_OP_UPDATE,
1183 KANIDM_OUTCOME_CHANGED,
1184 kanidm_client.idm_oauth2_rs_prefer_short_username(name),
1185 )
1186 .await
1187 .map_err(|e| {
1188 Error::kanidm_client_error_attr(
1189 "update",
1190 ATTR_OAUTH2_PREFER_SHORT_USERNAME,
1191 name,
1192 self.kanidm_namespace(),
1193 self.kanidm_name(),
1194 e,
1195 )
1196 })?;
1197 } else {
1198 record_kanidm_sdk_call(
1199 metrics,
1200 KANIDM_RESOURCE_OAUTH2,
1201 KANIDM_OP_UPDATE,
1202 KANIDM_OUTCOME_CHANGED,
1203 kanidm_client.idm_oauth2_rs_prefer_spn_username(name),
1204 )
1205 .await
1206 .map_err(|e| {
1207 Error::kanidm_client_error_attr(
1208 "update",
1209 ATTR_OAUTH2_PREFER_SHORT_USERNAME,
1210 name,
1211 self.kanidm_namespace(),
1212 self.kanidm_name(),
1213 e,
1214 )
1215 })?;
1216 }
1217 };
1218 Ok(())
1219 }
1220
1221 async fn update_allow_localhost_redirect(
1222 &self,
1223 kanidm_client: &KanidmClient,
1224 name: &str,
1225 metrics: &kaniop_operator::metrics::ControllerMetrics,
1226 ) -> Result<()> {
1227 debug!("update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} attribute");
1228 if let Some(allow_localhost_redirect) = self.spec.allow_localhost_redirect {
1229 if allow_localhost_redirect {
1230 record_kanidm_sdk_call(
1231 metrics,
1232 KANIDM_RESOURCE_OAUTH2,
1233 KANIDM_OP_UPDATE,
1234 KANIDM_OUTCOME_CHANGED,
1235 kanidm_client.idm_oauth2_rs_enable_public_localhost_redirect(name),
1236 )
1237 .await
1238 .map_err(|e| {
1239 Error::kanidm_client_error_attr(
1240 "update",
1241 ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT,
1242 name,
1243 self.kanidm_namespace(),
1244 self.kanidm_name(),
1245 e,
1246 )
1247 })?;
1248 } else {
1249 record_kanidm_sdk_call(
1250 metrics,
1251 KANIDM_RESOURCE_OAUTH2,
1252 KANIDM_OP_UPDATE,
1253 KANIDM_OUTCOME_CHANGED,
1254 kanidm_client.idm_oauth2_rs_disable_public_localhost_redirect(name),
1255 )
1256 .await
1257 .map_err(|e| {
1258 Error::kanidm_client_error_attr(
1259 "update",
1260 ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT,
1261 name,
1262 self.kanidm_namespace(),
1263 self.kanidm_name(),
1264 e,
1265 )
1266 })?;
1267 }
1268 };
1269 Ok(())
1270 }
1271
1272 async fn update_legacy_crypto(
1273 &self,
1274 kanidm_client: &KanidmClient,
1275 name: &str,
1276 metrics: &kaniop_operator::metrics::ControllerMetrics,
1277 ) -> Result<()> {
1278 debug!("update {ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE} attribute");
1279 if let Some(legacy_crypto) = self.spec.jwt_legacy_crypto_enable {
1280 if legacy_crypto {
1281 record_kanidm_sdk_call(
1282 metrics,
1283 KANIDM_RESOURCE_OAUTH2,
1284 KANIDM_OP_UPDATE,
1285 KANIDM_OUTCOME_CHANGED,
1286 kanidm_client.idm_oauth2_rs_enable_legacy_crypto(name),
1287 )
1288 .await
1289 .map_err(|e| {
1290 Error::kanidm_client_error_attr(
1291 "update",
1292 ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE,
1293 name,
1294 self.kanidm_namespace(),
1295 self.kanidm_name(),
1296 e,
1297 )
1298 })?;
1299 } else {
1300 record_kanidm_sdk_call(
1301 metrics,
1302 KANIDM_RESOURCE_OAUTH2,
1303 KANIDM_OP_UPDATE,
1304 KANIDM_OUTCOME_CHANGED,
1305 kanidm_client.idm_oauth2_rs_disable_legacy_crypto(name),
1306 )
1307 .await
1308 .map_err(|e| {
1309 Error::kanidm_client_error_attr(
1310 "update",
1311 ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE,
1312 name,
1313 self.kanidm_namespace(),
1314 self.kanidm_name(),
1315 e,
1316 )
1317 })?;
1318 }
1319 };
1320 Ok(())
1321 }
1322
1323 async fn update_consent_prompt(
1324 &self,
1325 kanidm_client: &KanidmClient,
1326 name: &str,
1327 metrics: &kaniop_operator::metrics::ControllerMetrics,
1328 ) -> Result<()> {
1329 debug!("update {ATTR_OAUTH2_CONSENT_PROMPT_ENABLE} attribute");
1330 if let Some(disable_consent_prompt) = self.spec.disable_consent_prompt {
1331 if disable_consent_prompt {
1332 record_kanidm_sdk_call(
1333 metrics,
1334 KANIDM_RESOURCE_OAUTH2,
1335 KANIDM_OP_UPDATE,
1336 KANIDM_OUTCOME_CHANGED,
1337 kanidm_client.idm_oauth2_rs_disable_consent_prompt(name),
1338 )
1339 .await
1340 .map_err(|e| {
1341 Error::kanidm_client_error_attr(
1342 "update",
1343 ATTR_OAUTH2_CONSENT_PROMPT_ENABLE,
1344 name,
1345 self.kanidm_namespace(),
1346 self.kanidm_name(),
1347 e,
1348 )
1349 })?;
1350 } else {
1351 record_kanidm_sdk_call(
1352 metrics,
1353 KANIDM_RESOURCE_OAUTH2,
1354 KANIDM_OP_UPDATE,
1355 KANIDM_OUTCOME_CHANGED,
1356 kanidm_client.idm_oauth2_rs_enable_consent_prompt(name),
1357 )
1358 .await
1359 .map_err(|e| {
1360 Error::kanidm_client_error_attr(
1361 "update",
1362 ATTR_OAUTH2_CONSENT_PROMPT_ENABLE,
1363 name,
1364 self.kanidm_namespace(),
1365 self.kanidm_name(),
1366 e,
1367 )
1368 })?;
1369 }
1370 };
1371 Ok(())
1372 }
1373
1374 async fn update_image(
1375 &self,
1376 kanidm_client: &KanidmClient,
1377 name: &str,
1378 status: &KanidmOAuth2ClientStatus,
1379 ctx: Arc<Context>,
1380 metrics: &kaniop_operator::metrics::ControllerMetrics,
1381 ) -> Result<bool> {
1382 match &self.spec.image {
1383 None => {
1384 debug!("deleting image from OAuth2 client");
1385 record_kanidm_sdk_call(
1386 metrics,
1387 KANIDM_RESOURCE_OAUTH2,
1388 KANIDM_OP_DELETE_IMAGE,
1389 KANIDM_OUTCOME_CHANGED,
1390 kanidm_client.idm_oauth2_rs_delete_image(name),
1391 )
1392 .await
1393 .map_err(|e| {
1394 Error::kanidm_client_error_attr(
1395 "delete",
1396 "image",
1397 name,
1398 self.kanidm_namespace(),
1399 self.kanidm_name(),
1400 e,
1401 )
1402 })?;
1403 Ok(true)
1404 }
1405 Some(image_spec) => {
1406 let url = &image_spec.url;
1407 debug!("updating image for OAuth2 client from {url}");
1408
1409 let namespace = self.kanidm_namespace();
1410 let kanidm = self.kanidm_name();
1411 let namespace_for_closure = namespace.clone();
1412 let kanidm_for_closure = kanidm.clone();
1413 let metrics_clone = metrics.clone();
1414
1415 let update_result =
1416 update_image_if_needed(url, status.image.as_ref(), |image_value| {
1417 let metrics = metrics_clone.clone();
1418 let namespace = namespace_for_closure.clone();
1419 let kanidm = kanidm_for_closure.clone();
1420 async move {
1421 record_kanidm_sdk_call(
1422 &metrics,
1423 KANIDM_RESOURCE_OAUTH2,
1424 KANIDM_OP_UPDATE_IMAGE,
1425 KANIDM_OUTCOME_CHANGED,
1426 kanidm_client.idm_oauth2_rs_update_image(name, image_value),
1427 )
1428 .await
1429 .map_err(|e| {
1430 Error::kanidm_client_error_attr(
1431 "update", "image", name, namespace, kanidm, e,
1432 )
1433 })
1434 }
1435 })
1436 .await;
1437
1438 match update_result {
1439 Ok(Some(updated)) => {
1440 let new_image_status = OAuth2ClientImageStatus {
1441 url: updated.image_status.url,
1442 etag: updated.image_status.etag,
1443 last_modified: updated.image_status.last_modified,
1444 content_length: updated.image_status.content_length,
1445 content_hash: Some(updated.image_status.content_hash),
1446 };
1447
1448 let namespace = self.namespace().unwrap();
1449 let name = self.name_any();
1450 let oauth2_api = Api::<KanidmOAuth2Client>::namespaced(
1451 ctx.kaniop_ctx.client.clone(),
1452 &namespace,
1453 );
1454 let status_patch = Patch::Apply(KanidmOAuth2Client {
1455 status: Some(KanidmOAuth2ClientStatus {
1456 image: Some(new_image_status),
1457 ..status.clone()
1458 }),
1459 ..KanidmOAuth2Client::default()
1460 });
1461 oauth2_api
1462 .patch_status(
1463 &name,
1464 &PatchParams::apply(OAUTH2_OPERATOR_NAME),
1465 &status_patch,
1466 )
1467 .await
1468 .map_err(|e| {
1469 Error::kube_status_error("KanidmOAuth2Client", &namespace, &name, e)
1470 })?;
1471 Ok(true)
1472 }
1473 Ok(None) => Ok(false),
1474 Err(e) => {
1475 let operation = if matches!(e, Error::HttpError(_, _)) {
1476 ImageOperation::Fetch
1477 } else {
1478 ImageOperation::Download
1479 };
1480 Err(publish_image_error_event(
1481 e,
1482 operation,
1483 name,
1484 &namespace,
1485 &kanidm,
1486 &ctx.kaniop_ctx.recorder,
1487 self,
1488 )
1489 .await)
1490 }
1491 }
1492 }
1493 }
1494 }
1495
1496 async fn cleanup(
1497 &self,
1498 kanidm_client: Arc<KanidmClient>,
1499 status: KanidmOAuth2ClientStatus,
1500 ctx: Arc<Context>,
1501 ) -> Result<(Action, bool)> {
1502 let name = &self.kanidm_entity_name();
1503 let mut changed = false;
1504 if is_oauth2(TYPE_EXISTS, status.clone()) {
1505 debug!("delete");
1506 record_kanidm_sdk_call(
1507 &ctx.kaniop_ctx.metrics,
1508 KANIDM_RESOURCE_OAUTH2,
1509 KANIDM_OP_DELETE,
1510 KANIDM_OUTCOME_CHANGED,
1511 kanidm_client.idm_oauth2_rs_delete(name),
1512 )
1513 .await
1514 .map_err(|e| {
1515 Error::kanidm_client_error(
1516 "delete",
1517 name,
1518 self.kanidm_namespace(),
1519 self.kanidm_name(),
1520 e,
1521 )
1522 })?;
1523 changed = true;
1524 }
1525 Ok((Action::requeue(idm_reconcile_interval()), changed))
1526 }
1527}
1528
1529pub fn is_oauth2(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
1530 status
1531 .conditions
1532 .unwrap_or_default()
1533 .iter()
1534 .any(|c| c.type_ == type_ && c.status == CONDITION_TRUE)
1535}
1536
1537pub fn is_oauth2_false(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
1538 status
1539 .conditions
1540 .unwrap_or_default()
1541 .iter()
1542 .any(|c| c.type_ == type_ && c.status == CONDITION_FALSE)
1543}