fix: remove ownerrefs

Author: maltesander

rust/operator-binary/src/controller/build/discovery.rs

@@ -4,15 +4,14 @@ use snafu::{ResultExt, Snafu};
 use stackable_operator::{
     builder::{configmap::ConfigMapBuilder, meta::ObjectMetaBuilder},
     k8s_openapi::api::core::v1::ConfigMap,
-    kube::runtime::reflector::ObjectRef,
     utils::cluster_info::KubernetesClusterInfo,
 };
 
 use crate::{
     build_recommended_labels,
     config::{CoreSiteConfigBuilder, HdfsSiteConfigBuilder},
     controller::build::properties::ConfigFileName,
-    crd::{HdfsNodeRole, HdfsPodRef, v1alpha1},
+    crd::{HdfsNodeRole, HdfsPodRef},
     hdfs_controller::{HDFS_CONTROLLER_NAME, ValidatedCluster},
     security::kerberos::KerberosConfig,
 };
@@ -22,10 +21,10 @@ type Result<T, E = Error> = std::result::Result<T, E>;
 #[derive(Snafu, Debug)]
 #[allow(clippy::enum_variant_names)]
 pub enum Error {
-    #[snafu(display("object {hdfs} is missing metadata to build owner reference"))]
+    #[snafu(display("object {name} is missing metadata to build owner reference"))]
     ObjectMissingMetadataForOwnerRef {
         source: stackable_operator::builder::meta::Error,
-        hdfs: ObjectRef<v1alpha1::HdfsCluster>,
+        name: String,
     },
 
     #[snafu(display("failed to build ConfigMap"))]
@@ -42,23 +41,22 @@ pub enum Error {
 /// Creates a discovery config map containing the `hdfs-site.xml` and `core-site.xml`
 /// for clients.
 ///
-/// The rendered content comes entirely from `cluster` (with the externally-resolved
-/// `cluster_info` and `namenode_podrefs`); `owner_ref` is retained only for the ConfigMap
-/// ObjectMeta / owner reference.
+/// The rendered content as well as the ConfigMap ObjectMeta / owner reference come
+/// entirely from `cluster` (with the externally-resolved `cluster_info` and
+/// `namenode_podrefs`).
 pub fn build_discovery_config_map(
     cluster: &ValidatedCluster,
     cluster_info: &KubernetesClusterInfo,
     namenode_podrefs: &[HdfsPodRef],
-    owner_ref: &v1alpha1::HdfsCluster,
 ) -> Result<ConfigMap> {
     let metadata = ObjectMetaBuilder::new()
-        .name_and_namespace(owner_ref)
-        .ownerreference_from_resource(owner_ref, None, Some(true))
+        .name_and_namespace(cluster)
+        .ownerreference_from_resource(cluster, None, Some(true))
         .context(ObjectMissingMetadataForOwnerRefSnafu {
-            hdfs: ObjectRef::from_obj(owner_ref),
+            name: cluster.name.to_string(),
         })?
         .with_recommended_labels(&build_recommended_labels(
-            owner_ref,
+            cluster,
             HDFS_CONTROLLER_NAME,
             &cluster.image.app_version_label_value,
             &HdfsNodeRole::Name.to_string(),

rust/operator-binary/src/controller/build/properties/mod.rs

@@ -96,6 +96,7 @@ kind: HdfsCluster
 metadata:
   name: hdfs
   namespace: default
+  uid: c2c8c5c0-0b5a-4b1e-9f3e-1a2b3c4d5e6f
 spec:
   image:
     productVersion: 3.4.0

rust/operator-binary/src/controller/validate.rs

@@ -5,15 +5,14 @@
 //! [`HdfsNodeRole::merged_config`], and the per-file `configOverrides` / `envOverrides`
 //! are merged here (role group wins).
 
-use std::{collections::BTreeMap, str::FromStr};
+use std::collections::BTreeMap;
 
-use snafu::{OptionExt, ResultExt, Snafu};
+use snafu::{ResultExt, Snafu};
 use stackable_operator::{
     commons::product_image_selection,
     config::merge::Merge,
-    kube::ResourceExt,
     role_utils::{GenericRoleConfig, JavaCommonConfig, Role, RoleGroup},
-    v2::types::{kubernetes::NamespaceName, operator::ClusterName},
+    v2::controller_utils::{get_cluster_name, get_namespace, get_uid},
 };
 use strum::IntoEnumIterator;
 
@@ -33,17 +32,19 @@ pub enum Error {
         source: product_image_selection::Error,
     },
 
-    #[snafu(display("invalid cluster name"))]
-    InvalidClusterName {
-        source: stackable_operator::v2::macros::attributed_string_type::Error,
+    #[snafu(display("failed to get the cluster name"))]
+    GetClusterName {
+        source: stackable_operator::v2::controller_utils::Error,
     },
 
-    #[snafu(display("the HdfsCluster has no namespace"))]
-    ObjectHasNoNamespace,
+    #[snafu(display("failed to get the cluster namespace"))]
+    GetClusterNamespace {
+        source: stackable_operator::v2::controller_utils::Error,
+    },
 
-    #[snafu(display("invalid cluster namespace"))]
-    InvalidNamespace {
-        source: stackable_operator::v2::macros::attributed_string_type::Error,
+    #[snafu(display("failed to get the cluster uid"))]
+    GetClusterUid {
+        source: stackable_operator::v2::controller_utils::Error,
     },
 
     #[snafu(display("failed to resolve and merge config for role and role group"))]
@@ -91,17 +92,19 @@ pub fn validate_cluster(
         role_groups.insert(hdfs_role, group_configs);
     }
 
-    let namespace = hdfs.namespace().context(ObjectHasNoNamespaceSnafu)?;
-    let namespace = NamespaceName::from_str(&namespace).context(InvalidNamespaceSnafu)?;
+    let cluster_name = get_cluster_name(hdfs).context(GetClusterNameSnafu)?;
+    let namespace = get_namespace(hdfs).context(GetClusterNamespaceSnafu)?;
+    let uid = get_uid(hdfs).context(GetClusterUidSnafu)?;
 
-    Ok(ValidatedCluster {
-        name: ClusterName::from_str(&hdfs.name_any()).context(InvalidClusterNameSnafu)?,
+    Ok(ValidatedCluster::new(
+        cluster_name,
         namespace,
-        image: resolved_product_image,
-        cluster_config: ValidatedClusterConfig::resolve(hdfs, hdfs_opa_config),
+        uid,
+        resolved_product_image,
+        ValidatedClusterConfig::resolve(hdfs, hdfs_opa_config),
         role_groups,
         role_configs,
-    })
+    ))
 }
 
 /// Validates every role group of a role into a map keyed by role group name.

rust/operator-binary/src/hdfs_controller.rs

@@ -41,7 +41,10 @@ use stackable_operator::{
         rollout::check_statefulset_rollout_complete,
     },
     utils::cluster_info::KubernetesClusterInfo,
-    v2::types::{kubernetes::NamespaceName, operator::ClusterName},
+    v2::types::{
+        kubernetes::{NamespaceName, Uid},
+        operator::ClusterName,
+    },
 };
 use strum::{EnumDiscriminants, IntoEnumIterator, IntoStaticStr};
 
@@ -74,6 +77,10 @@ pub const CONTAINER_IMAGE_BASE_NAME: &str = "hadoop";
 /// the controller.
 #[derive(Clone, Debug)]
 pub struct ValidatedCluster {
+    /// The cluster's object metadata (name, namespace and uid). Kept private and only
+    /// exposed via the [`Resource`] implementation so this type can act as the owner
+    /// when building owned objects.
+    metadata: ObjectMeta,
     /// The logical (and Kubernetes object) name of the cluster.
     pub name: ClusterName,
     /// The cluster namespace, used to build kerberos principals.
@@ -85,6 +92,33 @@ pub struct ValidatedCluster {
 }
 
 impl ValidatedCluster {
+    pub fn new(
+        name: ClusterName,
+        namespace: NamespaceName,
+        uid: Uid,
+        image: ResolvedProductImage,
+        cluster_config: ValidatedClusterConfig,
+        role_groups: BTreeMap<HdfsNodeRole, BTreeMap<String, ValidatedRoleGroupConfig>>,
+        role_configs: BTreeMap<HdfsNodeRole, ValidatedRoleConfig>,
+    ) -> Self {
+        Self {
+            metadata: ObjectMeta {
+                name: Some(name.to_string()),
+                namespace: Some(namespace.to_string()),
+                // The uid is required so this type can produce valid owner references
+                // (Kubernetes rejects owner references without a uid).
+                uid: Some(uid.to_string()),
+                ..ObjectMeta::default()
+            },
+            name,
+            namespace,
+            image,
+            cluster_config,
+            role_groups,
+            role_configs,
+        }
+    }
+
     /// Builds the [`HdfsPodRef`]s expected for every pod of the given `role`, across
     /// all of its role groups.
     ///
@@ -119,6 +153,39 @@ impl ValidatedCluster {
     }
 }
 
+/// Lets [`ValidatedCluster`] be used as the owner [`Resource`] (e.g. in
+/// [`ObjectMetaBuilder::ownerreference_from_resource`]). The kind/group/version/plural
+/// are delegated to [`v1alpha1::HdfsCluster`] so the generated owner references are
+/// identical to the ones built from the raw cluster object.
+impl Resource for ValidatedCluster {
+    type DynamicType = <v1alpha1::HdfsCluster as Resource>::DynamicType;
+    type Scope = <v1alpha1::HdfsCluster as Resource>::Scope;
+
+    fn kind(dt: &Self::DynamicType) -> std::borrow::Cow<'_, str> {
+        v1alpha1::HdfsCluster::kind(dt)
+    }
+
+    fn group(dt: &Self::DynamicType) -> std::borrow::Cow<'_, str> {
+        v1alpha1::HdfsCluster::group(dt)
+    }
+
+    fn version(dt: &Self::DynamicType) -> std::borrow::Cow<'_, str> {
+        v1alpha1::HdfsCluster::version(dt)
+    }
+
+    fn plural(dt: &Self::DynamicType) -> std::borrow::Cow<'_, str> {
+        v1alpha1::HdfsCluster::plural(dt)
+    }
+
+    fn meta(&self) -> &ObjectMeta {
+        &self.metadata
+    }
+
+    fn meta_mut(&mut self) -> &mut ObjectMeta {
+        &mut self.metadata
+    }
+}
+
 /// Cluster-wide settings resolved once during validation, so the build steps no
 /// longer need the raw `HdfsCluster` to render config.
 #[derive(Clone, Debug)]
@@ -415,14 +482,14 @@ pub async fn reconcile_hdfs(
             // to avoid the compiler error "E0716 (temporary value dropped while borrowed)".
             let mut metadata = ObjectMetaBuilder::new();
             let metadata = metadata
-                .name_and_namespace(hdfs)
+                .name_and_namespace(&validated_cluster)
                 .name(rolegroup_ref.object_name())
-                .ownerreference_from_resource(hdfs, None, Some(true))
+                .ownerreference_from_resource(&validated_cluster, None, Some(true))
                 .with_context(|_| ObjectMissingMetadataForOwnerRefSnafu {
                     obj_ref: ObjectRef::from_obj(hdfs),
                 })?
                 .with_recommended_labels(&build_recommended_labels(
-                    hdfs,
+                    &validated_cluster,
                     RESOURCE_MANAGER_HDFS_CONTROLLER,
                     &resolved_product_image.app_version_label_value,
                     &rolegroup_ref.role,
@@ -523,7 +590,6 @@ pub async fn reconcile_hdfs(
             .namenode_listener_refs(client)
             .await
             .context(CollectDiscoveryConfigSnafu)?,
-        hdfs,
     )
     .context(BuildDiscoveryConfigMapSnafu)?;
 
@@ -714,6 +780,7 @@ kind: HdfsCluster
 metadata:
   name: hdfs
   namespace: default
+  uid: c2c8c5c0-0b5a-4b1e-9f3e-1a2b3c4d5e6f
 spec:
   image:
     productVersion: 3.4.0