kaniop_oauth2/reconcile/
mod.rs

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_PKCE_UPDATED, TYPE_EXISTS, TYPE_LEGACY_CRYPTO_UPDATED,
8    TYPE_PREFER_SHORT_NAME_UPDATED, TYPE_REDIRECT_URL_UPDATED, TYPE_SCOPE_MAP_UPDATED,
9    TYPE_SECRET_INITIALIZED, TYPE_STRICT_REDIRECT_URL_UPDATED, TYPE_SUP_SCOPE_MAP_UPDATED,
10    TYPE_UPDATED,
11};
12
13use crate::{
14    controller::Context,
15    crd::{KanidmClaimMap, KanidmOAuth2Client, KanidmOAuth2ClientStatus, KanidmScopeMap},
16};
17
18use kaniop_operator::controller::DEFAULT_RECONCILE_INTERVAL;
19use kaniop_operator::controller::context::{IdmClientContext, KubeOperations};
20use kaniop_operator::controller::kanidm::KanidmResource;
21use kaniop_operator::error::{Error, Result};
22use kaniop_operator::telemetry;
23
24use std::collections::BTreeSet;
25use std::sync::Arc;
26use std::time::Duration;
27
28use futures::future::TryJoinAll;
29use futures::try_join;
30
31use k8s_openapi::NamespaceResourceScope;
32use kanidm_client::KanidmClient;
33use kanidm_proto::constants::{
34    ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE, ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT,
35    ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE, ATTR_OAUTH2_PREFER_SHORT_USERNAME,
36    ATTR_OAUTH2_RS_CLAIM_MAP, ATTR_OAUTH2_RS_ORIGIN, ATTR_OAUTH2_RS_SCOPE_MAP,
37    ATTR_OAUTH2_RS_SUP_SCOPE_MAP, ATTR_OAUTH2_STRICT_REDIRECT_URI,
38};
39use kube::api::Api;
40use kube::core::{Selector, SelectorExt};
41use kube::runtime::controller::Action;
42use kube::runtime::events::{Event, EventType};
43use kube::runtime::finalizer::{Event as Finalizer, finalizer};
44use kube::{Resource, ResourceExt};
45use serde::{Deserialize, Serialize};
46
47use tracing::{Span, debug, field, info, instrument, trace, warn};
48
49static OAUTH2_OPERATOR_NAME: &str = "kanidmoauth2clients.kaniop.rs";
50static OAUTH2_FINALIZER: &str = "kanidms.kaniop.rs/oauth2-client";
51
52pub fn watched_resource(oauth2: &KanidmOAuth2Client, ctx: Arc<Context>) -> bool {
53    let namespace = oauth2.get_namespace();
54    trace!(msg = "check if resource is watched");
55    let kanidm = if let Some(k) = ctx.kaniop_ctx.get_kanidm(oauth2) {
56        k
57    } else {
58        trace!(msg = "no kanidm found");
59        return false;
60    };
61
62    let namespace_selector = if let Some(l) = kanidm.spec.oauth2_client_namespace_selector.clone() {
63        l
64    } else {
65        trace!(msg = "no namespace selector found, defaulting to current namespace");
66        // A null label selector (default value) matches the current namespace only
67        return kanidm.namespace().unwrap() == namespace;
68    };
69
70    let selector: Selector = if let Ok(s) = namespace_selector.try_into() {
71        s
72    } else {
73        trace!(msg = "failed to parse namespace selector, defaulting to current namespace");
74        return kanidm.namespace().unwrap() == namespace;
75    };
76    trace!(msg = "namespace selector", ?selector);
77    ctx.kaniop_ctx
78        .namespace_store
79        .state()
80        .iter()
81        .filter(|n| selector.matches(n.metadata.labels.as_ref().unwrap_or(&Default::default())))
82        .any(|n| n.name_any() == namespace)
83}
84
85#[instrument(skip(ctx, oauth2))]
86pub async fn reconcile_oauth2(
87    oauth2: Arc<KanidmOAuth2Client>,
88    ctx: Arc<Context>,
89) -> Result<Action> {
90    let trace_id = telemetry::get_trace_id();
91    Span::current().record("trace_id", field::display(&trace_id));
92    let _timer = ctx
93        .kaniop_ctx
94        .metrics
95        .reconcile_count_and_measure(&trace_id);
96    let kanidm_client = ctx.get_idm_client(&oauth2).await?;
97
98    if !watched_resource(&oauth2, ctx.clone()) {
99        debug!(msg = "resource not watched, skipping reconcile");
100        ctx.kaniop_ctx.recorder
101        .publish(
102            &Event {
103                type_: EventType::Warning,
104                reason: "ResourceNotWatched".to_string(),
105                note: Some("configure `oauth2ClientNamespaceSelector` on Kanidm resource to watch this namespace".to_string()),
106                action: "Reconcile".to_string(),
107                secondary: None,
108            },
109            &oauth2.object_ref(&()),
110        )
111        .await
112        .map_err(|e| {
113            warn!(msg = "failed to publish KanidmError event", %e);
114            Error::KubeError("failed to publish event".to_string(), Box::new(e))
115        })?;
116        return Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL));
117    }
118
119    info!(msg = "reconciling oauth2 client");
120    let namespace = oauth2.get_namespace();
121    let status = oauth2
122        .update_status(kanidm_client.clone(), ctx.clone())
123        .await
124        .map_err(|e| {
125            debug!(msg = "failed to reconcile status", %e);
126            ctx.kaniop_ctx.metrics.status_update_errors_inc();
127            e
128        })?;
129    let persons_api: Api<KanidmOAuth2Client> =
130        Api::namespaced(ctx.kaniop_ctx.client.clone(), &namespace);
131    finalizer(&persons_api, OAUTH2_FINALIZER, oauth2, |event| async {
132        match event {
133            Finalizer::Apply(p) => p.reconcile(kanidm_client, status, ctx).await,
134            Finalizer::Cleanup(p) => p.cleanup(kanidm_client, status).await,
135        }
136    })
137    .await
138    .map_err(|e| {
139        Error::FinalizerError("failed on oauth2 client finalizer".to_string(), Box::new(e))
140    })
141}
142
143impl KanidmOAuth2Client {
144    // Method kube_patch are provided by KubeOperations trait
145    pub async fn patch<K>(&self, ctx: &Context, resource: K) -> Result<K>
146    where
147        K: Resource<Scope = NamespaceResourceScope>
148            + Serialize
149            + Clone
150            + std::fmt::Debug
151            + for<'de> Deserialize<'de>,
152        <K as kube::Resource>::DynamicType: Default,
153        <K as Resource>::Scope: std::marker::Sized,
154    {
155        self.kube_patch(
156            ctx.kaniop_ctx.client.clone(),
157            &ctx.kaniop_ctx.metrics,
158            resource,
159            OAUTH2_OPERATOR_NAME,
160        )
161        .await
162    }
163
164    #[inline]
165    fn get_namespace(&self) -> String {
166        // safe unwrap: oauth2 is namespaced scoped
167        self.namespace().unwrap()
168    }
169
170    #[inline]
171    async fn reconcile(
172        &self,
173        kanidm_client: Arc<KanidmClient>,
174        status: KanidmOAuth2ClientStatus,
175        ctx: Arc<Context>,
176    ) -> Result<Action> {
177        match self
178            .internal_reconcile(kanidm_client, status, ctx.clone())
179            .await
180        {
181            Ok(action) => Ok(action),
182            Err(e) => match e {
183                Error::KanidmClientError(_, _) => {
184                    ctx.kaniop_ctx
185                        .recorder
186                        .publish(
187                            &Event {
188                                type_: EventType::Warning,
189                                reason: "KanidmError".to_string(),
190                                note: Some(format!("{e:?}")),
191                                action: "KanidmRequest".to_string(),
192                                secondary: None,
193                            },
194                            &self.object_ref(&()),
195                        )
196                        .await
197                        .map_err(|e| {
198                            warn!(msg = "failed to publish KanidmError event", %e);
199                            Error::KubeError("failed to publish event".to_string(), Box::new(e))
200                        })?;
201                    Err(e)
202                }
203                _ => Err(e),
204            },
205        }
206    }
207
208    #[inline]
209    async fn internal_reconcile(
210        &self,
211        kanidm_client: Arc<KanidmClient>,
212        status: KanidmOAuth2ClientStatus,
213        ctx: Arc<Context>,
214    ) -> Result<Action> {
215        let name = &self.name_any();
216        let mut require_status_update = false;
217
218        if is_oauth2_false(TYPE_EXISTS, status.clone()) {
219            self.create(&kanidm_client, name).await?;
220            require_status_update = true;
221        }
222
223        if is_oauth2_false(TYPE_SECRET_INITIALIZED, status.clone()) {
224            let secret = self.generate_secret(&kanidm_client).await?;
225            self.patch(&ctx, secret).await?;
226            require_status_update = true;
227        }
228
229        if is_oauth2_false(TYPE_UPDATED, status.clone()) {
230            self.update(&kanidm_client, name).await?;
231            require_status_update = true;
232        }
233
234        if is_oauth2_false(TYPE_REDIRECT_URL_UPDATED, status.clone()) {
235            self.update_redirect_url(&kanidm_client, name, &status)
236                .await?;
237            require_status_update = true;
238        }
239
240        if is_oauth2_false(TYPE_SCOPE_MAP_UPDATED, status.clone()) {
241            self.update_scope_map(&kanidm_client, name, &status).await?;
242            require_status_update = true;
243        }
244
245        if is_oauth2_false(TYPE_SUP_SCOPE_MAP_UPDATED, status.clone()) {
246            self.update_sup_scope_map(&kanidm_client, name, &status)
247                .await?;
248            require_status_update = true;
249        }
250
251        if is_oauth2_false(TYPE_CLAIMS_MAP_UPDATED, status.clone()) {
252            self.update_claims_map(&kanidm_client, name, &status)
253                .await?;
254            require_status_update = true;
255        }
256
257        if is_oauth2_false(TYPE_STRICT_REDIRECT_URL_UPDATED, status.clone()) {
258            self.update_strict_redirect_url(&kanidm_client, name)
259                .await?;
260            require_status_update = true;
261        }
262
263        if is_oauth2_false(TYPE_DISABLE_PKCE_UPDATED, status.clone()) {
264            self.update_disable_pkce(&kanidm_client, name).await?;
265            require_status_update = true;
266        }
267
268        if is_oauth2_false(TYPE_PREFER_SHORT_NAME_UPDATED, status.clone()) {
269            self.update_prefer_short_name(&kanidm_client, name).await?;
270            require_status_update = true;
271        }
272
273        if is_oauth2_false(TYPE_ALLOW_LOCALHOST_REDIRECT_UPDATED, status.clone()) {
274            self.update_allow_localhost_redirect(&kanidm_client, name)
275                .await?;
276            require_status_update = true;
277        }
278
279        if is_oauth2_false(TYPE_LEGACY_CRYPTO_UPDATED, status.clone()) {
280            self.update_legacy_crypto(&kanidm_client, name).await?;
281            require_status_update = true;
282        }
283
284        if require_status_update {
285            trace!(msg = "status update required, requeueing in 500ms");
286            Ok(Action::requeue(Duration::from_millis(500)))
287        } else {
288            Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL))
289        }
290    }
291
292    async fn create(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
293        debug!(msg = "create");
294        if self.spec.public {
295            debug!(msg = "create public client");
296            kanidm_client
297                .idm_oauth2_rs_public_create(name, &self.spec.displayname, &self.spec.origin)
298                .await
299                .map_err(|e| {
300                    Error::KanidmClientError(
301                        format!(
302                            "failed to create {name} from {namespace}/{kanidm}",
303                            namespace = self.kanidm_namespace(),
304                            kanidm = self.kanidm_name(),
305                        ),
306                        Box::new(e),
307                    )
308                })?;
309        } else {
310            kanidm_client
311                .idm_oauth2_rs_basic_create(name, &self.spec.displayname, &self.spec.origin)
312                .await
313                .map_err(|e| {
314                    Error::KanidmClientError(
315                        format!(
316                            "failed to create {name} from {namespace}/{kanidm}",
317                            namespace = self.kanidm_namespace(),
318                            kanidm = self.kanidm_name(),
319                        ),
320                        Box::new(e),
321                    )
322                })?;
323        }
324        Ok(())
325    }
326
327    async fn update(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
328        debug!(msg = "update");
329        kanidm_client
330            .idm_oauth2_rs_update(
331                name,
332                None,
333                Some(&self.spec.displayname),
334                Some(&self.spec.origin),
335                false,
336            )
337            .await
338            .map_err(|e| {
339                Error::KanidmClientError(
340                    format!(
341                        "failed to create {name} from {namespace}/{kanidm}",
342                        namespace = self.kanidm_namespace(),
343                        kanidm = self.kanidm_name(),
344                    ),
345                    Box::new(e),
346                )
347            })?;
348        Ok(())
349    }
350
351    async fn update_redirect_url(
352        &self,
353        kanidm_client: &KanidmClient,
354        name: &str,
355        status: &KanidmOAuth2ClientStatus,
356    ) -> Result<()> {
357        debug!(msg = format!("update {ATTR_OAUTH2_RS_ORIGIN} attribute"));
358
359        let current_urls: BTreeSet<_> = status
360            .origin
361            .as_ref()
362            .map(|o| o.iter().map(|u| url::Url::parse(u).unwrap()).collect())
363            .unwrap_or_default();
364
365        let redirect_url = self
366            .spec
367            .redirect_url
368            .iter()
369            .map(|u| {
370                url::Url::parse(u).map_err(|e| {
371                    Error::ParseError(
372                        format!(
373                            "failed to parse redirect URL {u} for {name} from {namespace}/{kanidm}",
374                            namespace = self.kanidm_namespace(),
375                            kanidm = self.kanidm_name(),
376                        ),
377                        e,
378                    )
379                })
380            })
381            .collect::<Result<BTreeSet<_>>>()?;
382
383        let delete_futures = current_urls
384            .difference(&redirect_url)
385            .map(|url| kanidm_client.idm_oauth2_client_remove_origin(name, url))
386            .collect::<TryJoinAll<_>>();
387
388        let add_futures = redirect_url
389            .difference(&current_urls)
390            .map(|url| kanidm_client.idm_oauth2_client_add_origin(name, url))
391            .collect::<TryJoinAll<_>>();
392
393        futures::try_join!(delete_futures, add_futures).map_err(|e| {
394            Error::KanidmClientError(
395                format!(
396                    "failed to modify {ATTR_OAUTH2_RS_ORIGIN} for {name} from {namespace}/{kanidm}",
397                    namespace = self.kanidm_namespace(),
398                    kanidm = self.kanidm_name(),
399                ),
400                Box::new(e),
401            )
402        })?;
403
404        Ok(())
405    }
406
407    async fn update_scope_map(
408        &self,
409        kanidm_client: &KanidmClient,
410        name: &str,
411        status: &KanidmOAuth2ClientStatus,
412    ) -> Result<()> {
413        debug!(msg = format!("update {ATTR_OAUTH2_RS_SCOPE_MAP} attribute"));
414
415        let current_scope_map: BTreeSet<_> = status
416            .scope_map
417            .as_ref()
418            .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
419            .unwrap_or_default();
420
421        let scope_map: BTreeSet<KanidmScopeMap> = self
422            .spec
423            .scope_map
424            .clone()
425            .unwrap_or_default()
426            .clone()
427            .into_iter()
428            .collect();
429
430        let delete_futures = current_scope_map
431            .difference(&scope_map)
432            .map(|s| kanidm_client.idm_oauth2_rs_delete_scope_map(name, &s.group))
433            .collect::<TryJoinAll<_>>();
434
435        let add_futures = scope_map
436            .difference(&current_scope_map)
437            .map(|s| {
438                kanidm_client.idm_oauth2_rs_update_scope_map(
439                    name,
440                    &s.group,
441                    s.scopes.iter().map(|s| s.as_str()).collect(),
442                )
443            })
444            .collect::<TryJoinAll<_>>();
445
446        try_join!(delete_futures, add_futures).map_err(|e| {
447            Error::KanidmClientError(
448                format!(
449                    "failed to modify {ATTR_OAUTH2_RS_SCOPE_MAP} for {name} from {namespace}/{kanidm}",
450                    namespace = self.kanidm_namespace(),
451                    kanidm = self.kanidm_name(),
452                ),
453                Box::new(e),
454            )
455        })?;
456        Ok(())
457    }
458
459    async fn update_sup_scope_map(
460        &self,
461        kanidm_client: &KanidmClient,
462        name: &str,
463        status: &KanidmOAuth2ClientStatus,
464    ) -> Result<()> {
465        debug!(msg = format!("update {ATTR_OAUTH2_RS_SUP_SCOPE_MAP} attribute"));
466
467        let current_sup_scope_map: BTreeSet<_> = status
468            .sup_scope_map
469            .as_ref()
470            .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
471            .unwrap_or_default();
472
473        let sup_scope_map: BTreeSet<KanidmScopeMap> = self
474            .spec
475            .sup_scope_map
476            .clone()
477            .unwrap_or_default()
478            .clone()
479            .into_iter()
480            .collect();
481
482        let delete_futures = current_sup_scope_map
483            .difference(&sup_scope_map)
484            .map(|s| kanidm_client.idm_oauth2_rs_delete_sup_scope_map(name, &s.group))
485            .collect::<TryJoinAll<_>>();
486
487        let add_futures = sup_scope_map
488            .difference(&current_sup_scope_map)
489            .map(|s| {
490                kanidm_client.idm_oauth2_rs_update_sup_scope_map(
491                    name,
492                    &s.group,
493                    s.scopes.iter().map(|s| s.as_str()).collect(),
494                )
495            })
496            .collect::<TryJoinAll<_>>();
497
498        try_join!(delete_futures, add_futures).map_err(|e| {
499            Error::KanidmClientError(
500                format!(
501                    "failed to modify {ATTR_OAUTH2_RS_SUP_SCOPE_MAP} for {name} from {namespace}/{kanidm}",
502                    namespace = self.kanidm_namespace(),
503                    kanidm = self.kanidm_name(),
504                ),
505                Box::new(e),
506            )
507        })?;
508        Ok(())
509    }
510
511    async fn update_claims_map(
512        &self,
513        kanidm_client: &KanidmClient,
514        name: &str,
515        status: &KanidmOAuth2ClientStatus,
516    ) -> Result<()> {
517        debug!(msg = format!("update {ATTR_OAUTH2_RS_CLAIM_MAP} attribute"));
518
519        let current_claims_map: BTreeSet<_> = status
520            .claims_map
521            .as_ref()
522            .map(|v| {
523                KanidmClaimMap::group(
524                    &v.iter()
525                        .filter_map(|c| KanidmClaimMap::from(c))
526                        .collect::<Vec<_>>(),
527                )
528            })
529            .unwrap_or_default();
530
531        let claims_map: BTreeSet<KanidmClaimMap> = self
532            .spec
533            .claim_map
534            .clone()
535            .unwrap_or_default()
536            .clone()
537            .into_iter()
538            .collect();
539
540        let delete_futures = current_claims_map
541            .difference(&claims_map)
542            .flat_map(|c| {
543                c.values_map
544                    .iter()
545                    .map(|v| kanidm_client.idm_oauth2_rs_delete_claim_map(name, &c.name, &v.group))
546            })
547            .collect::<TryJoinAll<_>>();
548
549        let claims_to_add = claims_map.difference(&current_claims_map);
550        let add_futures = claims_to_add
551            .clone()
552            .flat_map(|c| {
553                c.values_map.iter().map(|v| {
554                    kanidm_client.idm_oauth2_rs_update_claim_map(name, &c.name, &v.group, &v.values)
555                })
556            })
557            .collect::<TryJoinAll<_>>();
558
559        let join_strategy_futures = claims_to_add
560            .map(|c| {
561                kanidm_client.idm_oauth2_rs_update_claim_map_join(
562                    name,
563                    &c.name,
564                    c.join_strategy.to_oauth2_claim_map_join(),
565                )
566            })
567            .collect::<TryJoinAll<_>>();
568
569        try_join!(delete_futures, add_futures, join_strategy_futures).map_err(|e| {
570            Error::KanidmClientError(
571                format!(
572                    "failed to modify {ATTR_OAUTH2_RS_CLAIM_MAP} for {name} from {namespace}/{kanidm}",
573                    namespace = self.kanidm_namespace(),
574                    kanidm = self.kanidm_name(),
575                ),
576                Box::new(e),
577            )
578        })?;
579        Ok(())
580    }
581
582    async fn update_strict_redirect_url(
583        &self,
584        kanidm_client: &KanidmClient,
585        name: &str,
586    ) -> Result<()> {
587        debug!(msg = format!("update {ATTR_OAUTH2_STRICT_REDIRECT_URI} attribute"));
588        if let Some(strict_redirect_url_enabled) = self.spec.strict_redirect_url {
589            if strict_redirect_url_enabled {
590                kanidm_client
591                    .idm_oauth2_rs_enable_strict_redirect_uri(
592                        name,
593                    )
594                    .await
595                    .map_err(|e| {
596                        Error::KanidmClientError(
597                            format!(
598                                "failed to update {ATTR_OAUTH2_STRICT_REDIRECT_URI} for {name} from {namespace}/{kanidm}",
599                                namespace = self.kanidm_namespace(),
600                                kanidm = self.kanidm_name(),
601                            ),
602                            Box::new(e),
603                        )
604                    })?;
605            } else {
606                kanidm_client
607                .idm_oauth2_rs_disable_strict_redirect_uri(
608                    name,
609                )
610                .await
611                .map_err(|e| {
612                    Error::KanidmClientError(
613                        format!(
614                            "failed to update {ATTR_OAUTH2_STRICT_REDIRECT_URI} for {name} from {namespace}/{kanidm}",
615                            namespace = self.kanidm_namespace(),
616                            kanidm = self.kanidm_name(),
617                        ),
618                        Box::new(e),
619                    )
620                })?;
621            }
622        };
623        Ok(())
624    }
625
626    async fn update_disable_pkce(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
627        debug!(msg = format!("update {ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE} attribute"));
628        if let Some(disable_pkce) = self.spec.allow_insecure_client_disable_pkce {
629            if disable_pkce {
630                kanidm_client
631                    .idm_oauth2_rs_disable_pkce(
632                        name,
633                    )
634                    .await
635                    .map_err(|e| {
636                        Error::KanidmClientError(
637                            format!(
638                                "failed to update {ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE} for {name} from {namespace}/{kanidm}",
639                                namespace = self.kanidm_namespace(),
640                                kanidm = self.kanidm_name(),
641                            ),
642                            Box::new(e),
643                        )
644                    })?;
645            } else {
646                kanidm_client
647                .idm_oauth2_rs_enable_pkce(
648                    name,
649                )
650                .await
651                .map_err(|e| {
652                    Error::KanidmClientError(
653                        format!(
654                            "failed to update {ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE} for {name} from {namespace}/{kanidm}",
655                            namespace = self.kanidm_namespace(),
656                            kanidm = self.kanidm_name(),
657                        ),
658                        Box::new(e),
659                    )
660                })?;
661            }
662        };
663        Ok(())
664    }
665
666    async fn update_prefer_short_name(
667        &self,
668        kanidm_client: &KanidmClient,
669        name: &str,
670    ) -> Result<()> {
671        debug!(msg = format!("update {ATTR_OAUTH2_PREFER_SHORT_USERNAME} attribute"));
672        if let Some(prefer_short_username) = self.spec.prefer_short_username {
673            if prefer_short_username {
674                kanidm_client
675                    .idm_oauth2_rs_prefer_short_username(
676                        name,
677                    )
678                    .await
679                    .map_err(|e| {
680                        Error::KanidmClientError(
681                            format!(
682                                "failed to update {ATTR_OAUTH2_PREFER_SHORT_USERNAME} for {name} from {namespace}/{kanidm}",
683                                namespace = self.kanidm_namespace(),
684                                kanidm = self.kanidm_name(),
685                            ),
686                            Box::new(e),
687                        )
688                    })?;
689            } else {
690                kanidm_client
691                .idm_oauth2_rs_prefer_spn_username(
692                    name,
693                )
694                .await
695                .map_err(|e| {
696                    Error::KanidmClientError(
697                        format!(
698                            "failed to update {ATTR_OAUTH2_PREFER_SHORT_USERNAME} for {name} from {namespace}/{kanidm}",
699                            namespace = self.kanidm_namespace(),
700                            kanidm = self.kanidm_name(),
701                        ),
702                        Box::new(e),
703                    )
704                })?;
705            }
706        };
707        Ok(())
708    }
709
710    async fn update_allow_localhost_redirect(
711        &self,
712        kanidm_client: &KanidmClient,
713        name: &str,
714    ) -> Result<()> {
715        debug!(msg = format!("update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} attribute"));
716        if let Some(allow_localhost_redirect) = self.spec.allow_localhost_redirect {
717            if allow_localhost_redirect {
718                kanidm_client
719                    .idm_oauth2_rs_enable_public_localhost_redirect(
720                        name,
721                    )
722                    .await
723                    .map_err(|e| {
724                        Error::KanidmClientError(
725                            format!(
726                                "failed to update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} for {name} from {namespace}/{kanidm}",
727                                namespace = self.kanidm_namespace(),
728                                kanidm = self.kanidm_name(),
729                            ),
730                            Box::new(e),
731                        )
732                    })?;
733            } else {
734                kanidm_client
735                .idm_oauth2_rs_disable_public_localhost_redirect(
736                    name,
737                )
738                .await
739                .map_err(|e| {
740                    Error::KanidmClientError(
741                        format!(
742                            "failed to update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} for {name} from {namespace}/{kanidm}",
743                            namespace = self.kanidm_namespace(),
744                            kanidm = self.kanidm_name(),
745                        ),
746                        Box::new(e),
747                    )
748                })?;
749            }
750        };
751        Ok(())
752    }
753
754    async fn update_legacy_crypto(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
755        debug!(msg = format!("update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} attribute"));
756        if let Some(legacy_crypto) = self.spec.jwt_legacy_crypto_enable {
757            if legacy_crypto {
758                kanidm_client
759                    .idm_oauth2_rs_enable_legacy_crypto(
760                        name,
761                    )
762                    .await
763                    .map_err(|e| {
764                        Error::KanidmClientError(
765                            format!(
766                                "failed to update {ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE} for {name} from {namespace}/{kanidm}",
767                                namespace = self.kanidm_namespace(),
768                                kanidm = self.kanidm_name(),
769                            ),
770                            Box::new(e),
771                        )
772                    })?;
773            } else {
774                kanidm_client
775                .idm_oauth2_rs_disable_legacy_crypto(
776                    name,
777                )
778                .await
779                .map_err(|e| {
780                    Error::KanidmClientError(
781                        format!(
782                            "failed to update {ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE} for {name} from {namespace}/{kanidm}",
783                            namespace = self.kanidm_namespace(),
784                            kanidm = self.kanidm_name(),
785                        ),
786                        Box::new(e),
787                    )
788                })?;
789            }
790        };
791        Ok(())
792    }
793
794    async fn cleanup(
795        &self,
796        kanidm_client: Arc<KanidmClient>,
797        status: KanidmOAuth2ClientStatus,
798    ) -> Result<Action> {
799        let name = &self.name_any();
800        if is_oauth2(TYPE_EXISTS, status.clone()) {
801            debug!(msg = "delete");
802            kanidm_client
803                .idm_oauth2_rs_delete(name)
804                .await
805                .map_err(|e| {
806                    Error::KanidmClientError(
807                        format!(
808                            "failed to delete {name} from {namespace}/{kanidm}",
809                            namespace = self.kanidm_namespace(),
810                            kanidm = self.kanidm_name(),
811                        ),
812                        Box::new(e),
813                    )
814                })?;
815        }
816        Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL))
817    }
818}
819
820pub fn is_oauth2(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
821    status
822        .conditions
823        .unwrap_or_default()
824        .iter()
825        .any(|c| c.type_ == type_ && c.status == CONDITION_TRUE)
826}
827
828pub fn is_oauth2_false(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
829    status
830        .conditions
831        .unwrap_or_default()
832        .iter()
833        .any(|c| c.type_ == type_ && c.status == CONDITION_FALSE)
834}