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