refactor: switch to v2 types, ResourceNAmes, RoleGroupName, reduce RoleGroupRef, cleanup

Author: maltesander

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

@@ -6,59 +6,52 @@ use stackable_operator::{
     builder::{configmap::ConfigMapBuilder, meta::ObjectMetaBuilder},
     k8s_openapi::api::core::v1::ConfigMap,
     product_logging::framework::VECTOR_CONFIG_FILE,
-    role_utils::RoleGroupRef,
     v2::builder::meta::ownerreference_from_resource,
 };
 
-use super::properties::{ConfigFileName, config_json, logging, user_info_fetcher};
-use crate::{
-    controller::{OpaRoleGroupConfig, ValidatedCluster},
-    crd::v1alpha2,
-    opa_controller::build_recommended_labels,
-};
+use super::properties::{ConfigFileName, config_json, user_info_fetcher};
+use crate::controller::{OpaRoleGroupConfig, RoleGroupName, ValidatedCluster};
 
 #[derive(Snafu, Debug)]
 pub enum Error {
-    #[snafu(display("failed to build object meta data"))]
-    ObjectMeta {
-        source: stackable_operator::builder::meta::Error,
-    },
-
     #[snafu(display("failed to build config.json"))]
     BuildConfigJson { source: config_json::Error },
 
     #[snafu(display("failed to build user-info-fetcher.json"))]
     BuildUserInfoFetcher { source: user_info_fetcher::Error },
 
-    #[snafu(display("failed to build ConfigMap for [{rolegroup}]"))]
-    BuildConfigMap {
+    #[snafu(display("failed to assemble ConfigMap for role group {role_group}"))]
+    Assemble {
         source: stackable_operator::builder::configmap::Error,
-        rolegroup: RoleGroupRef<v1alpha2::OpaCluster>,
+        role_group: RoleGroupName,
     },
 }
 
 type Result<T, E = Error> = std::result::Result<T, E>;
 
 /// The rolegroup [`ConfigMap`] configures the rolegroup based on the configuration given by the
 /// administrator.
+///
+/// `vector_config` is the Vector agent config (`vector.yaml`) built by the caller (where a
+/// `RoleGroupRef` is available); it is `None` when the Vector agent is disabled.
 pub fn build_rolegroup_config_map(
     cluster: &ValidatedCluster,
+    role_group_name: &RoleGroupName,
     rolegroup_config: &OpaRoleGroupConfig,
-    rolegroup_ref: &RoleGroupRef<v1alpha2::OpaCluster>,
+    vector_config: Option<String>,
 ) -> Result<ConfigMap> {
     let mut cm_builder = ConfigMapBuilder::new();
 
     let metadata = ObjectMetaBuilder::new()
-        .name(rolegroup_ref.object_name())
-        .namespace(&cluster.namespace)
+        .name_and_namespace(cluster)
+        .name(
+            cluster
+                .resource_names(role_group_name)
+                .role_group_config_map()
+                .to_string(),
+        )
         .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-        .with_recommended_labels(&build_recommended_labels(
-            cluster,
-            &cluster.image.app_version_label_value,
-            &rolegroup_ref.role,
-            &rolegroup_ref.role_group,
-        ))
-        .context(ObjectMetaSnafu)?
+        .with_labels(cluster.recommended_labels(role_group_name))
         .build();
 
     cm_builder.metadata(metadata).add_data(
@@ -74,21 +67,18 @@ pub fn build_rolegroup_config_map(
         );
     }
 
-    if let Some(vector_config) =
-        logging::build_vector_config(rolegroup_ref, &rolegroup_config.config.logging)
-    {
+    if let Some(vector_config) = vector_config {
         cm_builder.add_data(VECTOR_CONFIG_FILE, vector_config);
     }
 
-    cm_builder.build().with_context(|_| BuildConfigMapSnafu {
-        rolegroup: rolegroup_ref.clone(),
+    cm_builder.build().with_context(|_| AssembleSnafu {
+        role_group: role_group_name.clone(),
     })
 }
 
 #[cfg(test)]
 mod tests {
     use serde_json::{Value, json};
-    use stackable_operator::kube::runtime::reflector::ObjectRef;
 
     use super::*;
     use crate::{
@@ -97,20 +87,15 @@ mod tests {
 
     /// Renders the ConfigMap of the `default` server role group of an `OpaCluster` built from `spec`.
     fn build_config_map(spec: Value) -> ConfigMap {
-        let (opa, validated) = validated_cluster_from_spec(spec);
+        let (_opa, validated) = validated_cluster_from_spec(spec);
 
         let role = OpaRole::Server;
-        let rg_config = validated.role_group_configs[&role]
-            .values()
+        let (role_group_name, rg_config) = validated.role_group_configs[&role]
+            .iter()
             .next()
             .expect("the default role group should exist");
-        let rolegroup_ref = RoleGroupRef {
-            cluster: ObjectRef::from_obj(&opa),
-            role: role.to_string(),
-            role_group: "default".to_string(),
-        };
 
-        build_rolegroup_config_map(&validated, rg_config, &rolegroup_ref)
+        build_rolegroup_config_map(&validated, role_group_name, rg_config, None)
             .expect("the config map should build")
     }
 

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

@@ -3,6 +3,8 @@
 //! The content comes entirely from the [`ValidatedCluster`] (plus the externally-resolved role
 //! service and `cluster_info`).
 
+use std::str::FromStr;
+
 use snafu::{ResultExt, Snafu};
 use stackable_operator::{
     builder::{configmap::ConfigMapBuilder, meta::ObjectMetaBuilder},
@@ -12,9 +14,7 @@ use stackable_operator::{
 };
 
 use crate::{
-    controller::ValidatedCluster,
-    crd::OpaRole,
-    opa_controller::build_recommended_labels,
+    controller::{RoleGroupName, ValidatedCluster},
     service::{APP_PORT, APP_TLS_PORT},
 };
 
@@ -24,11 +24,6 @@ pub enum Error {
     BuildConfigMap {
         source: stackable_operator::builder::configmap::Error,
     },
-
-    #[snafu(display("failed to build object meta data"))]
-    ObjectMeta {
-        source: stackable_operator::builder::meta::Error,
-    },
 }
 
 type Result<T, E = Error> = std::result::Result<T, E>;
@@ -52,17 +47,14 @@ pub fn build_discovery_config_map(
         cluster_domain = cluster_info.cluster_domain,
     );
 
+    // Discovery is a cluster-level object (named after the cluster); `discovery` is used as a
+    // placeholder role-group name for the recommended labels.
     let metadata = ObjectMetaBuilder::new()
-        .name(cluster.name.to_string())
-        .namespace(&cluster.namespace)
+        .name_and_namespace(cluster)
         .ownerreference(ownerreference_from_resource(cluster, None, Some(true)))
-        .with_recommended_labels(&build_recommended_labels(
-            cluster,
-            &cluster.image.app_version_label_value,
-            &OpaRole::Server.to_string(),
-            "discovery",
+        .with_labels(cluster.recommended_labels(
+            &RoleGroupName::from_str("discovery").expect("'discovery' is a valid role group name"),
         ))
-        .context(ObjectMetaSnafu)?
         .build();
 
     let mut cm_builder = ConfigMapBuilder::new();

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

@@ -1,22 +1,35 @@
 //! Controller-level vocabulary: the [`ValidatedCluster`] type and the `build` / `validate`
 //! sub-modules.
 
-use std::collections::BTreeMap;
+use std::{collections::BTreeMap, str::FromStr};
 
+// Re-exported so the rest of the controller refers to `crate::controller::RoleGroupName`.
+pub use stackable_operator::v2::types::operator::RoleGroupName;
 use stackable_operator::{
     commons::product_image_selection::ResolvedProductImage,
     kube::{Resource as KubeResource, api::ObjectMeta},
+    kvp::Labels,
     v2::{
         HasName, HasUid, NameIsValidLabelValue,
+        kvp::label::{recommended_labels, role_group_selector, role_selector},
+        role_group_utils::ResourceNames,
         role_utils::{GenericCommonConfig, RoleGroupConfig},
         types::{
             kubernetes::{NamespaceName, Uid},
-            operator::{ClusterName, RoleGroupName},
+            operator::{
+                ClusterName, ControllerName, OperatorName, ProductName, ProductVersion, RoleName,
+            },
         },
     },
 };
 
-use crate::crd::{OpaConfig, OpaConfigOverrides, OpaRole, user_info_fetcher, v1alpha2};
+use crate::{
+    crd::{
+        APP_NAME, OPERATOR_NAME, OpaConfig, OpaConfigOverrides, OpaRole, user_info_fetcher,
+        v1alpha2,
+    },
+    opa_controller::OPA_CONTROLLER_NAME,
+};
 
 pub mod build;
 pub mod validate;
@@ -69,6 +82,72 @@ impl ValidatedCluster {
     pub fn server_role_service_name(&self) -> String {
         format!("{name}-{role}", name = self.name, role = OpaRole::Server)
     }
+
+    /// The single OPA role name (`server`).
+    pub fn role_name() -> RoleName {
+        RoleName::from_str(&OpaRole::Server.to_string())
+            .expect("the server role name is a valid role name")
+    }
+
+    /// Type-safe names for the resources of a given role group.
+    pub(crate) fn resource_names(&self, role_group_name: &RoleGroupName) -> ResourceNames {
+        ResourceNames {
+            cluster_name: self.name.clone(),
+            role_name: Self::role_name(),
+            role_group_name: role_group_name.clone(),
+        }
+    }
+
+    /// The product version as a type-safe label value.
+    ///
+    /// `app_version_label_value` is constructed to be a valid label value, so it is also a valid
+    /// [`ProductVersion`].
+    fn product_version(&self) -> ProductVersion {
+        ProductVersion::from_str(&self.image.app_version_label_value)
+            .expect("the app version label value is a valid product version")
+    }
+
+    /// Recommended labels for a role-group resource.
+    ///
+    /// For role-level or cluster-level resources (e.g. the role `Service` or the discovery
+    /// `ConfigMap`) pass a placeholder role-group name such as `global` or `discovery`.
+    pub fn recommended_labels(&self, role_group_name: &RoleGroupName) -> Labels {
+        recommended_labels(
+            self,
+            &product_name(),
+            &self.product_version(),
+            &operator_name(),
+            &controller_name(),
+            &Self::role_name(),
+            role_group_name,
+        )
+    }
+
+    /// Selector labels matching the pods of a role group.
+    pub fn role_group_selector(&self, role_group_name: &RoleGroupName) -> Labels {
+        role_group_selector(self, &product_name(), &Self::role_name(), role_group_name)
+    }
+
+    /// Selector labels matching all pods of the (single) OPA role.
+    pub fn role_selector(&self) -> Labels {
+        role_selector(self, &product_name(), &Self::role_name())
+    }
+}
+
+/// The product name (`opa`) as a type-safe label value.
+fn product_name() -> ProductName {
+    ProductName::from_str(APP_NAME).expect("'opa' is a valid product name")
+}
+
+/// The operator name as a type-safe label value.
+fn operator_name() -> OperatorName {
+    OperatorName::from_str(OPERATOR_NAME).expect("the operator name is a valid label value")
+}
+
+/// The controller name as a type-safe label value.
+fn controller_name() -> ControllerName {
+    ControllerName::from_str(OPA_CONTROLLER_NAME)
+        .expect("the controller name is a valid label value")
 }
 
 impl HasName for ValidatedCluster {

rust/operator-binary/src/crd/mod.rs

@@ -1,7 +1,4 @@
-use std::str::FromStr;
-
 use serde::{Deserialize, Serialize};
-use snafu::{OptionExt, ResultExt, Snafu};
 use stackable_operator::{
     commons::{
         affinity::StackableAffinity,
@@ -15,9 +12,9 @@ use stackable_operator::{
     config::{fragment::Fragment, merge::Merge},
     deep_merger::ObjectOverrides,
     k8s_openapi::apimachinery::pkg::api::resource::Quantity,
-    kube::{CustomResource, ResourceExt},
+    kube::{CustomResource, runtime::reflector::ObjectRef},
     product_logging::{self, spec::Logging},
-    role_utils::{EmptyRoleConfig, Role, RoleGroup, RoleGroupRef},
+    role_utils::{EmptyRoleConfig, Role, RoleGroupRef},
     schemars::{self, JsonSchema},
     shared::time::Duration,
     status::condition::{ClusterCondition, HasStatusCondition},
@@ -41,20 +38,6 @@ pub const SERVER_GRACEFUL_SHUTDOWN_SAFETY_OVERHEAD: Duration = Duration::from_se
 pub type OpaRoleType =
     Role<OpaConfigFragment, OpaConfigOverrides, EmptyRoleConfig, GenericCommonConfig>;
 
-pub type OpaRoleGroupType = RoleGroup<OpaConfigFragment, GenericCommonConfig, OpaConfigOverrides>;
-
-#[derive(Snafu, Debug)]
-pub enum Error {
-    #[snafu(display("the role group {role_group} is not defined"))]
-    CannotRetrieveOpaRoleGroup { role_group: String },
-
-    #[snafu(display("unknown role {role}"))]
-    UnknownOpaRole {
-        source: strum::ParseError,
-        role: String,
-    },
-}
-
 #[versioned(
     version(name = "v1alpha1"),
     version(name = "v1alpha2"),
@@ -323,30 +306,18 @@ impl v1alpha2::OpaCluster {
         }
     }
 
-    /// Returns a reference to the role group. Raises an error if the role or role group are not defined.
-    pub fn rolegroup(
-        &self,
-        rolegroup_ref: &RoleGroupRef<v1alpha2::OpaCluster>,
-    ) -> Result<&OpaRoleGroupType, Error> {
-        let role_variant =
-            OpaRole::from_str(&rolegroup_ref.role).with_context(|_| UnknownOpaRoleSnafu {
-                role: rolegroup_ref.role.to_owned(),
-            })?;
-        let role = self.role(&role_variant);
-        role.role_groups
-            .get(&rolegroup_ref.role_group)
-            .with_context(|| CannotRetrieveOpaRoleGroupSnafu {
-                role_group: rolegroup_ref.role_group.to_owned(),
-            })
-    }
-
-    /// The name of the role-level load-balanced Kubernetes `Service`
-    pub fn server_role_service_name(&self) -> String {
-        format!(
-            "{cluster_name}-{role}",
-            cluster_name = self.name_any(),
-            role = OpaRole::Server
-        )
+    /// A [`RoleGroupRef`] for the given server role group.
+    ///
+    /// This is only needed to build the Vector agent config via the upstream
+    /// [`create_vector_config`](stackable_operator::product_logging::framework::create_vector_config),
+    /// which still requires a `RoleGroupRef`. All other resource naming goes through
+    /// [`ValidatedCluster`](crate::controller::ValidatedCluster) and the v2 `ResourceNames`.
+    pub fn server_rolegroup_ref(&self, group_name: impl Into<String>) -> RoleGroupRef<Self> {
+        RoleGroupRef {
+            cluster: ObjectRef::from_obj(self),
+            role: OpaRole::Server.to_string(),
+            role_group: group_name.into(),
+        }
     }
 }