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_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 if is_oauth2_false(TYPE_IMAGE_UPDATED, status.clone()) {
589 let image_changed = self
590 .update_image(&kanidm_client, name, &status, ctx.clone(), metrics)
591 .await?;
592 require_status_update = true;
593 changed = changed || image_changed;
594 }
595
596 if require_status_update {
597 trace!("status update required, requeueing in 500ms");
598 Ok((Action::requeue(Duration::from_millis(500)), changed))
599 } else {
600 Ok((Action::requeue(idm_reconcile_interval()), changed))
601 }
602 }
603
604 async fn create(
605 &self,
606 kanidm_client: &KanidmClient,
607 name: &str,
608 metrics: &kaniop_operator::metrics::ControllerMetrics,
609 ) -> Result<()> {
610 debug!("create");
611 if self.spec.public {
612 debug!("create public client");
613 record_kanidm_sdk_call(
614 metrics,
615 KANIDM_RESOURCE_OAUTH2,
616 KANIDM_OP_CREATE,
617 KANIDM_OUTCOME_CHANGED,
618 kanidm_client.idm_oauth2_rs_public_create(
619 name,
620 &self.spec.displayname,
621 &self.spec.origin,
622 ),
623 )
624 .await
625 .map_err(|e| {
626 Error::kanidm_client_error(
627 "create",
628 name,
629 self.kanidm_namespace(),
630 self.kanidm_name(),
631 e,
632 )
633 })?;
634 } else {
635 record_kanidm_sdk_call(
636 metrics,
637 KANIDM_RESOURCE_OAUTH2,
638 KANIDM_OP_CREATE,
639 KANIDM_OUTCOME_CHANGED,
640 kanidm_client.idm_oauth2_rs_basic_create(
641 name,
642 &self.spec.displayname,
643 &self.spec.origin,
644 ),
645 )
646 .await
647 .map_err(|e| {
648 Error::kanidm_client_error(
649 "create",
650 name,
651 self.kanidm_namespace(),
652 self.kanidm_name(),
653 e,
654 )
655 })?;
656 }
657 Ok(())
658 }
659
660 async fn update(
661 &self,
662 kanidm_client: &KanidmClient,
663 name: &str,
664 metrics: &kaniop_operator::metrics::ControllerMetrics,
665 ) -> Result<()> {
666 debug!("update");
667 record_kanidm_sdk_call(
668 metrics,
669 KANIDM_RESOURCE_OAUTH2,
670 KANIDM_OP_UPDATE,
671 KANIDM_OUTCOME_CHANGED,
672 kanidm_client.idm_oauth2_rs_update(
673 name,
674 None,
675 Some(&self.spec.displayname),
676 Some(&self.spec.origin),
677 false,
678 ),
679 )
680 .await
681 .map_err(|e| {
682 Error::kanidm_client_error(
683 "update",
684 name,
685 self.kanidm_namespace(),
686 self.kanidm_name(),
687 e,
688 )
689 })?;
690 Ok(())
691 }
692
693 async fn update_description(
694 &self,
695 kanidm_client: &KanidmClient,
696 name: &str,
697 metrics: &kaniop_operator::metrics::ControllerMetrics,
698 ) -> Result<()> {
699 let description = self.spec.description.as_deref().ok_or_else(|| {
700 Error::MissingData("OAuth2 client description is not defined".to_string())
701 })?;
702 let entry = Entry {
703 attrs: BTreeMap::from([(
704 ATTR_DESCRIPTION.to_string(),
705 if description.is_empty() {
706 Vec::new()
707 } else {
708 vec![description.to_string()]
709 },
710 )]),
711 };
712 let _: () = record_kanidm_sdk_call(
714 metrics,
715 KANIDM_RESOURCE_OAUTH2,
716 KANIDM_OP_UPDATE,
717 KANIDM_OUTCOME_CHANGED,
718 kanidm_client.perform_patch_request(&format!("/v1/oauth2/{name}"), entry),
719 )
720 .await
721 .map_err(|e| {
722 Error::kanidm_client_error_attr(
723 "update",
724 ATTR_DESCRIPTION,
725 name,
726 self.kanidm_namespace(),
727 self.kanidm_name(),
728 e,
729 )
730 })?;
731 Ok(())
732 }
733
734 async fn rotate_secret(
735 &self,
736 kanidm_client: &KanidmClient,
737 name: &str,
738 ctx: Arc<Context>,
739 metrics: &kaniop_operator::metrics::ControllerMetrics,
740 ) -> Result<()> {
741 info!("rotating OAuth2 client secret");
742 record_kanidm_sdk_call(
744 metrics,
745 KANIDM_RESOURCE_OAUTH2,
746 KANIDM_OP_RESET_SECRET,
747 KANIDM_OUTCOME_CHANGED,
748 kanidm_client.idm_oauth2_rs_update(name, None, None, None, true),
749 )
750 .await
751 .map_err(|e| {
752 Error::kanidm_client_error_attr(
753 "rotate",
754 "secret",
755 name,
756 self.kanidm_namespace(),
757 self.kanidm_name(),
758 e,
759 )
760 })?;
761
762 let secret = record_kanidm_sdk_call(
764 metrics,
765 KANIDM_RESOURCE_OAUTH2,
766 KANIDM_OP_GET_SECRET,
767 KANIDM_OUTCOME_CHANGED,
768 self.generate_secret(
769 kanidm_client,
770 self.spec.secret_rotation.as_ref(),
771 self.spec.secret_key_aliases.as_ref(),
772 ),
773 )
774 .await?;
775 self.apply_secret(&ctx, secret).await?;
776 Ok(())
777 }
778
779 async fn update_redirect_url(
780 &self,
781 kanidm_client: &KanidmClient,
782 name: &str,
783 status: &KanidmOAuth2ClientStatus,
784 metrics: &kaniop_operator::metrics::ControllerMetrics,
785 ) -> Result<()> {
786 debug!("update {ATTR_OAUTH2_RS_ORIGIN} attribute");
787
788 let current_urls: BTreeSet<_> = status
789 .origin
790 .as_ref()
791 .map(|o| o.iter().filter_map(|u| url::Url::parse(u).ok()).collect())
792 .unwrap_or_default();
793
794 let redirect_url = self
795 .spec
796 .redirect_url
797 .iter()
798 .map(|u| {
799 url::Url::parse(u).map_err(|e| {
800 Error::UrlParseError(
801 format!(
802 "failed to parse redirect URL {u} for {name} from {namespace}/{kanidm}",
803 namespace = self.kanidm_namespace(),
804 kanidm = self.kanidm_name(),
805 ),
806 e,
807 )
808 })
809 })
810 .collect::<Result<BTreeSet<_>>>()?;
811
812 let metrics_remove = metrics.clone();
813 let delete_futures = current_urls
814 .difference(&redirect_url)
815 .map(|url| {
816 let metrics = metrics_remove.clone();
817 async move {
818 record_kanidm_sdk_call(
819 &metrics,
820 KANIDM_RESOURCE_OAUTH2,
821 KANIDM_OP_REMOVE_ORIGIN,
822 KANIDM_OUTCOME_CHANGED,
823 kanidm_client.idm_oauth2_client_remove_origin(name, url),
824 )
825 .await
826 }
827 })
828 .collect::<TryJoinAll<_>>();
829
830 let metrics_add = metrics.clone();
831 let add_futures = redirect_url
832 .difference(¤t_urls)
833 .map(|url| {
834 let metrics = metrics_add.clone();
835 async move {
836 record_kanidm_sdk_call(
837 &metrics,
838 KANIDM_RESOURCE_OAUTH2,
839 KANIDM_OP_ADD_ORIGIN,
840 KANIDM_OUTCOME_CHANGED,
841 kanidm_client.idm_oauth2_client_add_origin(name, url),
842 )
843 .await
844 }
845 })
846 .collect::<TryJoinAll<_>>();
847
848 futures::try_join!(delete_futures, add_futures).map_err(|e| {
849 Error::kanidm_client_error_attr(
850 "modify",
851 ATTR_OAUTH2_RS_ORIGIN,
852 name,
853 self.kanidm_namespace(),
854 self.kanidm_name(),
855 e,
856 )
857 })?;
858
859 Ok(())
860 }
861
862 async fn update_scope_map(
863 &self,
864 kanidm_client: &KanidmClient,
865 name: &str,
866 status: &KanidmOAuth2ClientStatus,
867 metrics: &kaniop_operator::metrics::ControllerMetrics,
868 ) -> Result<()> {
869 debug!("update {ATTR_OAUTH2_RS_SCOPE_MAP} attribute");
870
871 let current_scope_map: BTreeSet<_> = status
872 .scope_map
873 .as_ref()
874 .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
875 .unwrap_or_default();
876
877 let scope_map: BTreeSet<KanidmScopeMap> = self
878 .spec
879 .scope_map
880 .clone()
881 .unwrap_or_default()
882 .clone()
883 .into_iter()
884 .collect();
885
886 let metrics_del = metrics.clone();
887 let delete_futures = current_scope_map
888 .difference(&scope_map)
889 .map(|s| {
890 let metrics = metrics_del.clone();
891 async move {
892 record_kanidm_sdk_call(
893 &metrics,
894 KANIDM_RESOURCE_OAUTH2,
895 KANIDM_OP_DELETE_SCOPE_MAP,
896 KANIDM_OUTCOME_CHANGED,
897 kanidm_client.idm_oauth2_rs_delete_scope_map(name, &s.group),
898 )
899 .await
900 }
901 })
902 .collect::<TryJoinAll<_>>();
903
904 let metrics_add = metrics.clone();
905 let add_futures = scope_map
906 .difference(¤t_scope_map)
907 .map(|s| {
908 let metrics = metrics_add.clone();
909 let scopes: Vec<&str> = s.scopes.iter().map(|s| s.as_str()).collect();
910 async move {
911 record_kanidm_sdk_call(
912 &metrics,
913 KANIDM_RESOURCE_OAUTH2,
914 KANIDM_OP_UPDATE_SCOPE_MAP,
915 KANIDM_OUTCOME_CHANGED,
916 kanidm_client.idm_oauth2_rs_update_scope_map(name, &s.group, scopes),
917 )
918 .await
919 }
920 })
921 .collect::<TryJoinAll<_>>();
922
923 try_join!(delete_futures, add_futures).map_err(|e| {
924 Error::kanidm_client_error_attr(
925 "modify",
926 ATTR_OAUTH2_RS_SCOPE_MAP,
927 name,
928 self.kanidm_namespace(),
929 self.kanidm_name(),
930 e,
931 )
932 })?;
933 Ok(())
934 }
935
936 async fn update_sup_scope_map(
937 &self,
938 kanidm_client: &KanidmClient,
939 name: &str,
940 status: &KanidmOAuth2ClientStatus,
941 metrics: &kaniop_operator::metrics::ControllerMetrics,
942 ) -> Result<()> {
943 debug!("update {ATTR_OAUTH2_RS_SUP_SCOPE_MAP} attribute");
944
945 let current_sup_scope_map: BTreeSet<_> = status
946 .sup_scope_map
947 .as_ref()
948 .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
949 .unwrap_or_default();
950
951 let sup_scope_map: BTreeSet<KanidmScopeMap> = self
952 .spec
953 .sup_scope_map
954 .clone()
955 .unwrap_or_default()
956 .clone()
957 .into_iter()
958 .collect();
959
960 let metrics_del = metrics.clone();
961 let delete_futures = current_sup_scope_map
962 .difference(&sup_scope_map)
963 .map(|s| {
964 let metrics = metrics_del.clone();
965 async move {
966 record_kanidm_sdk_call(
967 &metrics,
968 KANIDM_RESOURCE_OAUTH2,
969 KANIDM_OP_DELETE_SUP_SCOPE_MAP,
970 KANIDM_OUTCOME_CHANGED,
971 kanidm_client.idm_oauth2_rs_delete_sup_scope_map(name, &s.group),
972 )
973 .await
974 }
975 })
976 .collect::<TryJoinAll<_>>();
977
978 let metrics_add = metrics.clone();
979 let add_futures = sup_scope_map
980 .difference(¤t_sup_scope_map)
981 .map(|s| {
982 let metrics = metrics_add.clone();
983 let scopes: Vec<&str> = s.scopes.iter().map(|s| s.as_str()).collect();
984 async move {
985 record_kanidm_sdk_call(
986 &metrics,
987 KANIDM_RESOURCE_OAUTH2,
988 KANIDM_OP_UPDATE_SUP_SCOPE_MAP,
989 KANIDM_OUTCOME_CHANGED,
990 kanidm_client.idm_oauth2_rs_update_sup_scope_map(name, &s.group, scopes),
991 )
992 .await
993 }
994 })
995 .collect::<TryJoinAll<_>>();
996
997 try_join!(delete_futures, add_futures).map_err(|e| {
998 Error::kanidm_client_error_attr(
999 "modify",
1000 ATTR_OAUTH2_RS_SUP_SCOPE_MAP,
1001 name,
1002 self.kanidm_namespace(),
1003 self.kanidm_name(),
1004 e,
1005 )
1006 })?;
1007 Ok(())
1008 }
1009
1010 async fn update_claims_map(
1011 &self,
1012 kanidm_client: &KanidmClient,
1013 name: &str,
1014 status: &KanidmOAuth2ClientStatus,
1015 metrics: &kaniop_operator::metrics::ControllerMetrics,
1016 ) -> Result<()> {
1017 debug!("update {ATTR_OAUTH2_RS_CLAIM_MAP} attribute");
1018
1019 let current_claims_map: BTreeSet<_> = status
1020 .claims_map
1021 .as_ref()
1022 .map(|v| {
1023 KanidmClaimMap::group(
1024 &v.iter()
1025 .filter_map(|c| KanidmClaimMap::from(c))
1026 .collect::<Vec<_>>(),
1027 )
1028 })
1029 .unwrap_or_default();
1030
1031 let claims_map: BTreeSet<KanidmClaimMap> = self
1032 .spec
1033 .claim_map
1034 .clone()
1035 .unwrap_or_default()
1036 .clone()
1037 .into_iter()
1038 .collect();
1039
1040 let metrics_del = metrics.clone();
1041 let delete_futures = current_claims_map
1042 .difference(&claims_map)
1043 .flat_map(|c| {
1044 c.values_map
1045 .iter()
1046 .map(|v| {
1047 let metrics = metrics_del.clone();
1048 async move {
1049 record_kanidm_sdk_call(
1050 &metrics,
1051 KANIDM_RESOURCE_OAUTH2,
1052 KANIDM_OP_DELETE_CLAIM_MAP,
1053 KANIDM_OUTCOME_CHANGED,
1054 kanidm_client
1055 .idm_oauth2_rs_delete_claim_map(name, &c.name, &v.group),
1056 )
1057 .await
1058 }
1059 })
1060 .collect::<Vec<_>>()
1061 })
1062 .collect::<TryJoinAll<_>>();
1063
1064 let claims_to_add = claims_map.difference(¤t_claims_map);
1065 let metrics_add = metrics.clone();
1066 let add_futures = claims_to_add
1067 .clone()
1068 .flat_map(|c| {
1069 c.values_map
1070 .iter()
1071 .map(|v| {
1072 let metrics = metrics_add.clone();
1073 let values = v.values.clone();
1074 async move {
1075 record_kanidm_sdk_call(
1076 &metrics,
1077 KANIDM_RESOURCE_OAUTH2,
1078 KANIDM_OP_UPDATE_CLAIM_MAP,
1079 KANIDM_OUTCOME_CHANGED,
1080 kanidm_client.idm_oauth2_rs_update_claim_map(
1081 name, &c.name, &v.group, &values,
1082 ),
1083 )
1084 .await
1085 }
1086 })
1087 .collect::<Vec<_>>()
1088 })
1089 .collect::<TryJoinAll<_>>();
1090
1091 let metrics_join = metrics.clone();
1092 let join_strategy_futures = claims_to_add
1093 .map(|c| {
1094 let metrics = metrics_join.clone();
1095 let join_strategy = c.join_strategy.to_oauth2_claim_map_join();
1096 async move {
1097 record_kanidm_sdk_call(
1098 &metrics,
1099 KANIDM_RESOURCE_OAUTH2,
1100 KANIDM_OP_UPDATE_CLAIM_MAP_JOIN,
1101 KANIDM_OUTCOME_CHANGED,
1102 kanidm_client.idm_oauth2_rs_update_claim_map_join(
1103 name,
1104 &c.name,
1105 join_strategy,
1106 ),
1107 )
1108 .await
1109 }
1110 })
1111 .collect::<TryJoinAll<_>>();
1112
1113 try_join!(delete_futures, add_futures, join_strategy_futures).map_err(|e| {
1114 Error::kanidm_client_error_attr(
1115 "modify",
1116 ATTR_OAUTH2_RS_CLAIM_MAP,
1117 name,
1118 self.kanidm_namespace(),
1119 self.kanidm_name(),
1120 e,
1121 )
1122 })?;
1123 Ok(())
1124 }
1125
1126 async fn update_strict_redirect_url(
1127 &self,
1128 kanidm_client: &KanidmClient,
1129 name: &str,
1130 metrics: &kaniop_operator::metrics::ControllerMetrics,
1131 ) -> Result<()> {
1132 debug!("update {ATTR_OAUTH2_STRICT_REDIRECT_URI} attribute");
1133 if let Some(strict_redirect_url_enabled) = self.spec.strict_redirect_url {
1134 if strict_redirect_url_enabled {
1135 record_kanidm_sdk_call(
1136 metrics,
1137 KANIDM_RESOURCE_OAUTH2,
1138 KANIDM_OP_UPDATE,
1139 KANIDM_OUTCOME_CHANGED,
1140 kanidm_client.idm_oauth2_rs_enable_strict_redirect_uri(name),
1141 )
1142 .await
1143 .map_err(|e| {
1144 Error::kanidm_client_error_attr(
1145 "update",
1146 ATTR_OAUTH2_STRICT_REDIRECT_URI,
1147 name,
1148 self.kanidm_namespace(),
1149 self.kanidm_name(),
1150 e,
1151 )
1152 })?;
1153 } else {
1154 record_kanidm_sdk_call(
1155 metrics,
1156 KANIDM_RESOURCE_OAUTH2,
1157 KANIDM_OP_UPDATE,
1158 KANIDM_OUTCOME_CHANGED,
1159 kanidm_client.idm_oauth2_rs_disable_strict_redirect_uri(name),
1160 )
1161 .await
1162 .map_err(|e| {
1163 Error::kanidm_client_error_attr(
1164 "update",
1165 ATTR_OAUTH2_STRICT_REDIRECT_URI,
1166 name,
1167 self.kanidm_namespace(),
1168 self.kanidm_name(),
1169 e,
1170 )
1171 })?;
1172 }
1173 };
1174 Ok(())
1175 }
1176
1177 async fn update_disable_pkce(
1178 &self,
1179 kanidm_client: &KanidmClient,
1180 name: &str,
1181 metrics: &kaniop_operator::metrics::ControllerMetrics,
1182 ) -> Result<()> {
1183 debug!("update {ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE} attribute");
1184 if let Some(disable_pkce) = self.spec.allow_insecure_client_disable_pkce {
1185 if disable_pkce {
1186 record_kanidm_sdk_call(
1187 metrics,
1188 KANIDM_RESOURCE_OAUTH2,
1189 KANIDM_OP_UPDATE,
1190 KANIDM_OUTCOME_CHANGED,
1191 kanidm_client.idm_oauth2_rs_disable_pkce(name),
1192 )
1193 .await
1194 .map_err(|e| {
1195 Error::kanidm_client_error_attr(
1196 "update",
1197 ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE,
1198 name,
1199 self.kanidm_namespace(),
1200 self.kanidm_name(),
1201 e,
1202 )
1203 })?;
1204 } else {
1205 record_kanidm_sdk_call(
1206 metrics,
1207 KANIDM_RESOURCE_OAUTH2,
1208 KANIDM_OP_UPDATE,
1209 KANIDM_OUTCOME_CHANGED,
1210 kanidm_client.idm_oauth2_rs_enable_pkce(name),
1211 )
1212 .await
1213 .map_err(|e| {
1214 Error::kanidm_client_error_attr(
1215 "update",
1216 ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE,
1217 name,
1218 self.kanidm_namespace(),
1219 self.kanidm_name(),
1220 e,
1221 )
1222 })?;
1223 }
1224 };
1225 Ok(())
1226 }
1227
1228 async fn update_prefer_short_name(
1229 &self,
1230 kanidm_client: &KanidmClient,
1231 name: &str,
1232 metrics: &kaniop_operator::metrics::ControllerMetrics,
1233 ) -> Result<()> {
1234 debug!("update {ATTR_OAUTH2_PREFER_SHORT_USERNAME} attribute");
1235 if let Some(prefer_short_username) = self.spec.prefer_short_username {
1236 if prefer_short_username {
1237 record_kanidm_sdk_call(
1238 metrics,
1239 KANIDM_RESOURCE_OAUTH2,
1240 KANIDM_OP_UPDATE,
1241 KANIDM_OUTCOME_CHANGED,
1242 kanidm_client.idm_oauth2_rs_prefer_short_username(name),
1243 )
1244 .await
1245 .map_err(|e| {
1246 Error::kanidm_client_error_attr(
1247 "update",
1248 ATTR_OAUTH2_PREFER_SHORT_USERNAME,
1249 name,
1250 self.kanidm_namespace(),
1251 self.kanidm_name(),
1252 e,
1253 )
1254 })?;
1255 } else {
1256 record_kanidm_sdk_call(
1257 metrics,
1258 KANIDM_RESOURCE_OAUTH2,
1259 KANIDM_OP_UPDATE,
1260 KANIDM_OUTCOME_CHANGED,
1261 kanidm_client.idm_oauth2_rs_prefer_spn_username(name),
1262 )
1263 .await
1264 .map_err(|e| {
1265 Error::kanidm_client_error_attr(
1266 "update",
1267 ATTR_OAUTH2_PREFER_SHORT_USERNAME,
1268 name,
1269 self.kanidm_namespace(),
1270 self.kanidm_name(),
1271 e,
1272 )
1273 })?;
1274 }
1275 };
1276 Ok(())
1277 }
1278
1279 async fn update_allow_localhost_redirect(
1280 &self,
1281 kanidm_client: &KanidmClient,
1282 name: &str,
1283 metrics: &kaniop_operator::metrics::ControllerMetrics,
1284 ) -> Result<()> {
1285 debug!("update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} attribute");
1286 if let Some(allow_localhost_redirect) = self.spec.allow_localhost_redirect {
1287 if allow_localhost_redirect {
1288 record_kanidm_sdk_call(
1289 metrics,
1290 KANIDM_RESOURCE_OAUTH2,
1291 KANIDM_OP_UPDATE,
1292 KANIDM_OUTCOME_CHANGED,
1293 kanidm_client.idm_oauth2_rs_enable_public_localhost_redirect(name),
1294 )
1295 .await
1296 .map_err(|e| {
1297 Error::kanidm_client_error_attr(
1298 "update",
1299 ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT,
1300 name,
1301 self.kanidm_namespace(),
1302 self.kanidm_name(),
1303 e,
1304 )
1305 })?;
1306 } else {
1307 record_kanidm_sdk_call(
1308 metrics,
1309 KANIDM_RESOURCE_OAUTH2,
1310 KANIDM_OP_UPDATE,
1311 KANIDM_OUTCOME_CHANGED,
1312 kanidm_client.idm_oauth2_rs_disable_public_localhost_redirect(name),
1313 )
1314 .await
1315 .map_err(|e| {
1316 Error::kanidm_client_error_attr(
1317 "update",
1318 ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT,
1319 name,
1320 self.kanidm_namespace(),
1321 self.kanidm_name(),
1322 e,
1323 )
1324 })?;
1325 }
1326 };
1327 Ok(())
1328 }
1329
1330 async fn update_legacy_crypto(
1331 &self,
1332 kanidm_client: &KanidmClient,
1333 name: &str,
1334 metrics: &kaniop_operator::metrics::ControllerMetrics,
1335 ) -> Result<()> {
1336 debug!("update {ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE} attribute");
1337 if let Some(legacy_crypto) = self.spec.jwt_legacy_crypto_enable {
1338 if legacy_crypto {
1339 record_kanidm_sdk_call(
1340 metrics,
1341 KANIDM_RESOURCE_OAUTH2,
1342 KANIDM_OP_UPDATE,
1343 KANIDM_OUTCOME_CHANGED,
1344 kanidm_client.idm_oauth2_rs_enable_legacy_crypto(name),
1345 )
1346 .await
1347 .map_err(|e| {
1348 Error::kanidm_client_error_attr(
1349 "update",
1350 ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE,
1351 name,
1352 self.kanidm_namespace(),
1353 self.kanidm_name(),
1354 e,
1355 )
1356 })?;
1357 } else {
1358 record_kanidm_sdk_call(
1359 metrics,
1360 KANIDM_RESOURCE_OAUTH2,
1361 KANIDM_OP_UPDATE,
1362 KANIDM_OUTCOME_CHANGED,
1363 kanidm_client.idm_oauth2_rs_disable_legacy_crypto(name),
1364 )
1365 .await
1366 .map_err(|e| {
1367 Error::kanidm_client_error_attr(
1368 "update",
1369 ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE,
1370 name,
1371 self.kanidm_namespace(),
1372 self.kanidm_name(),
1373 e,
1374 )
1375 })?;
1376 }
1377 };
1378 Ok(())
1379 }
1380
1381 async fn update_consent_prompt(
1382 &self,
1383 kanidm_client: &KanidmClient,
1384 name: &str,
1385 metrics: &kaniop_operator::metrics::ControllerMetrics,
1386 ) -> Result<()> {
1387 debug!("update {ATTR_OAUTH2_CONSENT_PROMPT_ENABLE} attribute");
1388 if let Some(disable_consent_prompt) = self.spec.disable_consent_prompt {
1389 if disable_consent_prompt {
1390 record_kanidm_sdk_call(
1391 metrics,
1392 KANIDM_RESOURCE_OAUTH2,
1393 KANIDM_OP_UPDATE,
1394 KANIDM_OUTCOME_CHANGED,
1395 kanidm_client.idm_oauth2_rs_disable_consent_prompt(name),
1396 )
1397 .await
1398 .map_err(|e| {
1399 Error::kanidm_client_error_attr(
1400 "update",
1401 ATTR_OAUTH2_CONSENT_PROMPT_ENABLE,
1402 name,
1403 self.kanidm_namespace(),
1404 self.kanidm_name(),
1405 e,
1406 )
1407 })?;
1408 } else {
1409 record_kanidm_sdk_call(
1410 metrics,
1411 KANIDM_RESOURCE_OAUTH2,
1412 KANIDM_OP_UPDATE,
1413 KANIDM_OUTCOME_CHANGED,
1414 kanidm_client.idm_oauth2_rs_enable_consent_prompt(name),
1415 )
1416 .await
1417 .map_err(|e| {
1418 Error::kanidm_client_error_attr(
1419 "update",
1420 ATTR_OAUTH2_CONSENT_PROMPT_ENABLE,
1421 name,
1422 self.kanidm_namespace(),
1423 self.kanidm_name(),
1424 e,
1425 )
1426 })?;
1427 }
1428 };
1429 Ok(())
1430 }
1431
1432 async fn update_refresh_token_expiry(
1433 &self,
1434 kanidm_client: &KanidmClient,
1435 name: &str,
1436 metrics: &kaniop_operator::metrics::ControllerMetrics,
1437 ) -> Result<()> {
1438 if let Some(expiry) = self.spec.refresh_token_expiry {
1439 debug!("update {ATTR_OAUTH2_REFRESH_TOKEN_EXPIRY} attribute");
1440 record_kanidm_sdk_call(
1441 metrics,
1442 KANIDM_RESOURCE_OAUTH2,
1443 KANIDM_OP_UPDATE,
1444 KANIDM_OUTCOME_CHANGED,
1445 kanidm_client.idm_oauth2_rs_set_refresh_token_expiry(name, Some(expiry)),
1446 )
1447 .await
1448 .map_err(|e| {
1449 Error::kanidm_client_error_attr(
1450 "update",
1451 ATTR_OAUTH2_REFRESH_TOKEN_EXPIRY,
1452 name,
1453 self.kanidm_namespace(),
1454 self.kanidm_name(),
1455 e,
1456 )
1457 })?;
1458 }
1459 Ok(())
1460 }
1461
1462 async fn update_image(
1463 &self,
1464 kanidm_client: &KanidmClient,
1465 name: &str,
1466 status: &KanidmOAuth2ClientStatus,
1467 ctx: Arc<Context>,
1468 metrics: &kaniop_operator::metrics::ControllerMetrics,
1469 ) -> Result<bool> {
1470 match &self.spec.image {
1471 None => {
1472 debug!("deleting image from OAuth2 client");
1473 record_kanidm_sdk_call(
1474 metrics,
1475 KANIDM_RESOURCE_OAUTH2,
1476 KANIDM_OP_DELETE_IMAGE,
1477 KANIDM_OUTCOME_CHANGED,
1478 kanidm_client.idm_oauth2_rs_delete_image(name),
1479 )
1480 .await
1481 .map_err(|e| {
1482 Error::kanidm_client_error_attr(
1483 "delete",
1484 "image",
1485 name,
1486 self.kanidm_namespace(),
1487 self.kanidm_name(),
1488 e,
1489 )
1490 })?;
1491 Ok(true)
1492 }
1493 Some(image_spec) => {
1494 let url = &image_spec.url;
1495 debug!("updating image for OAuth2 client from {url}");
1496
1497 let namespace = self.kanidm_namespace();
1498 let kanidm = self.kanidm_name();
1499 let namespace_for_closure = namespace.clone();
1500 let kanidm_for_closure = kanidm.clone();
1501 let metrics_clone = metrics.clone();
1502
1503 let update_result =
1504 update_image_if_needed(url, status.image.as_ref(), |image_value| {
1505 let metrics = metrics_clone.clone();
1506 let namespace = namespace_for_closure.clone();
1507 let kanidm = kanidm_for_closure.clone();
1508 async move {
1509 record_kanidm_sdk_call(
1510 &metrics,
1511 KANIDM_RESOURCE_OAUTH2,
1512 KANIDM_OP_UPDATE_IMAGE,
1513 KANIDM_OUTCOME_CHANGED,
1514 kanidm_client.idm_oauth2_rs_update_image(name, image_value),
1515 )
1516 .await
1517 .map_err(|e| {
1518 Error::kanidm_client_error_attr(
1519 "update", "image", name, namespace, kanidm, e,
1520 )
1521 })
1522 }
1523 })
1524 .await;
1525
1526 match update_result {
1527 Ok(Some(updated)) => {
1528 let new_image_status = OAuth2ClientImageStatus {
1529 url: updated.image_status.url,
1530 etag: updated.image_status.etag,
1531 last_modified: updated.image_status.last_modified,
1532 content_length: updated.image_status.content_length,
1533 content_hash: Some(updated.image_status.content_hash),
1534 };
1535
1536 let namespace = self.namespace().unwrap();
1537 let name = self.name_any();
1538 let oauth2_api = Api::<KanidmOAuth2Client>::namespaced(
1539 ctx.kaniop_ctx.client.clone(),
1540 &namespace,
1541 );
1542 let status_patch = Patch::Apply(KanidmOAuth2Client {
1543 status: Some(KanidmOAuth2ClientStatus {
1544 image: Some(new_image_status),
1545 ..status.clone()
1546 }),
1547 ..KanidmOAuth2Client::default()
1548 });
1549 oauth2_api
1554 .patch_status(
1555 &name,
1556 &PatchParams::apply(OAUTH2_OPERATOR_NAME).force(),
1557 &status_patch,
1558 )
1559 .await
1560 .map_err(|e| {
1561 Error::kube_status_error("KanidmOAuth2Client", &namespace, &name, e)
1562 })?;
1563 Ok(true)
1564 }
1565 Ok(None) => Ok(false),
1566 Err(e) => {
1567 let operation = if matches!(e, Error::HttpError(_, _)) {
1568 ImageOperation::Fetch
1569 } else {
1570 ImageOperation::Download
1571 };
1572 Err(publish_image_error_event(
1573 e,
1574 operation,
1575 name,
1576 &namespace,
1577 &kanidm,
1578 &ctx.kaniop_ctx.recorder,
1579 self,
1580 )
1581 .await)
1582 }
1583 }
1584 }
1585 }
1586 }
1587
1588 async fn cleanup(
1589 &self,
1590 kanidm_client: Arc<KanidmClient>,
1591 status: KanidmOAuth2ClientStatus,
1592 ctx: Arc<Context>,
1593 ) -> Result<(Action, bool)> {
1594 let name = &self.kanidm_entity_name();
1595 let mut changed = false;
1596 if is_oauth2(TYPE_EXISTS, status.clone()) {
1597 debug!("delete");
1598 record_kanidm_sdk_call(
1599 &ctx.kaniop_ctx.metrics,
1600 KANIDM_RESOURCE_OAUTH2,
1601 KANIDM_OP_DELETE,
1602 KANIDM_OUTCOME_CHANGED,
1603 kanidm_client.idm_oauth2_rs_delete(name),
1604 )
1605 .await
1606 .map_err(|e| {
1607 Error::kanidm_client_error(
1608 "delete",
1609 name,
1610 self.kanidm_namespace(),
1611 self.kanidm_name(),
1612 e,
1613 )
1614 })?;
1615 changed = true;
1616 }
1617 Ok((Action::requeue(idm_reconcile_interval()), changed))
1618 }
1619}
1620
1621pub fn is_oauth2(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
1622 status
1623 .conditions
1624 .unwrap_or_default()
1625 .iter()
1626 .any(|c| c.type_ == type_ && c.status == CONDITION_TRUE)
1627}
1628
1629pub fn is_oauth2_false(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
1630 status
1631 .conditions
1632 .unwrap_or_default()
1633 .iter()
1634 .any(|c| c.type_ == type_ && c.status == CONDITION_FALSE)
1635}