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