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 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 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 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(¤t_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(¤t_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(¤t_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(¤t_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}