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!(msg = "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!(msg = "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!(msg = "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!(msg = "failed to publish KanidmError event", %e);
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!(msg = "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!(msg = "failed to reconcile status", %e);
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!(msg = "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!(msg = "failed to publish KanidmError event", %e);
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!(msg = "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!(msg = "skipping forced secret rotation annotation for public OAuth2 client");
408 } else {
409 info!(msg = "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!(msg = "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!(
442 msg = "secretTemplate contains keys already owned by the operator; they will be ignored",
443 discarded_labels = ?filtered.discarded_labels,
444 discarded_annotations = ?filtered.discarded_annotations,
445 );
446 ctx.kaniop_ctx
447 .recorder
448 .publish(
449 &Event {
450 type_: EventType::Warning,
451 reason: "SecretTemplateConflict".to_string(),
452 note: Some(format!(
453 "secretTemplate contains keys already owned by the \
454 operator and will be ignored. Labels: [{}]. \
455 Annotations: [{}].",
456 filtered
457 .discarded_labels
458 .iter()
459 .cloned()
460 .collect::<Vec<_>>()
461 .join(", "),
462 filtered
463 .discarded_annotations
464 .iter()
465 .cloned()
466 .collect::<Vec<_>>()
467 .join(", "),
468 )),
469 action: "ApplySecretTemplate".to_string(),
470 secondary: None,
471 },
472 &self.object_ref(&()),
473 )
474 .await
475 .map_err(|e| {
476 warn!(msg = "failed to publish SecretTemplateConflict event", %e);
477Error::kube_error("publish", "event", self.get_namespace(), self.name_any(), e)
478 })?;
479 }
480 self.apply_meta_template(
481 ctx.kaniop_ctx.client.clone(),
482 &ctx.kaniop_ctx.metrics,
483 filtered,
484 )
485 .await?;
486 require_status_update = true;
487 changed = true;
488 }
489 }
490 }
491 }
492
493 if is_oauth2_false(TYPE_UPDATED, status.clone()) {
494 self.update(&kanidm_client, name, metrics).await?;
495 require_status_update = true;
496 changed = true;
497 }
498
499 if is_oauth2_false(TYPE_REDIRECT_URL_UPDATED, status.clone()) {
500 self.update_redirect_url(&kanidm_client, name, &status, metrics)
501 .await?;
502 require_status_update = true;
503 changed = true;
504 }
505
506 if is_oauth2_false(TYPE_SCOPE_MAP_UPDATED, status.clone()) {
507 self.update_scope_map(&kanidm_client, name, &status, metrics)
508 .await?;
509 require_status_update = true;
510 changed = true;
511 }
512
513 if is_oauth2_false(TYPE_SUP_SCOPE_MAP_UPDATED, status.clone()) {
514 self.update_sup_scope_map(&kanidm_client, name, &status, metrics)
515 .await?;
516 require_status_update = true;
517 changed = true;
518 }
519
520 if is_oauth2_false(TYPE_CLAIMS_MAP_UPDATED, status.clone()) {
521 self.update_claims_map(&kanidm_client, name, &status, metrics)
522 .await?;
523 require_status_update = true;
524 changed = true;
525 }
526
527 if is_oauth2_false(TYPE_STRICT_REDIRECT_URL_UPDATED, status.clone()) {
528 self.update_strict_redirect_url(&kanidm_client, name, metrics)
529 .await?;
530 require_status_update = true;
531 changed = true;
532 }
533
534 if is_oauth2_false(TYPE_DISABLE_PKCE_UPDATED, status.clone()) {
535 self.update_disable_pkce(&kanidm_client, name, metrics)
536 .await?;
537 require_status_update = true;
538 changed = true;
539 }
540
541 if is_oauth2_false(TYPE_PREFER_SHORT_NAME_UPDATED, status.clone()) {
542 self.update_prefer_short_name(&kanidm_client, name, metrics)
543 .await?;
544 require_status_update = true;
545 changed = true;
546 }
547
548 if is_oauth2_false(TYPE_ALLOW_LOCALHOST_REDIRECT_UPDATED, status.clone()) {
549 self.update_allow_localhost_redirect(&kanidm_client, name, metrics)
550 .await?;
551 require_status_update = true;
552 changed = true;
553 }
554
555 if is_oauth2_false(TYPE_LEGACY_CRYPTO_UPDATED, status.clone()) {
556 self.update_legacy_crypto(&kanidm_client, name, metrics)
557 .await?;
558 require_status_update = true;
559 changed = true;
560 }
561
562 if is_oauth2_false(TYPE_DISABLE_CONSENT_PROMPT_UPDATED, status.clone()) {
563 self.update_consent_prompt(&kanidm_client, name, metrics)
564 .await?;
565 require_status_update = true;
566 changed = true;
567 }
568
569 if is_oauth2_false(TYPE_IMAGE_UPDATED, status.clone()) {
570 let image_changed = self
571 .update_image(&kanidm_client, name, &status, ctx.clone(), metrics)
572 .await?;
573 require_status_update = true;
574 changed = changed || image_changed;
575 }
576
577 if require_status_update {
578 trace!(msg = "status update required, requeueing in 500ms");
579 Ok((Action::requeue(Duration::from_millis(500)), changed))
580 } else {
581 Ok((Action::requeue(idm_reconcile_interval()), changed))
582 }
583 }
584
585 async fn create(
586 &self,
587 kanidm_client: &KanidmClient,
588 name: &str,
589 metrics: &kaniop_operator::metrics::ControllerMetrics,
590 ) -> Result<()> {
591 debug!(msg = "create");
592 if self.spec.public {
593 debug!(msg = "create public client");
594 record_kanidm_sdk_call(
595 metrics,
596 KANIDM_RESOURCE_OAUTH2,
597 KANIDM_OP_CREATE,
598 KANIDM_OUTCOME_CHANGED,
599 kanidm_client.idm_oauth2_rs_public_create(
600 name,
601 &self.spec.displayname,
602 &self.spec.origin,
603 ),
604 )
605 .await
606 .map_err(|e| {
607 Error::kanidm_client_error(
608 "create",
609 name,
610 self.kanidm_namespace(),
611 self.kanidm_name(),
612 e,
613 )
614 })?;
615 } else {
616 record_kanidm_sdk_call(
617 metrics,
618 KANIDM_RESOURCE_OAUTH2,
619 KANIDM_OP_CREATE,
620 KANIDM_OUTCOME_CHANGED,
621 kanidm_client.idm_oauth2_rs_basic_create(
622 name,
623 &self.spec.displayname,
624 &self.spec.origin,
625 ),
626 )
627 .await
628 .map_err(|e| {
629 Error::kanidm_client_error(
630 "create",
631 name,
632 self.kanidm_namespace(),
633 self.kanidm_name(),
634 e,
635 )
636 })?;
637 }
638 Ok(())
639 }
640
641 async fn update(
642 &self,
643 kanidm_client: &KanidmClient,
644 name: &str,
645 metrics: &kaniop_operator::metrics::ControllerMetrics,
646 ) -> Result<()> {
647 debug!(msg = "update");
648 record_kanidm_sdk_call(
649 metrics,
650 KANIDM_RESOURCE_OAUTH2,
651 KANIDM_OP_UPDATE,
652 KANIDM_OUTCOME_CHANGED,
653 kanidm_client.idm_oauth2_rs_update(
654 name,
655 None,
656 Some(&self.spec.displayname),
657 Some(&self.spec.origin),
658 false,
659 ),
660 )
661 .await
662 .map_err(|e| {
663 Error::kanidm_client_error(
664 "update",
665 name,
666 self.kanidm_namespace(),
667 self.kanidm_name(),
668 e,
669 )
670 })?;
671 Ok(())
672 }
673
674 async fn rotate_secret(
675 &self,
676 kanidm_client: &KanidmClient,
677 name: &str,
678 ctx: Arc<Context>,
679 metrics: &kaniop_operator::metrics::ControllerMetrics,
680 ) -> Result<()> {
681 info!(msg = "rotating OAuth2 client secret");
682 record_kanidm_sdk_call(
684 metrics,
685 KANIDM_RESOURCE_OAUTH2,
686 KANIDM_OP_RESET_SECRET,
687 KANIDM_OUTCOME_CHANGED,
688 kanidm_client.idm_oauth2_rs_update(name, None, None, None, true),
689 )
690 .await
691 .map_err(|e| {
692 Error::kanidm_client_error_attr(
693 "rotate",
694 "secret",
695 name,
696 self.kanidm_namespace(),
697 self.kanidm_name(),
698 e,
699 )
700 })?;
701
702 let secret = record_kanidm_sdk_call(
704 metrics,
705 KANIDM_RESOURCE_OAUTH2,
706 KANIDM_OP_GET_SECRET,
707 KANIDM_OUTCOME_CHANGED,
708 self.generate_secret(
709 kanidm_client,
710 self.spec.secret_rotation.as_ref(),
711 self.spec.secret_key_aliases.as_ref(),
712 ),
713 )
714 .await?;
715 self.apply_secret(&ctx, secret).await?;
716 Ok(())
717 }
718
719 async fn update_redirect_url(
720 &self,
721 kanidm_client: &KanidmClient,
722 name: &str,
723 status: &KanidmOAuth2ClientStatus,
724 metrics: &kaniop_operator::metrics::ControllerMetrics,
725 ) -> Result<()> {
726 debug!(msg = format!("update {ATTR_OAUTH2_RS_ORIGIN} attribute"));
727
728 let current_urls: BTreeSet<_> = status
729 .origin
730 .as_ref()
731 .map(|o| o.iter().filter_map(|u| url::Url::parse(u).ok()).collect())
732 .unwrap_or_default();
733
734 let redirect_url = self
735 .spec
736 .redirect_url
737 .iter()
738 .map(|u| {
739 url::Url::parse(u).map_err(|e| {
740 Error::UrlParseError(
741 format!(
742 "failed to parse redirect URL {u} for {name} from {namespace}/{kanidm}",
743 namespace = self.kanidm_namespace(),
744 kanidm = self.kanidm_name(),
745 ),
746 e,
747 )
748 })
749 })
750 .collect::<Result<BTreeSet<_>>>()?;
751
752 let metrics_remove = metrics.clone();
753 let delete_futures = current_urls
754 .difference(&redirect_url)
755 .map(|url| {
756 let metrics = metrics_remove.clone();
757 async move {
758 record_kanidm_sdk_call(
759 &metrics,
760 KANIDM_RESOURCE_OAUTH2,
761 KANIDM_OP_REMOVE_ORIGIN,
762 KANIDM_OUTCOME_CHANGED,
763 kanidm_client.idm_oauth2_client_remove_origin(name, url),
764 )
765 .await
766 }
767 })
768 .collect::<TryJoinAll<_>>();
769
770 let metrics_add = metrics.clone();
771 let add_futures = redirect_url
772 .difference(¤t_urls)
773 .map(|url| {
774 let metrics = metrics_add.clone();
775 async move {
776 record_kanidm_sdk_call(
777 &metrics,
778 KANIDM_RESOURCE_OAUTH2,
779 KANIDM_OP_ADD_ORIGIN,
780 KANIDM_OUTCOME_CHANGED,
781 kanidm_client.idm_oauth2_client_add_origin(name, url),
782 )
783 .await
784 }
785 })
786 .collect::<TryJoinAll<_>>();
787
788 futures::try_join!(delete_futures, add_futures).map_err(|e| {
789 Error::kanidm_client_error_attr(
790 "modify",
791 ATTR_OAUTH2_RS_ORIGIN,
792 name,
793 self.kanidm_namespace(),
794 self.kanidm_name(),
795 e,
796 )
797 })?;
798
799 Ok(())
800 }
801
802 async fn update_scope_map(
803 &self,
804 kanidm_client: &KanidmClient,
805 name: &str,
806 status: &KanidmOAuth2ClientStatus,
807 metrics: &kaniop_operator::metrics::ControllerMetrics,
808 ) -> Result<()> {
809 debug!(msg = format!("update {ATTR_OAUTH2_RS_SCOPE_MAP} attribute"));
810
811 let current_scope_map: BTreeSet<_> = status
812 .scope_map
813 .as_ref()
814 .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
815 .unwrap_or_default();
816
817 let scope_map: BTreeSet<KanidmScopeMap> = self
818 .spec
819 .scope_map
820 .clone()
821 .unwrap_or_default()
822 .clone()
823 .into_iter()
824 .collect();
825
826 let metrics_del = metrics.clone();
827 let delete_futures = current_scope_map
828 .difference(&scope_map)
829 .map(|s| {
830 let metrics = metrics_del.clone();
831 async move {
832 record_kanidm_sdk_call(
833 &metrics,
834 KANIDM_RESOURCE_OAUTH2,
835 KANIDM_OP_DELETE_SCOPE_MAP,
836 KANIDM_OUTCOME_CHANGED,
837 kanidm_client.idm_oauth2_rs_delete_scope_map(name, &s.group),
838 )
839 .await
840 }
841 })
842 .collect::<TryJoinAll<_>>();
843
844 let metrics_add = metrics.clone();
845 let add_futures = scope_map
846 .difference(¤t_scope_map)
847 .map(|s| {
848 let metrics = metrics_add.clone();
849 let scopes: Vec<&str> = s.scopes.iter().map(|s| s.as_str()).collect();
850 async move {
851 record_kanidm_sdk_call(
852 &metrics,
853 KANIDM_RESOURCE_OAUTH2,
854 KANIDM_OP_UPDATE_SCOPE_MAP,
855 KANIDM_OUTCOME_CHANGED,
856 kanidm_client.idm_oauth2_rs_update_scope_map(name, &s.group, scopes),
857 )
858 .await
859 }
860 })
861 .collect::<TryJoinAll<_>>();
862
863 try_join!(delete_futures, add_futures).map_err(|e| {
864 Error::kanidm_client_error_attr(
865 "modify",
866 ATTR_OAUTH2_RS_SCOPE_MAP,
867 name,
868 self.kanidm_namespace(),
869 self.kanidm_name(),
870 e,
871 )
872 })?;
873 Ok(())
874 }
875
876 async fn update_sup_scope_map(
877 &self,
878 kanidm_client: &KanidmClient,
879 name: &str,
880 status: &KanidmOAuth2ClientStatus,
881 metrics: &kaniop_operator::metrics::ControllerMetrics,
882 ) -> Result<()> {
883 debug!(msg = format!("update {ATTR_OAUTH2_RS_SUP_SCOPE_MAP} attribute"));
884
885 let current_sup_scope_map: BTreeSet<_> = status
886 .sup_scope_map
887 .as_ref()
888 .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
889 .unwrap_or_default();
890
891 let sup_scope_map: BTreeSet<KanidmScopeMap> = self
892 .spec
893 .sup_scope_map
894 .clone()
895 .unwrap_or_default()
896 .clone()
897 .into_iter()
898 .collect();
899
900 let metrics_del = metrics.clone();
901 let delete_futures = current_sup_scope_map
902 .difference(&sup_scope_map)
903 .map(|s| {
904 let metrics = metrics_del.clone();
905 async move {
906 record_kanidm_sdk_call(
907 &metrics,
908 KANIDM_RESOURCE_OAUTH2,
909 KANIDM_OP_DELETE_SUP_SCOPE_MAP,
910 KANIDM_OUTCOME_CHANGED,
911 kanidm_client.idm_oauth2_rs_delete_sup_scope_map(name, &s.group),
912 )
913 .await
914 }
915 })
916 .collect::<TryJoinAll<_>>();
917
918 let metrics_add = metrics.clone();
919 let add_futures = sup_scope_map
920 .difference(¤t_sup_scope_map)
921 .map(|s| {
922 let metrics = metrics_add.clone();
923 let scopes: Vec<&str> = s.scopes.iter().map(|s| s.as_str()).collect();
924 async move {
925 record_kanidm_sdk_call(
926 &metrics,
927 KANIDM_RESOURCE_OAUTH2,
928 KANIDM_OP_UPDATE_SUP_SCOPE_MAP,
929 KANIDM_OUTCOME_CHANGED,
930 kanidm_client.idm_oauth2_rs_update_sup_scope_map(name, &s.group, scopes),
931 )
932 .await
933 }
934 })
935 .collect::<TryJoinAll<_>>();
936
937 try_join!(delete_futures, add_futures).map_err(|e| {
938 Error::kanidm_client_error_attr(
939 "modify",
940 ATTR_OAUTH2_RS_SUP_SCOPE_MAP,
941 name,
942 self.kanidm_namespace(),
943 self.kanidm_name(),
944 e,
945 )
946 })?;
947 Ok(())
948 }
949
950 async fn update_claims_map(
951 &self,
952 kanidm_client: &KanidmClient,
953 name: &str,
954 status: &KanidmOAuth2ClientStatus,
955 metrics: &kaniop_operator::metrics::ControllerMetrics,
956 ) -> Result<()> {
957 debug!(msg = format!("update {ATTR_OAUTH2_RS_CLAIM_MAP} attribute"));
958
959 let current_claims_map: BTreeSet<_> = status
960 .claims_map
961 .as_ref()
962 .map(|v| {
963 KanidmClaimMap::group(
964 &v.iter()
965 .filter_map(|c| KanidmClaimMap::from(c))
966 .collect::<Vec<_>>(),
967 )
968 })
969 .unwrap_or_default();
970
971 let claims_map: BTreeSet<KanidmClaimMap> = self
972 .spec
973 .claim_map
974 .clone()
975 .unwrap_or_default()
976 .clone()
977 .into_iter()
978 .collect();
979
980 let metrics_del = metrics.clone();
981 let delete_futures = current_claims_map
982 .difference(&claims_map)
983 .flat_map(|c| {
984 c.values_map
985 .iter()
986 .map(|v| {
987 let metrics = metrics_del.clone();
988 async move {
989 record_kanidm_sdk_call(
990 &metrics,
991 KANIDM_RESOURCE_OAUTH2,
992 KANIDM_OP_DELETE_CLAIM_MAP,
993 KANIDM_OUTCOME_CHANGED,
994 kanidm_client
995 .idm_oauth2_rs_delete_claim_map(name, &c.name, &v.group),
996 )
997 .await
998 }
999 })
1000 .collect::<Vec<_>>()
1001 })
1002 .collect::<TryJoinAll<_>>();
1003
1004 let claims_to_add = claims_map.difference(¤t_claims_map);
1005 let metrics_add = metrics.clone();
1006 let add_futures = claims_to_add
1007 .clone()
1008 .flat_map(|c| {
1009 c.values_map
1010 .iter()
1011 .map(|v| {
1012 let metrics = metrics_add.clone();
1013 let values = v.values.clone();
1014 async move {
1015 record_kanidm_sdk_call(
1016 &metrics,
1017 KANIDM_RESOURCE_OAUTH2,
1018 KANIDM_OP_UPDATE_CLAIM_MAP,
1019 KANIDM_OUTCOME_CHANGED,
1020 kanidm_client.idm_oauth2_rs_update_claim_map(
1021 name, &c.name, &v.group, &values,
1022 ),
1023 )
1024 .await
1025 }
1026 })
1027 .collect::<Vec<_>>()
1028 })
1029 .collect::<TryJoinAll<_>>();
1030
1031 let metrics_join = metrics.clone();
1032 let join_strategy_futures = claims_to_add
1033 .map(|c| {
1034 let metrics = metrics_join.clone();
1035 let join_strategy = c.join_strategy.to_oauth2_claim_map_join();
1036 async move {
1037 record_kanidm_sdk_call(
1038 &metrics,
1039 KANIDM_RESOURCE_OAUTH2,
1040 KANIDM_OP_UPDATE_CLAIM_MAP_JOIN,
1041 KANIDM_OUTCOME_CHANGED,
1042 kanidm_client.idm_oauth2_rs_update_claim_map_join(
1043 name,
1044 &c.name,
1045 join_strategy,
1046 ),
1047 )
1048 .await
1049 }
1050 })
1051 .collect::<TryJoinAll<_>>();
1052
1053 try_join!(delete_futures, add_futures, join_strategy_futures).map_err(|e| {
1054 Error::kanidm_client_error_attr(
1055 "modify",
1056 ATTR_OAUTH2_RS_CLAIM_MAP,
1057 name,
1058 self.kanidm_namespace(),
1059 self.kanidm_name(),
1060 e,
1061 )
1062 })?;
1063 Ok(())
1064 }
1065
1066 async fn update_strict_redirect_url(
1067 &self,
1068 kanidm_client: &KanidmClient,
1069 name: &str,
1070 metrics: &kaniop_operator::metrics::ControllerMetrics,
1071 ) -> Result<()> {
1072 debug!(msg = format!("update {ATTR_OAUTH2_STRICT_REDIRECT_URI} attribute"));
1073 if let Some(strict_redirect_url_enabled) = self.spec.strict_redirect_url {
1074 if strict_redirect_url_enabled {
1075 record_kanidm_sdk_call(
1076 metrics,
1077 KANIDM_RESOURCE_OAUTH2,
1078 KANIDM_OP_UPDATE,
1079 KANIDM_OUTCOME_CHANGED,
1080 kanidm_client.idm_oauth2_rs_enable_strict_redirect_uri(name),
1081 )
1082 .await
1083 .map_err(|e| {
1084 Error::kanidm_client_error_attr(
1085 "update",
1086 ATTR_OAUTH2_STRICT_REDIRECT_URI,
1087 name,
1088 self.kanidm_namespace(),
1089 self.kanidm_name(),
1090 e,
1091 )
1092 })?;
1093 } else {
1094 record_kanidm_sdk_call(
1095 metrics,
1096 KANIDM_RESOURCE_OAUTH2,
1097 KANIDM_OP_UPDATE,
1098 KANIDM_OUTCOME_CHANGED,
1099 kanidm_client.idm_oauth2_rs_disable_strict_redirect_uri(name),
1100 )
1101 .await
1102 .map_err(|e| {
1103 Error::kanidm_client_error_attr(
1104 "update",
1105 ATTR_OAUTH2_STRICT_REDIRECT_URI,
1106 name,
1107 self.kanidm_namespace(),
1108 self.kanidm_name(),
1109 e,
1110 )
1111 })?;
1112 }
1113 };
1114 Ok(())
1115 }
1116
1117 async fn update_disable_pkce(
1118 &self,
1119 kanidm_client: &KanidmClient,
1120 name: &str,
1121 metrics: &kaniop_operator::metrics::ControllerMetrics,
1122 ) -> Result<()> {
1123 debug!(msg = format!("update {ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE} attribute"));
1124 if let Some(disable_pkce) = self.spec.allow_insecure_client_disable_pkce {
1125 if disable_pkce {
1126 record_kanidm_sdk_call(
1127 metrics,
1128 KANIDM_RESOURCE_OAUTH2,
1129 KANIDM_OP_UPDATE,
1130 KANIDM_OUTCOME_CHANGED,
1131 kanidm_client.idm_oauth2_rs_disable_pkce(name),
1132 )
1133 .await
1134 .map_err(|e| {
1135 Error::kanidm_client_error_attr(
1136 "update",
1137 ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE,
1138 name,
1139 self.kanidm_namespace(),
1140 self.kanidm_name(),
1141 e,
1142 )
1143 })?;
1144 } else {
1145 record_kanidm_sdk_call(
1146 metrics,
1147 KANIDM_RESOURCE_OAUTH2,
1148 KANIDM_OP_UPDATE,
1149 KANIDM_OUTCOME_CHANGED,
1150 kanidm_client.idm_oauth2_rs_enable_pkce(name),
1151 )
1152 .await
1153 .map_err(|e| {
1154 Error::kanidm_client_error_attr(
1155 "update",
1156 ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE,
1157 name,
1158 self.kanidm_namespace(),
1159 self.kanidm_name(),
1160 e,
1161 )
1162 })?;
1163 }
1164 };
1165 Ok(())
1166 }
1167
1168 async fn update_prefer_short_name(
1169 &self,
1170 kanidm_client: &KanidmClient,
1171 name: &str,
1172 metrics: &kaniop_operator::metrics::ControllerMetrics,
1173 ) -> Result<()> {
1174 debug!(msg = format!("update {ATTR_OAUTH2_PREFER_SHORT_USERNAME} attribute"));
1175 if let Some(prefer_short_username) = self.spec.prefer_short_username {
1176 if prefer_short_username {
1177 record_kanidm_sdk_call(
1178 metrics,
1179 KANIDM_RESOURCE_OAUTH2,
1180 KANIDM_OP_UPDATE,
1181 KANIDM_OUTCOME_CHANGED,
1182 kanidm_client.idm_oauth2_rs_prefer_short_username(name),
1183 )
1184 .await
1185 .map_err(|e| {
1186 Error::kanidm_client_error_attr(
1187 "update",
1188 ATTR_OAUTH2_PREFER_SHORT_USERNAME,
1189 name,
1190 self.kanidm_namespace(),
1191 self.kanidm_name(),
1192 e,
1193 )
1194 })?;
1195 } else {
1196 record_kanidm_sdk_call(
1197 metrics,
1198 KANIDM_RESOURCE_OAUTH2,
1199 KANIDM_OP_UPDATE,
1200 KANIDM_OUTCOME_CHANGED,
1201 kanidm_client.idm_oauth2_rs_prefer_spn_username(name),
1202 )
1203 .await
1204 .map_err(|e| {
1205 Error::kanidm_client_error_attr(
1206 "update",
1207 ATTR_OAUTH2_PREFER_SHORT_USERNAME,
1208 name,
1209 self.kanidm_namespace(),
1210 self.kanidm_name(),
1211 e,
1212 )
1213 })?;
1214 }
1215 };
1216 Ok(())
1217 }
1218
1219 async fn update_allow_localhost_redirect(
1220 &self,
1221 kanidm_client: &KanidmClient,
1222 name: &str,
1223 metrics: &kaniop_operator::metrics::ControllerMetrics,
1224 ) -> Result<()> {
1225 debug!(msg = format!("update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} attribute"));
1226 if let Some(allow_localhost_redirect) = self.spec.allow_localhost_redirect {
1227 if allow_localhost_redirect {
1228 record_kanidm_sdk_call(
1229 metrics,
1230 KANIDM_RESOURCE_OAUTH2,
1231 KANIDM_OP_UPDATE,
1232 KANIDM_OUTCOME_CHANGED,
1233 kanidm_client.idm_oauth2_rs_enable_public_localhost_redirect(name),
1234 )
1235 .await
1236 .map_err(|e| {
1237 Error::kanidm_client_error_attr(
1238 "update",
1239 ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT,
1240 name,
1241 self.kanidm_namespace(),
1242 self.kanidm_name(),
1243 e,
1244 )
1245 })?;
1246 } else {
1247 record_kanidm_sdk_call(
1248 metrics,
1249 KANIDM_RESOURCE_OAUTH2,
1250 KANIDM_OP_UPDATE,
1251 KANIDM_OUTCOME_CHANGED,
1252 kanidm_client.idm_oauth2_rs_disable_public_localhost_redirect(name),
1253 )
1254 .await
1255 .map_err(|e| {
1256 Error::kanidm_client_error_attr(
1257 "update",
1258 ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT,
1259 name,
1260 self.kanidm_namespace(),
1261 self.kanidm_name(),
1262 e,
1263 )
1264 })?;
1265 }
1266 };
1267 Ok(())
1268 }
1269
1270 async fn update_legacy_crypto(
1271 &self,
1272 kanidm_client: &KanidmClient,
1273 name: &str,
1274 metrics: &kaniop_operator::metrics::ControllerMetrics,
1275 ) -> Result<()> {
1276 debug!(msg = format!("update {ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE} attribute"));
1277 if let Some(legacy_crypto) = self.spec.jwt_legacy_crypto_enable {
1278 if legacy_crypto {
1279 record_kanidm_sdk_call(
1280 metrics,
1281 KANIDM_RESOURCE_OAUTH2,
1282 KANIDM_OP_UPDATE,
1283 KANIDM_OUTCOME_CHANGED,
1284 kanidm_client.idm_oauth2_rs_enable_legacy_crypto(name),
1285 )
1286 .await
1287 .map_err(|e| {
1288 Error::kanidm_client_error_attr(
1289 "update",
1290 ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE,
1291 name,
1292 self.kanidm_namespace(),
1293 self.kanidm_name(),
1294 e,
1295 )
1296 })?;
1297 } else {
1298 record_kanidm_sdk_call(
1299 metrics,
1300 KANIDM_RESOURCE_OAUTH2,
1301 KANIDM_OP_UPDATE,
1302 KANIDM_OUTCOME_CHANGED,
1303 kanidm_client.idm_oauth2_rs_disable_legacy_crypto(name),
1304 )
1305 .await
1306 .map_err(|e| {
1307 Error::kanidm_client_error_attr(
1308 "update",
1309 ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE,
1310 name,
1311 self.kanidm_namespace(),
1312 self.kanidm_name(),
1313 e,
1314 )
1315 })?;
1316 }
1317 };
1318 Ok(())
1319 }
1320
1321 async fn update_consent_prompt(
1322 &self,
1323 kanidm_client: &KanidmClient,
1324 name: &str,
1325 metrics: &kaniop_operator::metrics::ControllerMetrics,
1326 ) -> Result<()> {
1327 debug!(msg = format!("update {ATTR_OAUTH2_CONSENT_PROMPT_ENABLE} attribute"));
1328 if let Some(disable_consent_prompt) = self.spec.disable_consent_prompt {
1329 if disable_consent_prompt {
1330 record_kanidm_sdk_call(
1331 metrics,
1332 KANIDM_RESOURCE_OAUTH2,
1333 KANIDM_OP_UPDATE,
1334 KANIDM_OUTCOME_CHANGED,
1335 kanidm_client.idm_oauth2_rs_disable_consent_prompt(name),
1336 )
1337 .await
1338 .map_err(|e| {
1339 Error::kanidm_client_error_attr(
1340 "update",
1341 ATTR_OAUTH2_CONSENT_PROMPT_ENABLE,
1342 name,
1343 self.kanidm_namespace(),
1344 self.kanidm_name(),
1345 e,
1346 )
1347 })?;
1348 } else {
1349 record_kanidm_sdk_call(
1350 metrics,
1351 KANIDM_RESOURCE_OAUTH2,
1352 KANIDM_OP_UPDATE,
1353 KANIDM_OUTCOME_CHANGED,
1354 kanidm_client.idm_oauth2_rs_enable_consent_prompt(name),
1355 )
1356 .await
1357 .map_err(|e| {
1358 Error::kanidm_client_error_attr(
1359 "update",
1360 ATTR_OAUTH2_CONSENT_PROMPT_ENABLE,
1361 name,
1362 self.kanidm_namespace(),
1363 self.kanidm_name(),
1364 e,
1365 )
1366 })?;
1367 }
1368 };
1369 Ok(())
1370 }
1371
1372 async fn update_image(
1373 &self,
1374 kanidm_client: &KanidmClient,
1375 name: &str,
1376 status: &KanidmOAuth2ClientStatus,
1377 ctx: Arc<Context>,
1378 metrics: &kaniop_operator::metrics::ControllerMetrics,
1379 ) -> Result<bool> {
1380 match &self.spec.image {
1381 None => {
1382 debug!(msg = "deleting image from OAuth2 client");
1383 record_kanidm_sdk_call(
1384 metrics,
1385 KANIDM_RESOURCE_OAUTH2,
1386 KANIDM_OP_DELETE_IMAGE,
1387 KANIDM_OUTCOME_CHANGED,
1388 kanidm_client.idm_oauth2_rs_delete_image(name),
1389 )
1390 .await
1391 .map_err(|e| {
1392 Error::kanidm_client_error_attr(
1393 "delete",
1394 "image",
1395 name,
1396 self.kanidm_namespace(),
1397 self.kanidm_name(),
1398 e,
1399 )
1400 })?;
1401 Ok(true)
1402 }
1403 Some(image_spec) => {
1404 let url = &image_spec.url;
1405 debug!(msg = format!("updating image for OAuth2 client from {url}"));
1406
1407 let namespace = self.kanidm_namespace();
1408 let kanidm = self.kanidm_name();
1409 let namespace_for_closure = namespace.clone();
1410 let kanidm_for_closure = kanidm.clone();
1411 let metrics_clone = metrics.clone();
1412
1413 let update_result =
1414 update_image_if_needed(url, status.image.as_ref(), |image_value| {
1415 let metrics = metrics_clone.clone();
1416 let namespace = namespace_for_closure.clone();
1417 let kanidm = kanidm_for_closure.clone();
1418 async move {
1419 record_kanidm_sdk_call(
1420 &metrics,
1421 KANIDM_RESOURCE_OAUTH2,
1422 KANIDM_OP_UPDATE_IMAGE,
1423 KANIDM_OUTCOME_CHANGED,
1424 kanidm_client.idm_oauth2_rs_update_image(name, image_value),
1425 )
1426 .await
1427 .map_err(|e| {
1428 Error::kanidm_client_error_attr(
1429 "update", "image", name, namespace, kanidm, e,
1430 )
1431 })
1432 }
1433 })
1434 .await;
1435
1436 match update_result {
1437 Ok(Some(updated)) => {
1438 let new_image_status = OAuth2ClientImageStatus {
1439 url: updated.image_status.url,
1440 etag: updated.image_status.etag,
1441 last_modified: updated.image_status.last_modified,
1442 content_length: updated.image_status.content_length,
1443 content_hash: Some(updated.image_status.content_hash),
1444 };
1445
1446 let namespace = self.namespace().unwrap();
1447 let name = self.name_any();
1448 let oauth2_api = Api::<KanidmOAuth2Client>::namespaced(
1449 ctx.kaniop_ctx.client.clone(),
1450 &namespace,
1451 );
1452 let status_patch = Patch::Apply(KanidmOAuth2Client {
1453 status: Some(KanidmOAuth2ClientStatus {
1454 image: Some(new_image_status),
1455 ..status.clone()
1456 }),
1457 ..KanidmOAuth2Client::default()
1458 });
1459 oauth2_api
1460 .patch_status(
1461 &name,
1462 &PatchParams::apply(OAUTH2_OPERATOR_NAME),
1463 &status_patch,
1464 )
1465 .await
1466 .map_err(|e| {
1467 Error::kube_status_error("KanidmOAuth2Client", &namespace, &name, e)
1468 })?;
1469 Ok(true)
1470 }
1471 Ok(None) => Ok(false),
1472 Err(e) => {
1473 let operation = if matches!(e, Error::HttpError(_, _)) {
1474 ImageOperation::Fetch
1475 } else {
1476 ImageOperation::Download
1477 };
1478 Err(publish_image_error_event(
1479 e,
1480 operation,
1481 name,
1482 &namespace,
1483 &kanidm,
1484 &ctx.kaniop_ctx.recorder,
1485 self,
1486 )
1487 .await)
1488 }
1489 }
1490 }
1491 }
1492 }
1493
1494 async fn cleanup(
1495 &self,
1496 kanidm_client: Arc<KanidmClient>,
1497 status: KanidmOAuth2ClientStatus,
1498 ctx: Arc<Context>,
1499 ) -> Result<(Action, bool)> {
1500 let name = &self.kanidm_entity_name();
1501 let mut changed = false;
1502 if is_oauth2(TYPE_EXISTS, status.clone()) {
1503 debug!(msg = "delete");
1504 record_kanidm_sdk_call(
1505 &ctx.kaniop_ctx.metrics,
1506 KANIDM_RESOURCE_OAUTH2,
1507 KANIDM_OP_DELETE,
1508 KANIDM_OUTCOME_CHANGED,
1509 kanidm_client.idm_oauth2_rs_delete(name),
1510 )
1511 .await
1512 .map_err(|e| {
1513 Error::kanidm_client_error(
1514 "delete",
1515 name,
1516 self.kanidm_namespace(),
1517 self.kanidm_name(),
1518 e,
1519 )
1520 })?;
1521 changed = true;
1522 }
1523 Ok((Action::requeue(idm_reconcile_interval()), changed))
1524 }
1525}
1526
1527pub fn is_oauth2(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
1528 status
1529 .conditions
1530 .unwrap_or_default()
1531 .iter()
1532 .any(|c| c.type_ == type_ && c.status == CONDITION_TRUE)
1533}
1534
1535pub fn is_oauth2_false(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
1536 status
1537 .conditions
1538 .unwrap_or_default()
1539 .iter()
1540 .any(|c| c.type_ == type_ && c.status == CONDITION_FALSE)
1541}