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