Prepare release 0.7.1

Cargo.toml

@@ -32,7 +32,7 @@ telemetry = ["tonic", "opentelemetry-otlp"]
 rand = { version = "0.9", features = ["small_rng"] }
 actix-web = "4.10.2"
 futures = "0.3.28"
-tokio = { version = "1.44.1", features = ["macros", "rt-multi-thread"] }
+tokio = { version = "1.44.1", features = ["macros", "rt-multi-thread", "process"] }
 k8s-openapi = { version = "0.24", features = ["latest", "schemars"] }
 kube = { version = "0.99.0", features = [
     "runtime",
@@ -52,8 +52,8 @@ tracing = "0.1.37"
 tracing-subscriber = { version = "0.3.19", features = ["json", "env-filter"] }
 tracing-opentelemetry = "0.28.0"
 opentelemetry = { version = "0.27.1", features = ["trace"] }
-opentelemetry-otlp = { version = "0.28.0", optional = true }
-opentelemetry_sdk = { version = "0.28.0", features = ["rt-tokio"] }
+opentelemetry-otlp = { version = "0.29.0", optional = true }
+opentelemetry_sdk = { version = "0.29.0", features = ["rt-tokio"] }
 tonic = { version = "0.12.3", optional = true }
 thiserror = "2.0.11"
 anyhow = "1.0.96"

src/api/capi_cluster.rs

@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 
-use cluster_api_rs::capi_cluster::{ClusterSpec, ClusterStatus, ClusterTopology};
+use cluster_api_rs::capi_cluster::{ClusterSpec, ClusterStatus};
 use fleet_api_rs::fleet_clustergroup::{ClusterGroupSelector, ClusterGroupSpec};
 use kube::{
     api::{ObjectMeta, TypeMeta},
@@ -44,51 +44,37 @@ impl Cluster {
     pub(crate) fn to_group(self: &Cluster, config: Option<&ClusterConfig>) -> Option<ClusterGroup> {
         config?.apply_class_group().then_some(true)?;
 
-        if let cluster_api_rs::capi_cluster::ClusterSpec {
-            topology:
-                Some(ClusterTopology {
-                    class_namespace: Some(class_namespace),
-                    class,
-                    ..
-                }),
-            ..
-        } = &self.spec
-        {
-            // Cluster groups creation for cluster class namespace are handled by ClusterClass controller
-            if Some(class_namespace) == self.namespace().as_ref() {
-                return None;
-            }
+        let class = self.cluster_class_name()?;
+        // Cluster groups creation for cluster class namespace are handled by ClusterClass controller
+        let class_namespace = self.cluster_class_namespace()?;
 
-            let labels = {
-                let mut labels = BTreeMap::default();
-                labels.insert(CLUSTER_CLASS_LABEL.to_string(), class.clone());
-                labels.insert(
-                    CLUSTER_CLASS_NAMESPACE_LABEL.to_string(),
-                    class_namespace.clone(),
-                );
-                Some(labels)
-            };
-
-            return Some(ClusterGroup {
-                types: Some(TypeMeta::resource::<ClusterGroup>()),
-                metadata: ObjectMeta {
-                    name: Some(format!("{class}.{class_namespace}")),
-                    namespace: self.namespace(),
-                    labels: labels.clone(),
-                    owner_references: self.owner_ref(&()).into_iter().map(Into::into).collect(),
-                    ..Default::default()
-                },
-                spec: ClusterGroupSpec {
-                    selector: Some(ClusterGroupSelector {
-                        match_labels: labels,
-                        ..Default::default()
-                    }),
-                },
-                ..Default::default()
-            });
-        }
+        let labels = {
+            let mut labels = BTreeMap::default();
+            labels.insert(CLUSTER_CLASS_LABEL.to_string(), class.to_string());
+            labels.insert(
+                CLUSTER_CLASS_NAMESPACE_LABEL.to_string(),
+                class_namespace.to_string(),
+            );
+            Some(labels)
+        };
 
-        None
+        Some(ClusterGroup {
+            types: Some(TypeMeta::resource::<ClusterGroup>()),
+            metadata: ObjectMeta {
+                name: Some(format!("{class}.{class_namespace}")),
+                namespace: self.namespace(),
+                labels: labels.clone(),
+                owner_references: self.owner_ref(&()).into_iter().map(Into::into).collect(),
+                ..Default::default()
+            },
+            spec: ClusterGroupSpec {
+                selector: Some(ClusterGroupSelector {
+                    match_labels: labels,
+                    ..Default::default()
+                }),
+            },
+            ..Default::default()
+        })
     }
 
     pub(crate) fn to_cluster(
@@ -97,23 +83,19 @@ impl Cluster {
     ) -> fleet_cluster::Cluster {
         let empty = ClusterConfig::default();
         let config = config.unwrap_or(&empty);
-        let labels = match &self.spec.topology {
-            Some(ClusterTopology {
-                class,
-                class_namespace,
-                ..
-            }) if !class.is_empty() => {
-                let mut labels = self.labels().clone();
-                labels.insert(CLUSTER_CLASS_LABEL.to_string(), class.clone());
+        let class = self.cluster_class_name();
+        let ns = self.namespace().unwrap_or_default();
+        let class_namespace = self.cluster_class_namespace().unwrap_or(&ns);
+        let labels = {
+            let mut labels = self.labels().clone();
+            if let Some(class) = class {
+                labels.insert(CLUSTER_CLASS_LABEL.to_string(), class.to_string());
                 labels.insert(
                     CLUSTER_CLASS_NAMESPACE_LABEL.to_string(),
-                    class_namespace
-                        .clone()
-                        .unwrap_or(self.namespace().unwrap_or_default()),
+                    class_namespace.to_string(),
                 );
-                labels
             }
-            None | Some(ClusterTopology { .. }) => self.labels().clone(),
+            labels
         };
 
         fleet_cluster::Cluster {
@@ -210,4 +192,12 @@ impl Cluster {
         }
         .into()
     }
+
+    pub(crate) fn cluster_class_namespace(&self) -> Option<&str> {
+        self.spec.topology.as_ref()?.class_namespace.as_deref()
+    }
+
+    pub(crate) fn cluster_class_name(&self) -> Option<&str> {
+        Some(&self.spec.topology.as_ref()?.class)
+    }
 }

src/api/fleet_addon_config.rs

@@ -269,6 +269,18 @@ pub enum Install {
     Version(String),
 }
 
+impl Install {
+    /// Perform version normalization for comparison with `helm search` app_version output
+    pub(crate) fn normalized(self) -> Self {
+        match self {
+            Install::FollowLatest(_) => self,
+            Install::Version(version) => {
+                Install::Version(version.strip_prefix("v").unwrap_or(&version).into())
+            }
+        }
+    }
+}
+
 impl Default for Install {
     fn default() -> Self {
         Self::FollowLatest(true)
@@ -314,16 +326,6 @@ pub struct Selectors {
 }
 
 impl FleetAddonConfig {
-    // Provide a static label selector for cluster objects, which can be always be set
-    // and will not cause cache events from resources in the labeled Namespace to be missed
-    pub(crate) fn cluster_watch(&self) -> Result<Selector, ParseExpressionError> {
-        Ok(self
-            .namespace_selector()?
-            .selects_all()
-            .then_some(self.cluster_selector()?)
-            .unwrap_or_default())
-    }
-
     // Raw cluster selector
     pub(crate) fn cluster_selector(&self) -> Result<Selector, ParseExpressionError> {
         self.spec

src/api/fleet_clustergroup.rs

@@ -6,6 +6,7 @@ use fleet_api_rs::fleet_clustergroup::{
 use k8s_openapi::api::core::v1::ObjectReference;
 use kube::{
     api::{ObjectMeta, TypeMeta},
+    core::{Expression, Selector},
     runtime::reflector::ObjectRef,
     Resource, ResourceExt as _,
 };
@@ -51,6 +52,13 @@ impl ClusterGroup {
                 .into(),
         )
     }
+
+    pub(crate) fn group_selector() -> Selector {
+        Selector::from_iter([
+            Expression::Exists(CLUSTER_CLASS_LABEL.to_string()),
+            Expression::Exists(CLUSTER_CLASS_NAMESPACE_LABEL.to_string()),
+        ])
+    }
 }
 
 impl From<&ClusterClass> for ClusterGroup {