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