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_SECRET_ROTATED, TYPE_STRICT_REDIRECT_URL_UPDATED,
10 TYPE_SUP_SCOPE_MAP_UPDATED, 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 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 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
215 .generate_secret(&kanidm_client, self.spec.secret_rotation.as_ref())
216 .await?;
217 self.patch(&ctx, secret).await?;
218 require_status_update = true;
219 }
220
221 if is_oauth2_false(TYPE_SECRET_ROTATED, status.clone()) {
223 self.rotate_secret(&kanidm_client, name, ctx.clone())
224 .await?;
225 require_status_update = true;
226 }
227
228 if is_oauth2_false(TYPE_UPDATED, status.clone()) {
229 self.update(&kanidm_client, name).await?;
230 require_status_update = true;
231 }
232
233 if is_oauth2_false(TYPE_REDIRECT_URL_UPDATED, status.clone()) {
234 self.update_redirect_url(&kanidm_client, name, &status)
235 .await?;
236 require_status_update = true;
237 }
238
239 if is_oauth2_false(TYPE_SCOPE_MAP_UPDATED, status.clone()) {
240 self.update_scope_map(&kanidm_client, name, &status).await?;
241 require_status_update = true;
242 }
243
244 if is_oauth2_false(TYPE_SUP_SCOPE_MAP_UPDATED, status.clone()) {
245 self.update_sup_scope_map(&kanidm_client, name, &status)
246 .await?;
247 require_status_update = true;
248 }
249
250 if is_oauth2_false(TYPE_CLAIMS_MAP_UPDATED, status.clone()) {
251 self.update_claims_map(&kanidm_client, name, &status)
252 .await?;
253 require_status_update = true;
254 }
255
256 if is_oauth2_false(TYPE_STRICT_REDIRECT_URL_UPDATED, status.clone()) {
257 self.update_strict_redirect_url(&kanidm_client, name)
258 .await?;
259 require_status_update = true;
260 }
261
262 if is_oauth2_false(TYPE_DISABLE_PKCE_UPDATED, status.clone()) {
263 self.update_disable_pkce(&kanidm_client, name).await?;
264 require_status_update = true;
265 }
266
267 if is_oauth2_false(TYPE_PREFER_SHORT_NAME_UPDATED, status.clone()) {
268 self.update_prefer_short_name(&kanidm_client, name).await?;
269 require_status_update = true;
270 }
271
272 if is_oauth2_false(TYPE_ALLOW_LOCALHOST_REDIRECT_UPDATED, status.clone()) {
273 self.update_allow_localhost_redirect(&kanidm_client, name)
274 .await?;
275 require_status_update = true;
276 }
277
278 if is_oauth2_false(TYPE_LEGACY_CRYPTO_UPDATED, status.clone()) {
279 self.update_legacy_crypto(&kanidm_client, name).await?;
280 require_status_update = true;
281 }
282
283 if require_status_update {
284 trace!(msg = "status update required, requeueing in 500ms");
285 Ok(Action::requeue(Duration::from_millis(500)))
286 } else {
287 Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL))
288 }
289 }
290
291 async fn create(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
292 debug!(msg = "create");
293 if self.spec.public {
294 debug!(msg = "create public client");
295 kanidm_client
296 .idm_oauth2_rs_public_create(name, &self.spec.displayname, &self.spec.origin)
297 .await
298 .map_err(|e| {
299 Error::KanidmClientError(
300 format!(
301 "failed to create {name} from {namespace}/{kanidm}",
302 namespace = self.kanidm_namespace(),
303 kanidm = self.kanidm_name(),
304 ),
305 Box::new(e),
306 )
307 })?;
308 } else {
309 kanidm_client
310 .idm_oauth2_rs_basic_create(name, &self.spec.displayname, &self.spec.origin)
311 .await
312 .map_err(|e| {
313 Error::KanidmClientError(
314 format!(
315 "failed to create {name} from {namespace}/{kanidm}",
316 namespace = self.kanidm_namespace(),
317 kanidm = self.kanidm_name(),
318 ),
319 Box::new(e),
320 )
321 })?;
322 }
323 Ok(())
324 }
325
326 async fn update(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
327 debug!(msg = "update");
328 kanidm_client
329 .idm_oauth2_rs_update(
330 name,
331 None,
332 Some(&self.spec.displayname),
333 Some(&self.spec.origin),
334 false,
335 )
336 .await
337 .map_err(|e| {
338 Error::KanidmClientError(
339 format!(
340 "failed to create {name} from {namespace}/{kanidm}",
341 namespace = self.kanidm_namespace(),
342 kanidm = self.kanidm_name(),
343 ),
344 Box::new(e),
345 )
346 })?;
347 Ok(())
348 }
349
350 async fn rotate_secret(
351 &self,
352 kanidm_client: &KanidmClient,
353 name: &str,
354 ctx: Arc<Context>,
355 ) -> Result<()> {
356 info!(msg = "rotating OAuth2 client secret");
357 kanidm_client
359 .idm_oauth2_rs_update(name, None, None, None, true)
360 .await
361 .map_err(|e| {
362 Error::KanidmClientError(
363 format!(
364 "failed to rotate secret for {name} from {namespace}/{kanidm}",
365 namespace = self.kanidm_namespace(),
366 kanidm = self.kanidm_name(),
367 ),
368 Box::new(e),
369 )
370 })?;
371
372 let secret = self
374 .generate_secret(kanidm_client, self.spec.secret_rotation.as_ref())
375 .await?;
376 self.patch(&ctx, secret).await?;
377 Ok(())
378 }
379
380 async fn update_redirect_url(
381 &self,
382 kanidm_client: &KanidmClient,
383 name: &str,
384 status: &KanidmOAuth2ClientStatus,
385 ) -> Result<()> {
386 debug!(msg = format!("update {ATTR_OAUTH2_RS_ORIGIN} attribute"));
387
388 let current_urls: BTreeSet<_> = status
389 .origin
390 .as_ref()
391 .map(|o| o.iter().map(|u| url::Url::parse(u).unwrap()).collect())
392 .unwrap_or_default();
393
394 let redirect_url = self
395 .spec
396 .redirect_url
397 .iter()
398 .map(|u| {
399 url::Url::parse(u).map_err(|e| {
400 Error::UrlParseError(
401 format!(
402 "failed to parse redirect URL {u} for {name} from {namespace}/{kanidm}",
403 namespace = self.kanidm_namespace(),
404 kanidm = self.kanidm_name(),
405 ),
406 e,
407 )
408 })
409 })
410 .collect::<Result<BTreeSet<_>>>()?;
411
412 let delete_futures = current_urls
413 .difference(&redirect_url)
414 .map(|url| kanidm_client.idm_oauth2_client_remove_origin(name, url))
415 .collect::<TryJoinAll<_>>();
416
417 let add_futures = redirect_url
418 .difference(¤t_urls)
419 .map(|url| kanidm_client.idm_oauth2_client_add_origin(name, url))
420 .collect::<TryJoinAll<_>>();
421
422 futures::try_join!(delete_futures, add_futures).map_err(|e| {
423 Error::KanidmClientError(
424 format!(
425 "failed to modify {ATTR_OAUTH2_RS_ORIGIN} for {name} from {namespace}/{kanidm}",
426 namespace = self.kanidm_namespace(),
427 kanidm = self.kanidm_name(),
428 ),
429 Box::new(e),
430 )
431 })?;
432
433 Ok(())
434 }
435
436 async fn update_scope_map(
437 &self,
438 kanidm_client: &KanidmClient,
439 name: &str,
440 status: &KanidmOAuth2ClientStatus,
441 ) -> Result<()> {
442 debug!(msg = format!("update {ATTR_OAUTH2_RS_SCOPE_MAP} attribute"));
443
444 let current_scope_map: BTreeSet<_> = status
445 .scope_map
446 .as_ref()
447 .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
448 .unwrap_or_default();
449
450 let scope_map: BTreeSet<KanidmScopeMap> = self
451 .spec
452 .scope_map
453 .clone()
454 .unwrap_or_default()
455 .clone()
456 .into_iter()
457 .collect();
458
459 let delete_futures = current_scope_map
460 .difference(&scope_map)
461 .map(|s| kanidm_client.idm_oauth2_rs_delete_scope_map(name, &s.group))
462 .collect::<TryJoinAll<_>>();
463
464 let add_futures = scope_map
465 .difference(¤t_scope_map)
466 .map(|s| {
467 kanidm_client.idm_oauth2_rs_update_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_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_sup_scope_map(
489 &self,
490 kanidm_client: &KanidmClient,
491 name: &str,
492 status: &KanidmOAuth2ClientStatus,
493 ) -> Result<()> {
494 debug!(msg = format!("update {ATTR_OAUTH2_RS_SUP_SCOPE_MAP} attribute"));
495
496 let current_sup_scope_map: BTreeSet<_> = status
497 .sup_scope_map
498 .as_ref()
499 .map(|v| v.iter().filter_map(|v| KanidmScopeMap::from(v)).collect())
500 .unwrap_or_default();
501
502 let sup_scope_map: BTreeSet<KanidmScopeMap> = self
503 .spec
504 .sup_scope_map
505 .clone()
506 .unwrap_or_default()
507 .clone()
508 .into_iter()
509 .collect();
510
511 let delete_futures = current_sup_scope_map
512 .difference(&sup_scope_map)
513 .map(|s| kanidm_client.idm_oauth2_rs_delete_sup_scope_map(name, &s.group))
514 .collect::<TryJoinAll<_>>();
515
516 let add_futures = sup_scope_map
517 .difference(¤t_sup_scope_map)
518 .map(|s| {
519 kanidm_client.idm_oauth2_rs_update_sup_scope_map(
520 name,
521 &s.group,
522 s.scopes.iter().map(|s| s.as_str()).collect(),
523 )
524 })
525 .collect::<TryJoinAll<_>>();
526
527 try_join!(delete_futures, add_futures).map_err(|e| {
528 Error::KanidmClientError(
529 format!(
530 "failed to modify {ATTR_OAUTH2_RS_SUP_SCOPE_MAP} for {name} from {namespace}/{kanidm}",
531 namespace = self.kanidm_namespace(),
532 kanidm = self.kanidm_name(),
533 ),
534 Box::new(e),
535 )
536 })?;
537 Ok(())
538 }
539
540 async fn update_claims_map(
541 &self,
542 kanidm_client: &KanidmClient,
543 name: &str,
544 status: &KanidmOAuth2ClientStatus,
545 ) -> Result<()> {
546 debug!(msg = format!("update {ATTR_OAUTH2_RS_CLAIM_MAP} attribute"));
547
548 let current_claims_map: BTreeSet<_> = status
549 .claims_map
550 .as_ref()
551 .map(|v| {
552 KanidmClaimMap::group(
553 &v.iter()
554 .filter_map(|c| KanidmClaimMap::from(c))
555 .collect::<Vec<_>>(),
556 )
557 })
558 .unwrap_or_default();
559
560 let claims_map: BTreeSet<KanidmClaimMap> = self
561 .spec
562 .claim_map
563 .clone()
564 .unwrap_or_default()
565 .clone()
566 .into_iter()
567 .collect();
568
569 let delete_futures = current_claims_map
570 .difference(&claims_map)
571 .flat_map(|c| {
572 c.values_map
573 .iter()
574 .map(|v| kanidm_client.idm_oauth2_rs_delete_claim_map(name, &c.name, &v.group))
575 })
576 .collect::<TryJoinAll<_>>();
577
578 let claims_to_add = claims_map.difference(¤t_claims_map);
579 let add_futures = claims_to_add
580 .clone()
581 .flat_map(|c| {
582 c.values_map.iter().map(|v| {
583 kanidm_client.idm_oauth2_rs_update_claim_map(name, &c.name, &v.group, &v.values)
584 })
585 })
586 .collect::<TryJoinAll<_>>();
587
588 let join_strategy_futures = claims_to_add
589 .map(|c| {
590 kanidm_client.idm_oauth2_rs_update_claim_map_join(
591 name,
592 &c.name,
593 c.join_strategy.to_oauth2_claim_map_join(),
594 )
595 })
596 .collect::<TryJoinAll<_>>();
597
598 try_join!(delete_futures, add_futures, join_strategy_futures).map_err(|e| {
599 Error::KanidmClientError(
600 format!(
601 "failed to modify {ATTR_OAUTH2_RS_CLAIM_MAP} for {name} from {namespace}/{kanidm}",
602 namespace = self.kanidm_namespace(),
603 kanidm = self.kanidm_name(),
604 ),
605 Box::new(e),
606 )
607 })?;
608 Ok(())
609 }
610
611 async fn update_strict_redirect_url(
612 &self,
613 kanidm_client: &KanidmClient,
614 name: &str,
615 ) -> Result<()> {
616 debug!(msg = format!("update {ATTR_OAUTH2_STRICT_REDIRECT_URI} attribute"));
617 if let Some(strict_redirect_url_enabled) = self.spec.strict_redirect_url {
618 if strict_redirect_url_enabled {
619 kanidm_client
620 .idm_oauth2_rs_enable_strict_redirect_uri(
621 name,
622 )
623 .await
624 .map_err(|e| {
625 Error::KanidmClientError(
626 format!(
627 "failed to update {ATTR_OAUTH2_STRICT_REDIRECT_URI} for {name} from {namespace}/{kanidm}",
628 namespace = self.kanidm_namespace(),
629 kanidm = self.kanidm_name(),
630 ),
631 Box::new(e),
632 )
633 })?;
634 } else {
635 kanidm_client
636 .idm_oauth2_rs_disable_strict_redirect_uri(
637 name,
638 )
639 .await
640 .map_err(|e| {
641 Error::KanidmClientError(
642 format!(
643 "failed to update {ATTR_OAUTH2_STRICT_REDIRECT_URI} for {name} from {namespace}/{kanidm}",
644 namespace = self.kanidm_namespace(),
645 kanidm = self.kanidm_name(),
646 ),
647 Box::new(e),
648 )
649 })?;
650 }
651 };
652 Ok(())
653 }
654
655 async fn update_disable_pkce(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
656 debug!(msg = format!("update {ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE} attribute"));
657 if let Some(disable_pkce) = self.spec.allow_insecure_client_disable_pkce {
658 if disable_pkce {
659 kanidm_client
660 .idm_oauth2_rs_disable_pkce(
661 name,
662 )
663 .await
664 .map_err(|e| {
665 Error::KanidmClientError(
666 format!(
667 "failed to update {ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE} for {name} from {namespace}/{kanidm}",
668 namespace = self.kanidm_namespace(),
669 kanidm = self.kanidm_name(),
670 ),
671 Box::new(e),
672 )
673 })?;
674 } else {
675 kanidm_client
676 .idm_oauth2_rs_enable_pkce(
677 name,
678 )
679 .await
680 .map_err(|e| {
681 Error::KanidmClientError(
682 format!(
683 "failed to update {ATTR_OAUTH2_ALLOW_INSECURE_CLIENT_DISABLE_PKCE} for {name} from {namespace}/{kanidm}",
684 namespace = self.kanidm_namespace(),
685 kanidm = self.kanidm_name(),
686 ),
687 Box::new(e),
688 )
689 })?;
690 }
691 };
692 Ok(())
693 }
694
695 async fn update_prefer_short_name(
696 &self,
697 kanidm_client: &KanidmClient,
698 name: &str,
699 ) -> Result<()> {
700 debug!(msg = format!("update {ATTR_OAUTH2_PREFER_SHORT_USERNAME} attribute"));
701 if let Some(prefer_short_username) = self.spec.prefer_short_username {
702 if prefer_short_username {
703 kanidm_client
704 .idm_oauth2_rs_prefer_short_username(
705 name,
706 )
707 .await
708 .map_err(|e| {
709 Error::KanidmClientError(
710 format!(
711 "failed to update {ATTR_OAUTH2_PREFER_SHORT_USERNAME} for {name} from {namespace}/{kanidm}",
712 namespace = self.kanidm_namespace(),
713 kanidm = self.kanidm_name(),
714 ),
715 Box::new(e),
716 )
717 })?;
718 } else {
719 kanidm_client
720 .idm_oauth2_rs_prefer_spn_username(
721 name,
722 )
723 .await
724 .map_err(|e| {
725 Error::KanidmClientError(
726 format!(
727 "failed to update {ATTR_OAUTH2_PREFER_SHORT_USERNAME} for {name} from {namespace}/{kanidm}",
728 namespace = self.kanidm_namespace(),
729 kanidm = self.kanidm_name(),
730 ),
731 Box::new(e),
732 )
733 })?;
734 }
735 };
736 Ok(())
737 }
738
739 async fn update_allow_localhost_redirect(
740 &self,
741 kanidm_client: &KanidmClient,
742 name: &str,
743 ) -> Result<()> {
744 debug!(msg = format!("update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} attribute"));
745 if let Some(allow_localhost_redirect) = self.spec.allow_localhost_redirect {
746 if allow_localhost_redirect {
747 kanidm_client
748 .idm_oauth2_rs_enable_public_localhost_redirect(
749 name,
750 )
751 .await
752 .map_err(|e| {
753 Error::KanidmClientError(
754 format!(
755 "failed to update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} for {name} from {namespace}/{kanidm}",
756 namespace = self.kanidm_namespace(),
757 kanidm = self.kanidm_name(),
758 ),
759 Box::new(e),
760 )
761 })?;
762 } else {
763 kanidm_client
764 .idm_oauth2_rs_disable_public_localhost_redirect(
765 name,
766 )
767 .await
768 .map_err(|e| {
769 Error::KanidmClientError(
770 format!(
771 "failed to update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} for {name} from {namespace}/{kanidm}",
772 namespace = self.kanidm_namespace(),
773 kanidm = self.kanidm_name(),
774 ),
775 Box::new(e),
776 )
777 })?;
778 }
779 };
780 Ok(())
781 }
782
783 async fn update_legacy_crypto(&self, kanidm_client: &KanidmClient, name: &str) -> Result<()> {
784 debug!(msg = format!("update {ATTR_OAUTH2_ALLOW_LOCALHOST_REDIRECT} attribute"));
785 if let Some(legacy_crypto) = self.spec.jwt_legacy_crypto_enable {
786 if legacy_crypto {
787 kanidm_client
788 .idm_oauth2_rs_enable_legacy_crypto(
789 name,
790 )
791 .await
792 .map_err(|e| {
793 Error::KanidmClientError(
794 format!(
795 "failed to update {ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE} for {name} from {namespace}/{kanidm}",
796 namespace = self.kanidm_namespace(),
797 kanidm = self.kanidm_name(),
798 ),
799 Box::new(e),
800 )
801 })?;
802 } else {
803 kanidm_client
804 .idm_oauth2_rs_disable_legacy_crypto(
805 name,
806 )
807 .await
808 .map_err(|e| {
809 Error::KanidmClientError(
810 format!(
811 "failed to update {ATTR_OAUTH2_JWT_LEGACY_CRYPTO_ENABLE} for {name} from {namespace}/{kanidm}",
812 namespace = self.kanidm_namespace(),
813 kanidm = self.kanidm_name(),
814 ),
815 Box::new(e),
816 )
817 })?;
818 }
819 };
820 Ok(())
821 }
822
823 async fn cleanup(
824 &self,
825 kanidm_client: Arc<KanidmClient>,
826 status: KanidmOAuth2ClientStatus,
827 ) -> Result<Action> {
828 let name = &self.name_any();
829 if is_oauth2(TYPE_EXISTS, status.clone()) {
830 debug!(msg = "delete");
831 kanidm_client
832 .idm_oauth2_rs_delete(name)
833 .await
834 .map_err(|e| {
835 Error::KanidmClientError(
836 format!(
837 "failed to delete {name} from {namespace}/{kanidm}",
838 namespace = self.kanidm_namespace(),
839 kanidm = self.kanidm_name(),
840 ),
841 Box::new(e),
842 )
843 })?;
844 }
845 Ok(Action::requeue(DEFAULT_RECONCILE_INTERVAL))
846 }
847}
848
849pub fn is_oauth2(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
850 status
851 .conditions
852 .unwrap_or_default()
853 .iter()
854 .any(|c| c.type_ == type_ && c.status == CONDITION_TRUE)
855}
856
857pub fn is_oauth2_false(type_: &str, status: KanidmOAuth2ClientStatus) -> bool {
858 status
859 .conditions
860 .unwrap_or_default()
861 .iter()
862 .any(|c| c.type_ == type_ && c.status == CONDITION_FALSE)
863}