Separate operator and controller names (#492)

## Description

Fixes #482



Co-authored-by: Teo Klestrup Röijezon <[email protected]>

Author: nightkr

CHANGELOG.md

@@ -7,9 +7,13 @@ All notable changes to this project will be documented in this file.
 ### Changed
 
 - BREAKING: `get_recommended_labels` and `with_recommended_labels` now takes a struct of named arguments ([#501]).
+- BREAKING: `get_recommended_labels` (and co) now takes the operator and controller names separately ([#492]).
+- BREAKING: `ClusterResources` now takes the operator and controller names separately ([#492]).
+  - When upgrading, please use FQDN-style names for the operators (`{operator}.stackable.tech`).
 - Bump opentelemetry crates ([#502]).
 - Bump clap to 4.0 ([#503]).
 
+[#492]: https://github.com/stackabletech/operator-rs/pull/492
 [#501]: https://github.com/stackabletech/operator-rs/pull/501
 [#502]: https://github.com/stackabletech/operator-rs/pull/502
 [#503]: https://github.com/stackabletech/operator-rs/pull/503

src/builder/meta.rs

@@ -324,7 +324,8 @@ mod tests {
                 owner: &pod,
                 app_name: "test_app",
                 app_version: "1.0",
-                managed_by: "app-operator",
+                operator_name: "app.stackable.tech",
+                controller_name: "appcluster",
                 role: "role",
                 role_group: "rolegroup",
             })

src/cluster_resources.rs

@@ -17,6 +17,7 @@ use crate::{
     },
     kube::{Resource, ResourceExt},
     labels::{APP_INSTANCE_LABEL, APP_MANAGED_BY_LABEL, APP_NAME_LABEL},
+    utils::format_full_controller_name,
 };
 use k8s_openapi::{
     api::{core::v1::Secret, core::v1::ServiceAccount, rbac::v1::RoleBinding},
@@ -72,7 +73,8 @@ impl ClusterResource for Secret {}
 /// use std::sync::Arc;
 ///
 /// const APP_NAME: &str = "app";
-/// const FIELD_MANAGER_SCOPE: &str = "appcluster";
+/// const OPERATOR_NAME: &str = "app.stackable.tech";
+/// const CONTROLLER_NAME: &str = "appcluster";
 ///
 /// #[derive(Clone, CustomResource, Debug, Deserialize, JsonSchema, Serialize)]
 /// #[kube(
@@ -101,7 +103,8 @@ impl ClusterResource for Secret {}
 ///
 ///     let mut cluster_resources = ClusterResources::new(
 ///         APP_NAME,
-///         FIELD_MANAGER_SCOPE,
+///         OPERATOR_NAME,
+///         CONTROLLER_NAME,
 ///         &app.object_ref(&()),
 ///     )
 ///     .map_err(|source| Error::CreateClusterResources { source })?;
@@ -166,19 +169,24 @@ impl ClusterResources {
     ///
     /// * `app_name` - The lower-case application name used in the resource labels, e.g.
     ///   "zookeeper"
-    /// * `manager` - The manager of these cluster resources, e.g.
-    ///   "zookeeper-operator_zk-controller". The added resources must contain the content of this
-    ///   field in the `app.kubernetes.io/managed-by` label. It must be different for each
-    ///   controller in the operator, otherwise resources created by another controller are detected
-    ///   as orphaned in this cluster and are deleted. This value is also used for the field manager
-    ///   scope when applying resources.
+    /// * `operator_name` - The FQDN-style name of the operator, such as ""zookeeper.stackable.tech""
+    /// * `controller_name` - The name of the lower-case name of the primary resource that
+    ///   the controller manages, such as "zookeepercluster"
     /// * `cluster` - A reference to the cluster containing the name and namespace of the cluster
     ///
+    /// The combination of (`operator_name`, `controller_name`) must be unique for each controller in the cluster,
+    /// otherwise resources created by another controller are detected as orphaned and deleted.
+    ///
     /// # Errors
     ///
     /// If `cluster` does not contain a namespace and a name then an `Error::MissingObjectKey` is
     /// returned.
-    pub fn new(app_name: &str, manager: &str, cluster: &ObjectReference) -> OperatorResult<Self> {
+    pub fn new(
+        app_name: &str,
+        operator_name: &str,
+        controller_name: &str,
+        cluster: &ObjectReference,
+    ) -> OperatorResult<Self> {
         let namespace = cluster
             .namespace
             .to_owned()
@@ -192,7 +200,7 @@ impl ClusterResources {
             namespace,
             app_instance,
             app_name: app_name.into(),
-            manager: manager.into(),
+            manager: format_full_controller_name(operator_name, controller_name),
             resource_ids: Default::default(),
         })
     }

src/labels.rs

@@ -1,3 +1,4 @@
+use crate::utils::format_full_controller_name;
 use const_format::concatcp;
 use kube::api::{Resource, ResourceExt};
 use std::collections::BTreeMap;
@@ -35,8 +36,10 @@ pub struct ObjectLabels<'a, T> {
     /// This version should include the Stackable version, such as `0.1.0-stackable0.1.0`. In the case of custom product images,
     /// the tag should be appended, such as `<productversion>-<tag>`. However, this is pure documentation and should not be parsed.
     pub app_version: &'a str,
-    /// The name of the operator and controller managing the object
-    pub managed_by: &'a str,
+    /// The DNS-style name of the operator managing the object (such as `zookeeper.stackable.tech`)
+    pub operator_name: &'a str,
+    /// The name of the controller inside of the operator managing the object (such as `zookeepercluster`)
+    pub controller_name: &'a str,
     /// The role that this object belongs to
     pub role: &'a str,
     /// The role group that this object belongs to
@@ -49,7 +52,8 @@ pub fn get_recommended_labels<T>(
         owner,
         app_name,
         app_version,
-        managed_by,
+        operator_name,
+        controller_name,
         role,
         role_group,
     }: ObjectLabels<T>,
@@ -62,7 +66,10 @@ where
     // TODO: Add operator version label
     // TODO: part-of is empty for now, decide on how this can be used in a proper fashion
     labels.insert(APP_VERSION_LABEL.to_string(), app_version.to_string());
-    labels.insert(APP_MANAGED_BY_LABEL.to_string(), managed_by.to_string());
+    labels.insert(
+        APP_MANAGED_BY_LABEL.to_string(),
+        format_full_controller_name(operator_name, controller_name),
+    );
 
     labels
 }

src/utils.rs

@@ -45,3 +45,12 @@ pub fn print_startup_string(
         pkg_version, git_information, target, rustc_version, built_time
     )
 }
+
+/// Returns the fully qualified controller name, which should be used when a single controller needs to be referred to uniquely.
+///
+/// `operator` should be a FQDN-style operator name (for example: `zookeeper.stackable.tech`).
+/// `controller` should typically be the lower-case version of the primary resource that the
+/// controller manages (for example: `zookeeperclusters`).
+pub(crate) fn format_full_controller_name(operator: &str, controller: &str) -> String {
+    format!("{operator}/{controller}")
+}