From 80801ed4b3e6351c8d96b61230a809db1aa71b31 Mon Sep 17 00:00:00 2001
From: Dreaded_X <tim@huizinga.dev>
Date: Sat, 22 Mar 2025 04:43:57 +0100
Subject: [PATCH] Add Group controller (#8)

---
 src/context.rs |  1 +
 src/lldap.rs   |  1 +
 src/main.rs    | 41 ++++++++++++++++++++++++++++-------------
 3 files changed, 30 insertions(+), 13 deletions(-)

diff --git a/src/context.rs b/src/context.rs
index 416100c..3f551e2 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -4,6 +4,7 @@ use kube::{Resource, ResourceExt};
 
 use crate::lldap::LldapConfig;
 
+#[derive(Clone)]
 pub struct Context {
     pub client: kube::Client,
     pub lldap_config: LldapConfig,
diff --git a/src/lldap.rs b/src/lldap.rs
index ce407b3..2e51192 100644
--- a/src/lldap.rs
+++ b/src/lldap.rs
@@ -42,6 +42,7 @@ fn check_graphql_errors<T>(response: GraphQlResponse<T>) -> Result<T> {
         .expect("Data should be valid if there are no error"))
 }
 
+#[derive(Clone)]
 pub struct LldapConfig {
     username: String,
     password: String,
diff --git a/src/main.rs b/src/main.rs
index 70b8203..b860c36 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -3,22 +3,34 @@ use std::time::Duration;
 
 use futures::StreamExt;
 use k8s_openapi::api::core::v1::Secret;
-use kube::runtime::Controller;
-use kube::runtime::controller::Action;
-use kube::{Api, Client as KubeClient};
+use kube::runtime::controller::{self, Action};
+use kube::runtime::reflector::ObjectRef;
+use kube::runtime::{Controller, watcher};
+use kube::{Api, Client as KubeClient, Resource};
 use lldap_controller::context::Context;
 use lldap_controller::lldap::LldapConfig;
-use lldap_controller::resources::{self, ServiceUser, reconcile};
+use lldap_controller::resources::{self, Error, Group, ServiceUser, reconcile};
 use tracing::{debug, info, warn};
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
 use tracing_subscriber::{EnvFilter, Registry};
 
-fn error_policy(_obj: Arc<ServiceUser>, err: &resources::Error, _ctx: Arc<Context>) -> Action {
+fn error_policy<T>(_obj: Arc<T>, err: &resources::Error, _ctx: Arc<Context>) -> Action {
     warn!("error: {}", err);
     Action::requeue(Duration::from_secs(5))
 }
 
+async fn log_status<T>(
+    res: Result<(ObjectRef<T>, Action), controller::Error<Error, watcher::Error>>,
+) where
+    T: Resource,
+{
+    match res {
+        Ok(obj) => debug!("reconciled {:?}", obj.0.name),
+        Err(err) => warn!("reconcile failed: {}", err),
+    }
+}
+
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     let logger = tracing_subscriber::fmt::layer().json();
@@ -41,17 +53,20 @@ async fn main() -> anyhow::Result<()> {
     let service_users = Api::<ServiceUser>::all(client.clone());
     let secrets = Api::<Secret>::all(client.clone());
 
-    Controller::new(service_users.clone(), Default::default())
+    let service_user_controller = Controller::new(service_users, Default::default())
         .owns(secrets, Default::default())
+        .shutdown_on_signal()
+        .run(reconcile, error_policy, Arc::new(data.clone()))
+        .for_each(log_status);
+
+    let groups = Api::<Group>::all(client.clone());
+
+    let group_controller = Controller::new(groups, Default::default())
         .shutdown_on_signal()
         .run(reconcile, error_policy, Arc::new(data))
-        .for_each(|res| async move {
-            match res {
-                Ok(obj) => debug!("reconciled {:?}", obj.0.name),
-                Err(err) => warn!("reconcile failed: {}", err),
-            }
-        })
-        .await;
+        .for_each(log_status);
+
+    tokio::join!(service_user_controller, group_controller);
 
     Ok(())
 }