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_k8s_util::error::{Error, Result};
19use kaniop_operator::controller::DEFAULT_RECONCILE_INTERVAL;
20use kaniop_operator::controller::context::{IdmClientContext, KubeOperations};
21use kaniop_operator::controller::kanidm::{KanidmResource, is_resource_watched};
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 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 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(¤t_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(¤t_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(¤t_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(¤t_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}