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