From 30191c8f64a39694ea1314bde3191374528badf3 Mon Sep 17 00:00:00 2001
From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com>
Date: Tue, 14 Mar 2023 15:02:06 +0100
Subject: [PATCH 01/36] added status mod

---
 src/cluster_resources.rs | 74 +++++++++++++++++++++++++++++++---------
 src/lib.rs               |  1 +
 src/status/mod.rs        | 63 ++++++++++++++++++++++++++++++++++
 3 files changed, 122 insertions(+), 16 deletions(-)
 create mode 100644 src/status/mod.rs

diff --git a/src/cluster_resources.rs b/src/cluster_resources.rs
index e129299c7..e8b6874a7 100644
--- a/src/cluster_resources.rs
+++ b/src/cluster_resources.rs
@@ -5,6 +5,19 @@ use std::{
     fmt::Debug,
 };
 
+use k8s_openapi::{
+    api::{
+        apps::v1::{DaemonSetStatus, Deployment, DeploymentStatus, StatefulSetStatus},
+        core::v1::Secret,
+        core::v1::{Pod, PodStatus, ServiceAccount},
+        rbac::v1::RoleBinding,
+    },
+    NamespaceResourceScope,
+};
+use kube::core::ErrorResponse;
+use serde::{de::DeserializeOwned, Serialize};
+use tracing::{debug, info};
+
 use crate::{
     client::{Client, GetApi},
     error::{Error, OperatorResult},
@@ -19,13 +32,6 @@ use crate::{
     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},
-    NamespaceResourceScope,
-};
-use kube::core::ErrorResponse;
-use serde::{de::DeserializeOwned, Serialize};
-use tracing::{debug, info};
 
 /// A cluster resource handled by [`ClusterResources`].
 ///
@@ -44,11 +50,17 @@ pub trait ClusterResource:
 }
 
 impl ClusterResource for ConfigMap {}
+
 impl ClusterResource for DaemonSet {}
+
 impl ClusterResource for Service {}
+
 impl ClusterResource for StatefulSet {}
+
 impl ClusterResource for ServiceAccount {}
+
 impl ClusterResource for RoleBinding {}
+
 impl ClusterResource for Secret {}
 
 /// A structure containing the cluster resources.
@@ -96,7 +108,7 @@ impl ClusterResource for Secret {}
 ///     DeleteOrphanedClusterResources {
 ///         source: stackable_operator::error::Error,
 ///     },
-/// };
+/// }
 ///
 /// async fn reconcile(app: Arc<AppCluster>, client: Arc<Client>) -> Result<Action, Error> {
 ///     let validated_config = ValidatedRoleConfigByPropertyKind::default();
@@ -397,7 +409,35 @@ impl ClusterResources {
         &self,
         client: &Client,
     ) -> OperatorResult<Vec<T>> {
-        let label_selector = LabelSelector {
+        let label_selector = self.label_selector();
+
+        let resources = client
+            .list_with_label_selector::<T>(&self.namespace, &label_selector)
+            .await?;
+
+        Ok(resources)
+    }
+
+    pub async fn resources_status(self, client: &Client) -> OperatorResult<ClusterResourcesStatus> {
+        let label_selector = self.label_selector();
+
+        let (dset, sts, deps, pods) = tokio::try_join!(
+            client.list_with_label_selector::<DaemonSet>(&self.namespace, &label_selector),
+            client.list_with_label_selector::<StatefulSet>(&self.namespace, &label_selector),
+            client.list_with_label_selector::<Deployment>(&self.namespace, &label_selector),
+            client.list_with_label_selector::<Pod>(&self.namespace, &label_selector)
+        )?;
+
+        Ok(ClusterResourcesStatus {
+            stateful_set_status: sts.iter().filter_map(|sts| sts.status.clone()).collect(),
+            daemon_set_status: dset.iter().filter_map(|sts| sts.status.clone()).collect(),
+            deployment_status: deps.iter().filter_map(|sts| sts.status.clone()).collect(),
+            pod_status: pods.iter().filter_map(|sts| sts.status.clone()).collect(),
+        })
+    }
+
+    fn label_selector(&self) -> LabelSelector {
+        LabelSelector {
             match_expressions: Some(vec![
                 LabelSelectorRequirement {
                     key: APP_INSTANCE_LABEL.into(),
@@ -416,12 +456,14 @@ impl ClusterResources {
                 },
             ]),
             ..Default::default()
-        };
-
-        let resources = client
-            .list_with_label_selector::<T>(&self.namespace, &label_selector)
-            .await?;
-
-        Ok(resources)
+        }
     }
 }
+
+#[derive(Default, PartialEq)]
+pub struct ClusterResourcesStatus {
+    stateful_set_status: Vec<StatefulSetStatus>,
+    daemon_set_status: Vec<DaemonSetStatus>,
+    deployment_status: Vec<DeploymentStatus>,
+    pod_status: Vec<PodStatus>,
+}
diff --git a/src/lib.rs b/src/lib.rs
index d7ad9e6af..73b26be83 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -17,6 +17,7 @@ pub mod pod_utils;
 pub mod product_config_utils;
 pub mod product_logging;
 pub mod role_utils;
+pub mod status;
 pub mod utils;
 pub mod validation;
 pub mod yaml;
diff --git a/src/status/mod.rs b/src/status/mod.rs
new file mode 100644
index 000000000..2b86ebaf5
--- /dev/null
+++ b/src/status/mod.rs
@@ -0,0 +1,63 @@
+use k8s_openapi::apimachinery::pkg::apis::meta::v1::Time;
+
+use crate::cluster_resources::ClusterResourcesStatus;
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+#[derive(
+    strum::Display, Clone, Debug, Default, Deserialize, Eq, JsonSchema, PartialEq, Serialize,
+)]
+#[serde(rename_all = "camelCase")]
+pub enum ClusterConditionType {
+    #[default]
+    Available,
+    Degraded,
+    Progressing,
+    Paused,
+    Stopped,
+}
+
+#[derive(
+    strum::Display, Clone, Debug, Default, Deserialize, Eq, JsonSchema, PartialEq, Serialize,
+)]
+#[serde(rename_all = "camelCase")]
+pub enum ClusterConditionStatus {
+    #[default]
+    True,
+    False,
+    Unknown,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct ClusterCondition {
+    /// Last time the condition transitioned from one status to another.
+    pub last_transition_time: Option<Time>,
+
+    /// The last time this condition was updated.
+    pub last_update_time: Option<Time>,
+
+    /// A human readable message indicating details about the transition.
+    pub message: Option<String>,
+
+    /// The reason for the condition's last transition.
+    pub reason: Option<String>,
+
+    /// Status of the condition, one of True, False, Unknown.
+    pub status: ClusterConditionStatus,
+
+    /// Type of deployment condition.
+    pub type_: ClusterConditionType,
+}
+
+pub trait StatusBuilder {
+    fn conditions(crs: &ClusterResourcesStatus) -> Vec<ClusterCondition>;
+}
+
+struct ADR27StatusBuilder {}
+
+impl StatusBuilder for ADR27StatusBuilder {
+    fn conditions(crs: &ClusterResourcesStatus) -> Vec<ClusterCondition> {
+        vec![]
+    }
+}

From c0c36c9b08d5c3369cf2dac27cf80be58dab234f Mon Sep 17 00:00:00 2001
From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com>
Date: Wed, 15 Mar 2023 15:59:17 +0100
Subject: [PATCH 02/36] wip

---
 src/cluster_resources.rs | 48 ++++++++++-----------
 src/status/mod.rs        | 92 ++++++++++++++++++++++++++++++++++++----
 2 files changed, 108 insertions(+), 32 deletions(-)

diff --git a/src/cluster_resources.rs b/src/cluster_resources.rs
index e8b6874a7..a63d571b6 100644
--- a/src/cluster_resources.rs
+++ b/src/cluster_resources.rs
@@ -14,7 +14,10 @@ use k8s_openapi::{
     },
     NamespaceResourceScope,
 };
-use kube::core::ErrorResponse;
+use kube::{
+    config::Cluster,
+    core::{object::HasStatus, ErrorResponse},
+};
 use serde::{de::DeserializeOwned, Serialize};
 use tracing::{debug, info};
 
@@ -63,6 +66,7 @@ impl ClusterResource for RoleBinding {}
 
 impl ClusterResource for Secret {}
 
+impl ClusterResource for Deployment {}
 /// A structure containing the cluster resources.
 ///
 /// Cluster resources can be added and orphaned resources are deleted. A cluster resource becomes
@@ -258,6 +262,10 @@ impl ClusterResources {
         Ok(patched_resource)
     }
 
+    pub async fn add<T: HasStatus>(&mut self, client: &Client, resource: &T) -> OperatorResult<T> {
+        self.add::<ClusterResource>(client, resource)
+    }
+
     /// Checks that the given `labels` contain the given `label` with the given `expected_content`.
     ///
     /// # Arguments
@@ -418,23 +426,23 @@ impl ClusterResources {
         Ok(resources)
     }
 
-    pub async fn resources_status(self, client: &Client) -> OperatorResult<ClusterResourcesStatus> {
-        let label_selector = self.label_selector();
+    // pub async fn resources_status(self, client: &Client) -> OperatorResult<ClusterResourcesStatus> {
+    //     let label_selector = self.label_selector();
 
-        let (dset, sts, deps, pods) = tokio::try_join!(
-            client.list_with_label_selector::<DaemonSet>(&self.namespace, &label_selector),
-            client.list_with_label_selector::<StatefulSet>(&self.namespace, &label_selector),
-            client.list_with_label_selector::<Deployment>(&self.namespace, &label_selector),
-            client.list_with_label_selector::<Pod>(&self.namespace, &label_selector)
-        )?;
+    //     let (dset, sts, deps, pods) = tokio::try_join!(
+    //         client.list_with_label_selector::<DaemonSet>(&self.namespace, &label_selector),
+    //         client.list_with_label_selector::<StatefulSet>(&self.namespace, &label_selector),
+    //         client.list_with_label_selector::<Deployment>(&self.namespace, &label_selector),
+    //         client.list_with_label_selector::<Pod>(&self.namespace, &label_selector)
+    //     )?;
 
-        Ok(ClusterResourcesStatus {
-            stateful_set_status: sts.iter().filter_map(|sts| sts.status.clone()).collect(),
-            daemon_set_status: dset.iter().filter_map(|sts| sts.status.clone()).collect(),
-            deployment_status: deps.iter().filter_map(|sts| sts.status.clone()).collect(),
-            pod_status: pods.iter().filter_map(|sts| sts.status.clone()).collect(),
-        })
-    }
+    //     Ok(ClusterResourcesStatus {
+    //         stateful_set_status: sts.iter().filter_map(|sts| sts.status.clone()).collect(),
+    //         daemon_set_status: dset.iter().filter_map(|sts| sts.status.clone()).collect(),
+    //         deployment_status: deps.iter().filter_map(|sts| sts.status.clone()).collect(),
+    //         pod_status: pods.iter().filter_map(|sts| sts.status.clone()).collect(),
+    //     })
+    // }
 
     fn label_selector(&self) -> LabelSelector {
         LabelSelector {
@@ -459,11 +467,3 @@ impl ClusterResources {
         }
     }
 }
-
-#[derive(Default, PartialEq)]
-pub struct ClusterResourcesStatus {
-    stateful_set_status: Vec<StatefulSetStatus>,
-    daemon_set_status: Vec<DaemonSetStatus>,
-    deployment_status: Vec<DeploymentStatus>,
-    pod_status: Vec<PodStatus>,
-}
diff --git a/src/status/mod.rs b/src/status/mod.rs
index 2b86ebaf5..695332a06 100644
--- a/src/status/mod.rs
+++ b/src/status/mod.rs
@@ -1,12 +1,24 @@
-use k8s_openapi::apimachinery::pkg::apis::meta::v1::Time;
+use std::collections::HashMap;
 
-use crate::cluster_resources::ClusterResourcesStatus;
+use k8s_openapi::{
+    api::apps::v1::{DaemonSet, Deployment, StatefulSet},
+    apimachinery::pkg::apis::meta::v1::Time,
+    Resource,
+};
+
+use crate::cluster_resources::ClusterResource;
 
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
+pub trait HasStatus: ClusterResource {}
+
+impl HasStatus for StatefulSet {}
+impl HasStatus for Deployment {}
+impl HasStatus for DaemonSet {}
+
 #[derive(
-    strum::Display, Clone, Debug, Default, Deserialize, Eq, JsonSchema, PartialEq, Serialize,
+    strum::Display, Clone, Debug, Default, Deserialize, Eq, Hash, JsonSchema, PartialEq, Serialize,
 )]
 #[serde(rename_all = "camelCase")]
 pub enum ClusterConditionType {
@@ -29,6 +41,23 @@ pub enum ClusterConditionStatus {
     Unknown,
 }
 
+impl From<bool> for ClusterConditionStatus {
+    fn from(b: bool) -> ClusterConditionStatus {
+        if b {
+            ClusterConditionStatus::True
+        } else {
+            ClusterConditionStatus::False
+        }
+    }
+}
+#[derive(Default, PartialEq)]
+pub struct ClusterResourcesStatus {
+    pub stateful_set_status: Vec<StatefulSetStatus>,
+    pub daemon_set_status: Vec<DaemonSetStatus>,
+    pub deployment_status: Vec<DeploymentStatus>,
+    pub pod_status: Vec<PodStatus>,
+}
+
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct ClusterCondition {
     /// Last time the condition transitioned from one status to another.
@@ -50,14 +79,61 @@ pub struct ClusterCondition {
     pub type_: ClusterConditionType,
 }
 
-pub trait StatusBuilder {
-    fn conditions(crs: &ClusterResourcesStatus) -> Vec<ClusterCondition>;
+impl ClusterCondition {
+    pub fn new_with(type_: ClusterConditionType, status: ClusterConditionStatus) -> Self {
+        ClusterCondition {
+            type_,
+            status,
+            ..ClusterCondition::default()
+        }
+    }
+}
+pub trait StatusBuilder<T: Resource> {
+    fn conditions(resource: &T, crs: &ClusterResourcesStatus) -> Vec<ClusterCondition>;
 }
 
 struct ADR27StatusBuilder {}
 
-impl StatusBuilder for ADR27StatusBuilder {
-    fn conditions(crs: &ClusterResourcesStatus) -> Vec<ClusterCondition> {
-        vec![]
+impl<T: Resource> StatusBuilder<T> for ADR27StatusBuilder {
+    fn conditions(_resource: &T, crs: &ClusterResourcesStatus) -> Vec<ClusterCondition> {
+        let mut result: HashMap<ClusterConditionType, ClusterConditionStatus> = HashMap::new();
+
+        let (sts_replicas, sts_available_replicas) = crs
+            .stateful_set_status
+            .iter()
+            .map(|s| (s.replicas, s.available_replicas.unwrap_or_default()))
+            .reduce(|(mut tr, mut tar), (r, ar)| {
+                tr += r;
+                tar += ar;
+                (tr, tar)
+            })
+            .unwrap_or((0, 0));
+
+        let (deploy_replicas, deploy_available_replicas) = crs
+            .deployment_status
+            .iter()
+            .map(|s| {
+                (
+                    s.replicas.unwrap_or_default(),
+                    s.available_replicas.unwrap_or_default(),
+                )
+            })
+            .reduce(|(mut tr, mut tar), (r, ar)| {
+                tr += r;
+                tar += ar;
+                (tr, tar)
+            })
+            .unwrap_or((0, 0));
+
+        result.insert(
+            ClusterConditionType::Available,
+            (sts_replicas + deploy_replicas == sts_available_replicas + deploy_available_replicas)
+                .into(),
+        );
+
+        result
+            .into_iter()
+            .map(|(type_, status)| ClusterCondition::new_with(type_, status))
+            .collect()
     }
 }

From 5a80e166f276349b279bb95249cbf9b20c99a26d Mon Sep 17 00:00:00 2001
From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com>
Date: Mon, 20 Mar 2023 13:16:07 +0100
Subject: [PATCH 03/36] wip

---
 src/cluster_resources.rs |  43 +++-------
 src/status/mod.rs        | 169 +++++++++++++++++++++++++++++++++------
 2 files changed, 156 insertions(+), 56 deletions(-)

diff --git a/src/cluster_resources.rs b/src/cluster_resources.rs
index a63d571b6..6c68ba576 100644
--- a/src/cluster_resources.rs
+++ b/src/cluster_resources.rs
@@ -7,17 +7,11 @@ use std::{
 
 use k8s_openapi::{
     api::{
-        apps::v1::{DaemonSetStatus, Deployment, DeploymentStatus, StatefulSetStatus},
-        core::v1::Secret,
-        core::v1::{Pod, PodStatus, ServiceAccount},
-        rbac::v1::RoleBinding,
+        apps::v1::Deployment, core::v1::Secret, core::v1::ServiceAccount, rbac::v1::RoleBinding,
     },
     NamespaceResourceScope,
 };
-use kube::{
-    config::Cluster,
-    core::{object::HasStatus, ErrorResponse},
-};
+use kube::core::ErrorResponse;
 use serde::{de::DeserializeOwned, Serialize};
 use tracing::{debug, info};
 
@@ -33,6 +27,7 @@ use crate::{
     },
     kube::{Resource, ResourceExt},
     labels::{APP_INSTANCE_LABEL, APP_MANAGED_BY_LABEL, APP_NAME_LABEL},
+    status::{self, ClusterResourcesStatus},
     utils::format_full_controller_name,
 };
 
@@ -49,6 +44,7 @@ pub trait ClusterResource:
     + Resource<DynamicType = (), Scope = NamespaceResourceScope>
     + GetApi<Namespace = str>
     + Serialize
+    + HasStatus
 {
 }
 
@@ -67,6 +63,7 @@ impl ClusterResource for RoleBinding {}
 impl ClusterResource for Secret {}
 
 impl ClusterResource for Deployment {}
+
 /// A structure containing the cluster resources.
 ///
 /// Cluster resources can be added and orphaned resources are deleted. A cluster resource becomes
@@ -125,6 +122,7 @@ impl ClusterResource for Deployment {}
 ///     )
 ///     .map_err(|source| Error::CreateClusterResources { source })?;
 ///
+///     let mut crs = Cluster
 ///     let role_service = Service::default();
 ///     let patched_role_service =
 ///         cluster_resources.add(&client, &role_service)
@@ -161,10 +159,12 @@ impl ClusterResource for Deployment {}
 ///         .await
 ///         .map_err(|source| Error::DeleteOrphanedClusterResources { source })?;
 ///
+///     let status = cluster_status_builder.status(&self);
+///     client.patch_status(status);
 ///     Ok(Action::await_change())
 /// }
 /// ```
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Debug, PartialEq)]
 pub struct ClusterResources {
     /// The namespace of the cluster
     namespace: String,
@@ -176,6 +176,7 @@ pub struct ClusterResources {
     manager: String,
     /// The unique IDs of the cluster resources
     resource_ids: HashSet<String>,
+    status_builders: Vec<dyn ClusterResource>,
 }
 
 impl ClusterResources {
@@ -259,11 +260,9 @@ impl ClusterResources {
 
         self.resource_ids.insert(resource_id);
 
-        Ok(patched_resource)
-    }
+        self.status_builders.push(resource);
 
-    pub async fn add<T: HasStatus>(&mut self, client: &Client, resource: &T) -> OperatorResult<T> {
-        self.add::<ClusterResource>(client, resource)
+        Ok(patched_resource)
     }
 
     /// Checks that the given `labels` contain the given `label` with the given `expected_content`.
@@ -426,24 +425,6 @@ impl ClusterResources {
         Ok(resources)
     }
 
-    // pub async fn resources_status(self, client: &Client) -> OperatorResult<ClusterResourcesStatus> {
-    //     let label_selector = self.label_selector();
-
-    //     let (dset, sts, deps, pods) = tokio::try_join!(
-    //         client.list_with_label_selector::<DaemonSet>(&self.namespace, &label_selector),
-    //         client.list_with_label_selector::<StatefulSet>(&self.namespace, &label_selector),
-    //         client.list_with_label_selector::<Deployment>(&self.namespace, &label_selector),
-    //         client.list_with_label_selector::<Pod>(&self.namespace, &label_selector)
-    //     )?;
-
-    //     Ok(ClusterResourcesStatus {
-    //         stateful_set_status: sts.iter().filter_map(|sts| sts.status.clone()).collect(),
-    //         daemon_set_status: dset.iter().filter_map(|sts| sts.status.clone()).collect(),
-    //         deployment_status: deps.iter().filter_map(|sts| sts.status.clone()).collect(),
-    //         pod_status: pods.iter().filter_map(|sts| sts.status.clone()).collect(),
-    //     })
-    // }
-
     fn label_selector(&self) -> LabelSelector {
         LabelSelector {
             match_expressions: Some(vec![
diff --git a/src/status/mod.rs b/src/status/mod.rs
index 695332a06..cc487731e 100644
--- a/src/status/mod.rs
+++ b/src/status/mod.rs
@@ -1,22 +1,20 @@
 use std::collections::HashMap;
 
 use k8s_openapi::{
-    api::apps::v1::{DaemonSet, Deployment, StatefulSet},
+    api::{
+        apps::v1::{
+            DaemonSet, DaemonSetStatus, Deployment, DeploymentStatus, StatefulSet,
+            StatefulSetStatus,
+        },
+        core::v1::PodStatus,
+    },
     apimachinery::pkg::apis::meta::v1::Time,
-    Resource,
 };
 
-use crate::cluster_resources::ClusterResource;
-
+use kube::Resource;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-pub trait HasStatus: ClusterResource {}
-
-impl HasStatus for StatefulSet {}
-impl HasStatus for Deployment {}
-impl HasStatus for DaemonSet {}
-
 #[derive(
     strum::Display, Clone, Debug, Default, Deserialize, Eq, Hash, JsonSchema, PartialEq, Serialize,
 )]
@@ -50,7 +48,7 @@ impl From<bool> for ClusterConditionStatus {
         }
     }
 }
-#[derive(Default, PartialEq)]
+#[derive(Debug, Default, PartialEq)]
 pub struct ClusterResourcesStatus {
     pub stateful_set_status: Vec<StatefulSetStatus>,
     pub daemon_set_status: Vec<DaemonSetStatus>,
@@ -88,17 +86,87 @@ impl ClusterCondition {
         }
     }
 }
-pub trait StatusBuilder<T: Resource> {
-    fn conditions(resource: &T, crs: &ClusterResourcesStatus) -> Vec<ClusterCondition>;
+
+pub trait HasStop {
+    fn is_stopped(&self) -> bool {
+        false
+    }
+}
+pub trait HasPause {
+    fn is_paused(&self) -> bool {
+        false
+    }
 }
 
-struct ADR27StatusBuilder {}
+trait HasStatus {
+    fn available(&self) -> Option<ClusterCondition> {
+        None
+    }
+}
 
-impl<T: Resource> StatusBuilder<T> for ADR27StatusBuilder {
-    fn conditions(_resource: &T, crs: &ClusterResourcesStatus) -> Vec<ClusterCondition> {
-        let mut result: HashMap<ClusterConditionType, ClusterConditionStatus> = HashMap::new();
+impl HasStatus for StatefulSet {
+    fn available(&self) -> Option<ClusterCondition> {
+        let requested_replicas = self.spec.and_then(|spec| spec.replicas).unwrap_or_default();
+        let available_replicas = self.status.and_then(|status| status.available_replicas).unwrap_or_default();
+        Some(ClusterCondition {
+            last_transition_time: None,
+            last_update_time: None,
+            message: Some("".to_owned()),
+            reason: Some("".to_owned()),
+            status: (requested_replicas == available_replicas).into(),
+            type_: ClusterConditionType::Available })
+    }
 
-        let (sts_replicas, sts_available_replicas) = crs
+}
+
+impl HasStatus for DaemonSet {
+    fn available(&self) -> Option<ClusterCondition> {
+        let requested_replicas = self.status.and_then(|spec| Some(spec.desired_number_scheduled)).unwrap_or_default();
+        let available_replicas = self.status.and_then(|status| Some(status.number_ready)).unwrap_or_default();
+        Some(ClusterCondition {
+            last_transition_time: None,
+            last_update_time: None,
+            message: Some("".to_owned()),
+            reason: Some("".to_owned()),
+            status: (requested_replicas == available_replicas).into(),
+            type_: ClusterConditionType::Available })
+    }
+
+}
+
+impl HasStatus for Deployment {
+    fn available(&self) -> Option<ClusterCondition> {
+        let requested_replicas = self.spec.and_then(|spec| spec.replicas).unwrap_or_default();
+        let available_replicas = self.status.and_then(|status| status.ready_replicas).unwrap_or_default();
+        Some(ClusterCondition {
+            last_transition_time: None,
+            last_update_time: None,
+            message: Some("".to_owned()),
+            reason: Some("".to_owned()),
+            status: (requested_replicas == available_replicas).into(),
+            type_: ClusterConditionType::Available })
+    }
+
+}
+
+pub trait ClusterStatus: HasStatus {
+    fn condtions(&self) -> Vec<ClusterCondition>;
+}
+
+fn compute_cluster_conditions(resources: &[dyn HasStatus]) -> Vec<ClusterCondition> {
+    todo!()
+}
+
+
+pub trait ClusterStatusBuilder {
+    type Status;
+
+    fn available<T: HasStatus>(
+        &self,
+        resource: &[T],
+    ) -> Option<ClusterCondition> {
+/*
+        let (requested_replicas, sts_available_replicas) = crs
             .stateful_set_status
             .iter()
             .map(|s| (s.replicas, s.available_replicas.unwrap_or_default()))
@@ -125,15 +193,66 @@ impl<T: Resource> StatusBuilder<T> for ADR27StatusBuilder {
             })
             .unwrap_or((0, 0));
 
-        result.insert(
-            ClusterConditionType::Available,
-            (sts_replicas + deploy_replicas == sts_available_replicas + deploy_available_replicas)
+        Some(ClusterCondition {
+            type_: ClusterConditionType::Available,
+            status: (sts_replicas + deploy_replicas
+                == sts_available_replicas + deploy_available_replicas)
                 .into(),
-        );
+        })
+        */ None
+    }
+
+    fn progressing<T: Resource>(
+        &self,
+        resource: &T,
+        crs: &ClusterResourcesStatus,
+    ) -> Option<ClusterCondition> {
+        None
+    }
+
+    fn degraded<T: Resource>(
+        &self,
+        resource: &T,
+        crs: &ClusterResourcesStatus,
+    ) -> Option<ClusterCondition> {
+        None
+    }
+
+    fn paused<T: Resource + HasPause>(
+        &self,
+        resource: &T,
+        crs: &ClusterResourcesStatus,
+    ) -> Option<ClusterCondition> {
+        None
+    }
+
+    fn stopped<T: Resource + HasStop>(
+        &self,
+        resource: &T,
+        crs: &ClusterResourcesStatus,
+    ) -> Option<ClusterCondition> {
+        None
+    }
+
+    fn conditions<T: Resource + HasPause>(
+        &self,
+        resource: &T,
+        crs: &ClusterResourcesStatus,
+    ) -> Vec<ClusterCondition> {
+        let mut result = vec![];
+
+        if let Some(condition) = self.available(resource, crs) {
+            if condition.status != old_condition.status {
+                // set transition time
+
+            }
+            result.push(condition);
+        }
 
         result
-            .into_iter()
-            .map(|(type_, status)| ClusterCondition::new_with(type_, status))
-            .collect()
+    }
+
+    fn status(&self, resource: &T) -> Status {
+        let c = self.conditions()
     }
 }

From 46ac63d8ad6c3fab92eb5ee55dcda015997ce23f Mon Sep 17 00:00:00 2001
From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com>
Date: Tue, 21 Mar 2023 11:56:36 +0100
Subject: [PATCH 04/36] reset cluster_resources.rs to main version

---
 src/cluster_resources.rs | 57 ++++++++++++----------------------------
 1 file changed, 17 insertions(+), 40 deletions(-)

diff --git a/src/cluster_resources.rs b/src/cluster_resources.rs
index 6c68ba576..e129299c7 100644
--- a/src/cluster_resources.rs
+++ b/src/cluster_resources.rs
@@ -5,16 +5,6 @@ use std::{
     fmt::Debug,
 };
 
-use k8s_openapi::{
-    api::{
-        apps::v1::Deployment, core::v1::Secret, core::v1::ServiceAccount, rbac::v1::RoleBinding,
-    },
-    NamespaceResourceScope,
-};
-use kube::core::ErrorResponse;
-use serde::{de::DeserializeOwned, Serialize};
-use tracing::{debug, info};
-
 use crate::{
     client::{Client, GetApi},
     error::{Error, OperatorResult},
@@ -27,9 +17,15 @@ use crate::{
     },
     kube::{Resource, ResourceExt},
     labels::{APP_INSTANCE_LABEL, APP_MANAGED_BY_LABEL, APP_NAME_LABEL},
-    status::{self, ClusterResourcesStatus},
     utils::format_full_controller_name,
 };
+use k8s_openapi::{
+    api::{core::v1::Secret, core::v1::ServiceAccount, rbac::v1::RoleBinding},
+    NamespaceResourceScope,
+};
+use kube::core::ErrorResponse;
+use serde::{de::DeserializeOwned, Serialize};
+use tracing::{debug, info};
 
 /// A cluster resource handled by [`ClusterResources`].
 ///
@@ -44,26 +40,17 @@ pub trait ClusterResource:
     + Resource<DynamicType = (), Scope = NamespaceResourceScope>
     + GetApi<Namespace = str>
     + Serialize
-    + HasStatus
 {
 }
 
 impl ClusterResource for ConfigMap {}
-
 impl ClusterResource for DaemonSet {}
-
 impl ClusterResource for Service {}
-
 impl ClusterResource for StatefulSet {}
-
 impl ClusterResource for ServiceAccount {}
-
 impl ClusterResource for RoleBinding {}
-
 impl ClusterResource for Secret {}
 
-impl ClusterResource for Deployment {}
-
 /// A structure containing the cluster resources.
 ///
 /// Cluster resources can be added and orphaned resources are deleted. A cluster resource becomes
@@ -109,7 +96,7 @@ impl ClusterResource for Deployment {}
 ///     DeleteOrphanedClusterResources {
 ///         source: stackable_operator::error::Error,
 ///     },
-/// }
+/// };
 ///
 /// async fn reconcile(app: Arc<AppCluster>, client: Arc<Client>) -> Result<Action, Error> {
 ///     let validated_config = ValidatedRoleConfigByPropertyKind::default();
@@ -122,7 +109,6 @@ impl ClusterResource for Deployment {}
 ///     )
 ///     .map_err(|source| Error::CreateClusterResources { source })?;
 ///
-///     let mut crs = Cluster
 ///     let role_service = Service::default();
 ///     let patched_role_service =
 ///         cluster_resources.add(&client, &role_service)
@@ -159,12 +145,10 @@ impl ClusterResource for Deployment {}
 ///         .await
 ///         .map_err(|source| Error::DeleteOrphanedClusterResources { source })?;
 ///
-///     let status = cluster_status_builder.status(&self);
-///     client.patch_status(status);
 ///     Ok(Action::await_change())
 /// }
 /// ```
-#[derive(Debug, PartialEq)]
+#[derive(Debug, Eq, PartialEq)]
 pub struct ClusterResources {
     /// The namespace of the cluster
     namespace: String,
@@ -176,7 +160,6 @@ pub struct ClusterResources {
     manager: String,
     /// The unique IDs of the cluster resources
     resource_ids: HashSet<String>,
-    status_builders: Vec<dyn ClusterResource>,
 }
 
 impl ClusterResources {
@@ -260,8 +243,6 @@ impl ClusterResources {
 
         self.resource_ids.insert(resource_id);
 
-        self.status_builders.push(resource);
-
         Ok(patched_resource)
     }
 
@@ -416,17 +397,7 @@ impl ClusterResources {
         &self,
         client: &Client,
     ) -> OperatorResult<Vec<T>> {
-        let label_selector = self.label_selector();
-
-        let resources = client
-            .list_with_label_selector::<T>(&self.namespace, &label_selector)
-            .await?;
-
-        Ok(resources)
-    }
-
-    fn label_selector(&self) -> LabelSelector {
-        LabelSelector {
+        let label_selector = LabelSelector {
             match_expressions: Some(vec![
                 LabelSelectorRequirement {
                     key: APP_INSTANCE_LABEL.into(),
@@ -445,6 +416,12 @@ impl ClusterResources {
                 },
             ]),
             ..Default::default()
-        }
+        };
+
+        let resources = client
+            .list_with_label_selector::<T>(&self.namespace, &label_selector)
+            .await?;
+
+        Ok(resources)
     }
 }

From 35fdb882424fab2dd67e1686f863df8cf725b046 Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Tue, 21 Mar 2023 13:21:15 +0100
Subject: [PATCH 05/36] wip

---
 src/status/mod.rs | 391 +++++++++++++++++++++++++---------------------
 1 file changed, 216 insertions(+), 175 deletions(-)

diff --git a/src/status/mod.rs b/src/status/mod.rs
index cc487731e..f72dcfa03 100644
--- a/src/status/mod.rs
+++ b/src/status/mod.rs
@@ -1,41 +1,48 @@
-use std::collections::HashMap;
-
+use chrono::Utc;
 use k8s_openapi::{
-    api::{
-        apps::v1::{
-            DaemonSet, DaemonSetStatus, Deployment, DeploymentStatus, StatefulSet,
-            StatefulSetStatus,
-        },
-        core::v1::PodStatus,
-    },
+    api::apps::v1::{DaemonSet, StatefulSet},
     apimachinery::pkg::apis::meta::v1::Time,
 };
-
-use kube::Resource;
-use schemars::JsonSchema;
+use schemars::{self, JsonSchema};
 use serde::{Deserialize, Serialize};
+use std::collections::{BTreeMap, HashMap};
+use tracing::info;
 
 #[derive(
-    strum::Display, Clone, Debug, Default, Deserialize, Eq, Hash, JsonSchema, PartialEq, Serialize,
+    Clone, Debug, Default, Deserialize, Eq, Hash, JsonSchema, Ord, PartialEq, PartialOrd, Serialize,
 )]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "PascalCase")]
 pub enum ClusterConditionType {
     #[default]
+    /// Available indicates that the binary maintained by the operator (eg: zookeeper for the
+    /// zookeeper-operator), is functional and available in the cluster.
     Available,
+    /// Degraded indicates that the operand is not functioning completely. An example of a degraded
+    /// state would be if there should be 5 copies of the operand running but only 4 are running.
+    /// It may still be available, but it is degraded.
     Degraded,
+    /// Progressing indicates that the operator is actively making changes to the binary maintained
+    /// by the operator (eg: zookeeper for the zookeeper-operator).
     Progressing,
+    /// Paused indicates that the operator is not reconciling the cluster. This may be used for
+    /// debugging or operator updating.
     Paused,
+    /// Stopped indicates that all the cluster replicas are scaled down to 0. All resources (e.g.
+    /// ConfigMaps, Services etc.) are kept.
     Stopped,
 }
 
 #[derive(
-    strum::Display, Clone, Debug, Default, Deserialize, Eq, JsonSchema, PartialEq, Serialize,
+    Clone, Debug, Default, Deserialize, Eq, JsonSchema, Ord, PartialEq, PartialOrd, Serialize,
 )]
-#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "PascalCase")]
 pub enum ClusterConditionStatus {
     #[default]
+    /// True means a resource is in the condition.
     True,
+    /// False means a resource is not in the condition.
     False,
+    /// Unknown means kubernetes cannot decide if a resource is in the condition or not.
     Unknown,
 }
 
@@ -48,211 +55,245 @@ impl From<bool> for ClusterConditionStatus {
         }
     }
 }
-#[derive(Debug, Default, PartialEq)]
-pub struct ClusterResourcesStatus {
-    pub stateful_set_status: Vec<StatefulSetStatus>,
-    pub daemon_set_status: Vec<DaemonSetStatus>,
-    pub deployment_status: Vec<DeploymentStatus>,
-    pub pod_status: Vec<PodStatus>,
-}
 
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
+#[derive(Clone, Debug, Default, PartialEq, Eq, JsonSchema, Deserialize, Serialize)]
 pub struct ClusterCondition {
     /// Last time the condition transitioned from one status to another.
     pub last_transition_time: Option<Time>,
-
     /// The last time this condition was updated.
     pub last_update_time: Option<Time>,
-
     /// A human readable message indicating details about the transition.
     pub message: Option<String>,
-
     /// The reason for the condition's last transition.
     pub reason: Option<String>,
-
     /// Status of the condition, one of True, False, Unknown.
     pub status: ClusterConditionStatus,
-
     /// Type of deployment condition.
     pub type_: ClusterConditionType,
 }
 
-impl ClusterCondition {
-    pub fn new_with(type_: ClusterConditionType, status: ClusterConditionStatus) -> Self {
-        ClusterCondition {
-            type_,
-            status,
-            ..ClusterCondition::default()
-        }
-    }
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub enum ClusterConditionMergeStrategy {
+    #[default]
+    /// Ordered merge strategy means that a higher (Unknown > False > True) ClusterConditionStatus
+    /// will take precedence over lower ClusterConditionStatus. This means a condition for
+    /// Available with status true will be overwritten by a condition for Available with status false.
+    Ordered,
 }
 
-pub trait HasStop {
-    fn is_stopped(&self) -> bool {
-        false
-    }
+pub trait HasCondition {
+    fn conditions(&self) -> Vec<ClusterCondition>;
 }
-pub trait HasPause {
-    fn is_paused(&self) -> bool {
-        false
-    }
+
+pub trait ConditionBuilder {
+    fn build_conditions(&self) -> Vec<ClusterCondition>;
+    //fn paused(&self, cluster_resource: &T) -> Option<ClusterCondition>;
+    //fn stopped(&self, cluster_resource: &T) -> Option<ClusterCondition>;
 }
 
-trait HasStatus {
-    fn available(&self) -> Option<ClusterCondition> {
-        None
-    }
+pub struct StatefulSetConditionBuilder<'a, T: HasCondition> {
+    resource: &'a T,
+    stateful_sets: Vec<StatefulSet>,
 }
 
-impl HasStatus for StatefulSet {
-    fn available(&self) -> Option<ClusterCondition> {
-        let requested_replicas = self.spec.and_then(|spec| spec.replicas).unwrap_or_default();
-        let available_replicas = self.status.and_then(|status| status.available_replicas).unwrap_or_default();
-        Some(ClusterCondition {
-            last_transition_time: None,
-            last_update_time: None,
-            message: Some("".to_owned()),
-            reason: Some("".to_owned()),
-            status: (requested_replicas == available_replicas).into(),
-            type_: ClusterConditionType::Available })
+impl<'a, T: HasCondition> StatefulSetConditionBuilder<'a, T> {
+    pub fn new(resource: &'a T) -> StatefulSetConditionBuilder<T> {
+        StatefulSetConditionBuilder {
+            resource,
+            stateful_sets: Vec::new(),
+        }
     }
 
-}
-
-impl HasStatus for DaemonSet {
-    fn available(&self) -> Option<ClusterCondition> {
-        let requested_replicas = self.status.and_then(|spec| Some(spec.desired_number_scheduled)).unwrap_or_default();
-        let available_replicas = self.status.and_then(|status| Some(status.number_ready)).unwrap_or_default();
-        Some(ClusterCondition {
-            last_transition_time: None,
-            last_update_time: None,
-            message: Some("".to_owned()),
-            reason: Some("".to_owned()),
-            status: (requested_replicas == available_replicas).into(),
-            type_: ClusterConditionType::Available })
+    pub fn add(&mut self, sts: StatefulSet) {
+        self.stateful_sets.push(sts);
     }
 
-}
+    pub fn available(&self) -> ClusterCondition {
+        let opt_old_available = self
+            .resource
+            .conditions()
+            .iter()
+            .find(|cond| cond.type_ == ClusterConditionType::Available)
+            .cloned();
 
-impl HasStatus for Deployment {
-    fn available(&self) -> Option<ClusterCondition> {
-        let requested_replicas = self.spec.and_then(|spec| spec.replicas).unwrap_or_default();
-        let available_replicas = self.status.and_then(|status| status.ready_replicas).unwrap_or_default();
-        Some(ClusterCondition {
-            last_transition_time: None,
-            last_update_time: None,
-            message: Some("".to_owned()),
-            reason: Some("".to_owned()),
-            status: (requested_replicas == available_replicas).into(),
-            type_: ClusterConditionType::Available })
-    }
+        let mut sts_available = true;
+        for sts in &self.stateful_sets {
+            sts_available = sts_available && stateful_set_available(sts);
+        }
 
+        let message = match sts_available {
+            true => Some("cluster has the requested amount of ready replicas".to_string()),
+            false => {
+                Some("cluster does not have the requested amount of ready replicas".to_string())
+            }
+        };
+
+        let now = Time(Utc::now());
+        if let Some(old_available) = opt_old_available {
+            if old_available.status == sts_available.into() {
+                ClusterCondition {
+                    last_update_time: Some(now),
+                    ..old_available
+                }
+            } else {
+                ClusterCondition {
+                    last_update_time: Some(now.clone()),
+                    last_transition_time: Some(now),
+                    status: sts_available.into(),
+                    message,
+                    ..old_available
+                }
+            }
+        } else {
+            ClusterCondition {
+                last_update_time: Some(now.clone()),
+                last_transition_time: Some(now),
+                status: sts_available.into(),
+                message,
+                reason: None,
+                type_: ClusterConditionType::Available,
+            }
+        }
+    }
 }
 
-pub trait ClusterStatus: HasStatus {
-    fn condtions(&self) -> Vec<ClusterCondition>;
+impl<'a, T: HasCondition> ConditionBuilder for StatefulSetConditionBuilder<'a, T> {
+    fn build_conditions(&self) -> Vec<ClusterCondition> {
+        vec![self.available()]
+    }
 }
 
-fn compute_cluster_conditions(resources: &[dyn HasStatus]) -> Vec<ClusterCondition> {
-    todo!()
+pub struct DaemonSetConditionBuilder<'a, T: HasCondition> {
+    resource: &'a T,
+    daemon_sets: Vec<DaemonSet>,
 }
 
+impl<'a, T: HasCondition> DaemonSetConditionBuilder<'a, T> {
+    pub fn new(resource: &'a T) -> DaemonSetConditionBuilder<T> {
+        DaemonSetConditionBuilder {
+            resource,
+            daemon_sets: Vec::new(),
+        }
+    }
 
-pub trait ClusterStatusBuilder {
-    type Status;
+    pub fn add(&mut self, ds: DaemonSet) {
+        self.daemon_sets.push(ds);
+    }
 
-    fn available<T: HasStatus>(
-        &self,
-        resource: &[T],
-    ) -> Option<ClusterCondition> {
-/*
-        let (requested_replicas, sts_available_replicas) = crs
-            .stateful_set_status
-            .iter()
-            .map(|s| (s.replicas, s.available_replicas.unwrap_or_default()))
-            .reduce(|(mut tr, mut tar), (r, ar)| {
-                tr += r;
-                tar += ar;
-                (tr, tar)
-            })
-            .unwrap_or((0, 0));
-
-        let (deploy_replicas, deploy_available_replicas) = crs
-            .deployment_status
+    pub fn available(&self) -> ClusterCondition {
+        let opt_old_available = self
+            .resource
+            .conditions()
             .iter()
-            .map(|s| {
-                (
-                    s.replicas.unwrap_or_default(),
-                    s.available_replicas.unwrap_or_default(),
-                )
-            })
-            .reduce(|(mut tr, mut tar), (r, ar)| {
-                tr += r;
-                tar += ar;
-                (tr, tar)
-            })
-            .unwrap_or((0, 0));
-
-        Some(ClusterCondition {
-            type_: ClusterConditionType::Available,
-            status: (sts_replicas + deploy_replicas
-                == sts_available_replicas + deploy_available_replicas)
-                .into(),
-        })
-        */ None
-    }
+            .find(|cond| cond.type_ == ClusterConditionType::Available)
+            .cloned();
 
-    fn progressing<T: Resource>(
-        &self,
-        resource: &T,
-        crs: &ClusterResourcesStatus,
-    ) -> Option<ClusterCondition> {
-        None
-    }
+        let mut ds_available = true;
+        for ds in &self.daemon_sets {
+            ds_available = ds_available && daemon_set_available(ds);
+        }
 
-    fn degraded<T: Resource>(
-        &self,
-        resource: &T,
-        crs: &ClusterResourcesStatus,
-    ) -> Option<ClusterCondition> {
-        None
+        let message = match ds_available {
+            true => Some("cluster has the requested amount of ready replicas".to_string()),
+            false => {
+                Some("cluster does not have the requested amount of ready replicas".to_string())
+            }
+        };
+
+        let now = Time(Utc::now());
+        if let Some(old_available) = opt_old_available {
+            if old_available.status == ds_available.into() {
+                ClusterCondition {
+                    last_update_time: Some(now),
+                    ..old_available
+                }
+            } else {
+                ClusterCondition {
+                    last_update_time: Some(now.clone()),
+                    last_transition_time: Some(now),
+                    status: ds_available.into(),
+                    message,
+                    ..old_available
+                }
+            }
+        } else {
+            ClusterCondition {
+                last_update_time: Some(now.clone()),
+                last_transition_time: Some(now),
+                status: ds_available.into(),
+                message,
+                reason: None,
+                type_: ClusterConditionType::Available,
+            }
+        }
     }
+}
 
-    fn paused<T: Resource + HasPause>(
-        &self,
-        resource: &T,
-        crs: &ClusterResourcesStatus,
-    ) -> Option<ClusterCondition> {
-        None
+impl<'a, T: HasCondition> ConditionBuilder for DaemonSetConditionBuilder<'a, T> {
+    fn build_conditions(&self) -> Vec<ClusterCondition> {
+        vec![self.available()]
     }
+}
 
-    fn stopped<T: Resource + HasStop>(
-        &self,
-        resource: &T,
-        crs: &ClusterResourcesStatus,
-    ) -> Option<ClusterCondition> {
-        None
+pub fn compute_conditions<T: ConditionBuilder>(condition_builder: &[T]) -> Vec<ClusterCondition> {
+    let mut current_conditions = BTreeMap::<ClusterConditionType, ClusterCondition>::new();
+    for cb in condition_builder {
+        let cb_conditions: HashMap<ClusterConditionType, ClusterCondition> = cb
+            .build_conditions()
+            .iter()
+            .map(|c| (c.type_.clone(), c.clone()))
+            .collect();
+
+        for (current_condition_type, cb_condition) in cb_conditions {
+            let current_condition = current_conditions.get(&current_condition_type);
+
+            let next_condition = if let Some(current) = current_condition {
+                if current.status > cb_condition.status {
+                    current
+                } else {
+                    &cb_condition
+                }
+            } else {
+                &cb_condition
+            };
+
+            current_conditions.insert(current_condition_type, next_condition.clone());
+        }
     }
 
-    fn conditions<T: Resource + HasPause>(
-        &self,
-        resource: &T,
-        crs: &ClusterResourcesStatus,
-    ) -> Vec<ClusterCondition> {
-        let mut result = vec![];
-
-        if let Some(condition) = self.available(resource, crs) {
-            if condition.status != old_condition.status {
-                // set transition time
-
-            }
-            result.push(condition);
-        }
+    current_conditions.values().cloned().collect()
+}
 
-        result
-    }
+fn stateful_set_available(sts: &StatefulSet) -> bool {
+    let requested_replicas = sts
+        .spec
+        .as_ref()
+        .and_then(|spec| spec.replicas)
+        .unwrap_or_default();
+    let available_replicas = sts
+        .status
+        .as_ref()
+        .and_then(|status| status.available_replicas)
+        .unwrap_or_default();
+
+    info!("STS: requested_replicas={requested_replicas}");
+    info!("STS: available_replicas={available_replicas}");
+    requested_replicas == available_replicas
+}
 
-    fn status(&self, resource: &T) -> Status {
-        let c = self.conditions()
-    }
+fn daemon_set_available(ds: &DaemonSet) -> bool {
+    let desired_number_scheduled = ds
+        .status
+        .as_ref()
+        .map(|status| status.desired_number_scheduled)
+        .unwrap_or_default();
+    let number_ready = ds
+        .status
+        .as_ref()
+        .map(|status| status.number_ready)
+        .unwrap_or_default();
+
+    info!("Ds: desired_number_scheduled={desired_number_scheduled}");
+    info!("Ds: number_ready={number_ready}");
+    desired_number_scheduled == number_ready
 }

From e130737374bec8138ed0f9c46f143f58fab91429 Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Tue, 21 Mar 2023 15:48:04 +0100
Subject: [PATCH 06/36] fix yaml representation and some refactoring

---
 src/status/mod.rs | 160 +++++++++++++++++++++++-----------------------
 1 file changed, 80 insertions(+), 80 deletions(-)

diff --git a/src/status/mod.rs b/src/status/mod.rs
index f72dcfa03..a7a173128 100644
--- a/src/status/mod.rs
+++ b/src/status/mod.rs
@@ -5,6 +5,7 @@ use k8s_openapi::{
 };
 use schemars::{self, JsonSchema};
 use serde::{Deserialize, Serialize};
+use std::cmp;
 use std::collections::{BTreeMap, HashMap};
 use tracing::info;
 
@@ -46,49 +47,34 @@ pub enum ClusterConditionStatus {
     Unknown,
 }
 
-impl From<bool> for ClusterConditionStatus {
-    fn from(b: bool) -> ClusterConditionStatus {
-        if b {
-            ClusterConditionStatus::True
-        } else {
-            ClusterConditionStatus::False
-        }
-    }
-}
-
 #[derive(Clone, Debug, Default, PartialEq, Eq, JsonSchema, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
 pub struct ClusterCondition {
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// Last time the condition transitioned from one status to another.
     pub last_transition_time: Option<Time>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// The last time this condition was updated.
     pub last_update_time: Option<Time>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// A human readable message indicating details about the transition.
     pub message: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     /// The reason for the condition's last transition.
     pub reason: Option<String>,
     /// Status of the condition, one of True, False, Unknown.
     pub status: ClusterConditionStatus,
     /// Type of deployment condition.
+    #[serde(rename = "type")]
     pub type_: ClusterConditionType,
 }
 
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
-pub enum ClusterConditionMergeStrategy {
-    #[default]
-    /// Ordered merge strategy means that a higher (Unknown > False > True) ClusterConditionStatus
-    /// will take precedence over lower ClusterConditionStatus. This means a condition for
-    /// Available with status true will be overwritten by a condition for Available with status false.
-    Ordered,
-}
-
 pub trait HasCondition {
     fn conditions(&self) -> Vec<ClusterCondition>;
 }
 
 pub trait ConditionBuilder {
     fn build_conditions(&self) -> Vec<ClusterCondition>;
-    //fn paused(&self, cluster_resource: &T) -> Option<ClusterCondition>;
-    //fn stopped(&self, cluster_resource: &T) -> Option<ClusterCondition>;
 }
 
 pub struct StatefulSetConditionBuilder<'a, T: HasCondition> {
@@ -116,44 +102,62 @@ impl<'a, T: HasCondition> StatefulSetConditionBuilder<'a, T> {
             .find(|cond| cond.type_ == ClusterConditionType::Available)
             .cloned();
 
-        let mut sts_available = true;
+        let mut sts_available = ClusterConditionStatus::True;
         for sts in &self.stateful_sets {
-            sts_available = sts_available && stateful_set_available(sts);
+            sts_available = cmp::max(sts_available, stateful_set_available(sts));
         }
 
         let message = match sts_available {
-            true => Some("cluster has the requested amount of ready replicas".to_string()),
-            false => {
-                Some("cluster does not have the requested amount of ready replicas".to_string())
+            ClusterConditionStatus::True => "cluster has the requested amount of ready replicas",
+            ClusterConditionStatus::False => {
+                "cluster does not have the requested amount of ready replicas"
             }
+            ClusterConditionStatus::Unknown => "Unknown",
         };
 
-        let now = Time(Utc::now());
-        if let Some(old_available) = opt_old_available {
-            if old_available.status == sts_available.into() {
-                ClusterCondition {
-                    last_update_time: Some(now),
-                    ..old_available
-                }
-            } else {
-                ClusterCondition {
-                    last_update_time: Some(now.clone()),
-                    last_transition_time: Some(now),
-                    status: sts_available.into(),
-                    message,
-                    ..old_available
-                }
+        update_condition(
+            ClusterConditionType::Available,
+            opt_old_available,
+            sts_available,
+            message,
+        )
+    }
+}
+
+fn update_condition(
+    condition_type: ClusterConditionType,
+    old_condition: Option<ClusterCondition>,
+    merged_condition_status: ClusterConditionStatus,
+    message: &str,
+) -> ClusterCondition {
+    let now = Time(Utc::now());
+    if let Some(old_condition) = old_condition {
+        // No change in status -> update "last_update_time"
+        if old_condition.status == merged_condition_status {
+            ClusterCondition {
+                last_update_time: Some(now),
+                ..old_condition
             }
+        // Change in status -> set new message, status and update / transition times
         } else {
             ClusterCondition {
                 last_update_time: Some(now.clone()),
                 last_transition_time: Some(now),
-                status: sts_available.into(),
-                message,
-                reason: None,
-                type_: ClusterConditionType::Available,
+                status: merged_condition_status,
+                message: Some(message.to_string()),
+                ..old_condition
             }
         }
+    // No condition available -> create
+    } else {
+        ClusterCondition {
+            last_update_time: Some(now.clone()),
+            last_transition_time: Some(now),
+            status: merged_condition_status,
+            message: Some(message.to_string()),
+            reason: None,
+            type_: condition_type,
+        }
     }
 }
 
@@ -188,44 +192,25 @@ impl<'a, T: HasCondition> DaemonSetConditionBuilder<'a, T> {
             .find(|cond| cond.type_ == ClusterConditionType::Available)
             .cloned();
 
-        let mut ds_available = true;
+        let mut ds_available = ClusterConditionStatus::True;
         for ds in &self.daemon_sets {
-            ds_available = ds_available && daemon_set_available(ds);
+            ds_available = cmp::max(ds_available, daemon_set_available(ds));
         }
 
         let message = match ds_available {
-            true => Some("cluster has the requested amount of ready replicas".to_string()),
-            false => {
-                Some("cluster does not have the requested amount of ready replicas".to_string())
+            ClusterConditionStatus::True => "cluster has the requested amount of ready replicas",
+            ClusterConditionStatus::False => {
+                "cluster does not have the requested amount of ready replicas"
             }
+            ClusterConditionStatus::Unknown => "Unknown",
         };
 
-        let now = Time(Utc::now());
-        if let Some(old_available) = opt_old_available {
-            if old_available.status == ds_available.into() {
-                ClusterCondition {
-                    last_update_time: Some(now),
-                    ..old_available
-                }
-            } else {
-                ClusterCondition {
-                    last_update_time: Some(now.clone()),
-                    last_transition_time: Some(now),
-                    status: ds_available.into(),
-                    message,
-                    ..old_available
-                }
-            }
-        } else {
-            ClusterCondition {
-                last_update_time: Some(now.clone()),
-                last_transition_time: Some(now),
-                status: ds_available.into(),
-                message,
-                reason: None,
-                type_: ClusterConditionType::Available,
-            }
-        }
+        update_condition(
+            ClusterConditionType::Available,
+            opt_old_available,
+            ds_available,
+            message,
+        )
     }
 }
 
@@ -264,7 +249,7 @@ pub fn compute_conditions<T: ConditionBuilder>(condition_builder: &[T]) -> Vec<C
     current_conditions.values().cloned().collect()
 }
 
-fn stateful_set_available(sts: &StatefulSet) -> bool {
+fn stateful_set_available(sts: &StatefulSet) -> ClusterConditionStatus {
     let requested_replicas = sts
         .spec
         .as_ref()
@@ -278,10 +263,15 @@ fn stateful_set_available(sts: &StatefulSet) -> bool {
 
     info!("STS: requested_replicas={requested_replicas}");
     info!("STS: available_replicas={available_replicas}");
-    requested_replicas == available_replicas
+
+    if requested_replicas == available_replicas {
+        ClusterConditionStatus::True
+    } else {
+        ClusterConditionStatus::False
+    }
 }
 
-fn daemon_set_available(ds: &DaemonSet) -> bool {
+fn daemon_set_available(ds: &DaemonSet) -> ClusterConditionStatus {
     let desired_number_scheduled = ds
         .status
         .as_ref()
@@ -295,5 +285,15 @@ fn daemon_set_available(ds: &DaemonSet) -> bool {
 
     info!("Ds: desired_number_scheduled={desired_number_scheduled}");
     info!("Ds: number_ready={number_ready}");
-    desired_number_scheduled == number_ready
+    if desired_number_scheduled == number_ready {
+        ClusterConditionStatus::True
+    } else {
+        ClusterConditionStatus::False
+    }
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test() {}
 }

From 854a283ee3ac5633f15e33aa1a2bbb1316365fd6 Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Tue, 21 Mar 2023 17:26:59 +0100
Subject: [PATCH 07/36] refactoring

---
 src/status/condition/daemonset.rs   |  85 +++++++++++
 src/status/condition/mod.rs         |   2 +
 src/status/condition/statefulset.rs |  97 ++++++++++++
 src/status/mod.rs                   | 227 +++++-----------------------
 4 files changed, 219 insertions(+), 192 deletions(-)
 create mode 100644 src/status/condition/daemonset.rs
 create mode 100644 src/status/condition/mod.rs
 create mode 100644 src/status/condition/statefulset.rs

diff --git a/src/status/condition/daemonset.rs b/src/status/condition/daemonset.rs
new file mode 100644
index 000000000..bbee3cdf4
--- /dev/null
+++ b/src/status/condition/daemonset.rs
@@ -0,0 +1,85 @@
+use crate::status::{
+    update_condition, ClusterCondition, ClusterConditionStatus, ClusterConditionType,
+    ConditionBuilder, HasStatusCondition,
+};
+
+use k8s_openapi::api::apps::v1::DaemonSet;
+use kube::ResourceExt;
+use std::cmp;
+
+pub struct DaemonSetConditionBuilder<'a, T: HasStatusCondition> {
+    resource: &'a T,
+    daemon_sets: Vec<DaemonSet>,
+}
+
+impl<'a, T: HasStatusCondition> DaemonSetConditionBuilder<'a, T> {
+    pub fn new(resource: &'a T) -> DaemonSetConditionBuilder<T> {
+        DaemonSetConditionBuilder {
+            resource,
+            daemon_sets: Vec::new(),
+        }
+    }
+
+    pub fn add(&mut self, ds: DaemonSet) {
+        self.daemon_sets.push(ds);
+    }
+
+    pub fn available(&self) -> ClusterCondition {
+        let opt_old_available = self
+            .resource
+            .conditions()
+            .iter()
+            .find(|cond| cond.type_ == ClusterConditionType::Available)
+            .cloned();
+
+        let mut available = ClusterConditionStatus::True;
+        let mut unavailable_ds = vec![];
+
+        for ds in &self.daemon_sets {
+            let current_status = daemon_set_available(ds);
+
+            if current_status != ClusterConditionStatus::True {
+                unavailable_ds.push(ds.name_any())
+            }
+
+            available = cmp::max(available, current_status);
+        }
+
+        let message = match available {
+            ClusterConditionStatus::True => {
+                "All DaemonSet have the requested amount of ready replicas.".to_string()
+            }
+            ClusterConditionStatus::False => {
+                format!("DaemonSet {unavailable_ds:?} missing ready replicas.")
+            }
+            ClusterConditionStatus::Unknown => "DaemonSet status cannot be determined.".to_string(),
+        };
+
+        update_condition(
+            ClusterConditionType::Available,
+            opt_old_available,
+            available,
+            &message,
+        )
+    }
+}
+
+impl<'a, T: HasStatusCondition> ConditionBuilder for DaemonSetConditionBuilder<'a, T> {
+    fn build_conditions(&self) -> Vec<ClusterCondition> {
+        vec![self.available()]
+    }
+}
+
+fn daemon_set_available(ds: &DaemonSet) -> ClusterConditionStatus {
+    let number_unavailable = ds
+        .status
+        .as_ref()
+        .and_then(|status| status.number_unavailable)
+        .unwrap_or_default();
+
+    if number_unavailable == 0 {
+        ClusterConditionStatus::True
+    } else {
+        ClusterConditionStatus::False
+    }
+}
diff --git a/src/status/condition/mod.rs b/src/status/condition/mod.rs
new file mode 100644
index 000000000..7a3d572ad
--- /dev/null
+++ b/src/status/condition/mod.rs
@@ -0,0 +1,2 @@
+pub mod daemonset;
+pub mod statefulset;
diff --git a/src/status/condition/statefulset.rs b/src/status/condition/statefulset.rs
new file mode 100644
index 000000000..7222870e4
--- /dev/null
+++ b/src/status/condition/statefulset.rs
@@ -0,0 +1,97 @@
+use crate::status::{
+    update_condition, ClusterCondition, ClusterConditionStatus, ClusterConditionType,
+    ConditionBuilder, HasStatusCondition,
+};
+
+use k8s_openapi::api::apps::v1::StatefulSet;
+use kube::ResourceExt;
+use std::cmp;
+
+pub struct StatefulSetConditionBuilder<'a, T: HasStatusCondition> {
+    resource: &'a T,
+    stateful_sets: Vec<StatefulSet>,
+}
+
+impl<'a, T: HasStatusCondition> StatefulSetConditionBuilder<'a, T> {
+    pub fn new(resource: &'a T) -> StatefulSetConditionBuilder<T> {
+        StatefulSetConditionBuilder {
+            resource,
+            stateful_sets: Vec::new(),
+        }
+    }
+
+    pub fn add(&mut self, sts: StatefulSet) {
+        self.stateful_sets.push(sts);
+    }
+
+    pub fn available(&self) -> ClusterCondition {
+        let opt_old_available = self
+            .resource
+            .conditions()
+            .iter()
+            .find(|cond| cond.type_ == ClusterConditionType::Available)
+            .cloned();
+
+        let mut available = ClusterConditionStatus::True;
+        let mut unavailable_sts = vec![];
+        for sts in &self.stateful_sets {
+            let current_status = stateful_set_available(sts);
+
+            if current_status != ClusterConditionStatus::True {
+                unavailable_sts.push(sts.name_any())
+            }
+
+            available = cmp::max(available, current_status);
+        }
+
+        let message = match available {
+            ClusterConditionStatus::True => {
+                "All StatefulSet have the requested amount of ready replicas.".to_string()
+            }
+            ClusterConditionStatus::False => {
+                format!("StatefulSet {unavailable_sts:?} missing ready replicas.")
+            }
+            ClusterConditionStatus::Unknown => {
+                "StatefulSet status cannot be determined.".to_string()
+            }
+        };
+
+        update_condition(
+            ClusterConditionType::Available,
+            opt_old_available,
+            available,
+            &message,
+        )
+    }
+}
+
+impl<'a, T: HasStatusCondition> ConditionBuilder for StatefulSetConditionBuilder<'a, T> {
+    fn build_conditions(&self) -> Vec<ClusterCondition> {
+        vec![self.available()]
+    }
+}
+
+fn stateful_set_available(sts: &StatefulSet) -> ClusterConditionStatus {
+    let requested_replicas = sts
+        .spec
+        .as_ref()
+        .and_then(|spec| spec.replicas)
+        .unwrap_or_default();
+    let available_replicas = sts
+        .status
+        .as_ref()
+        .and_then(|status| status.available_replicas)
+        .unwrap_or_default();
+
+    if requested_replicas == available_replicas {
+        ClusterConditionStatus::True
+    } else {
+        ClusterConditionStatus::False
+    }
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test() {}
+}
diff --git a/src/status/mod.rs b/src/status/mod.rs
index a7a173128..cfc139b57 100644
--- a/src/status/mod.rs
+++ b/src/status/mod.rs
@@ -1,13 +1,18 @@
+pub mod condition;
+
 use chrono::Utc;
-use k8s_openapi::{
-    api::apps::v1::{DaemonSet, StatefulSet},
-    apimachinery::pkg::apis::meta::v1::Time,
-};
+use k8s_openapi::apimachinery::pkg::apis::meta::v1::Time;
 use schemars::{self, JsonSchema};
 use serde::{Deserialize, Serialize};
-use std::cmp;
 use std::collections::{BTreeMap, HashMap};
-use tracing::info;
+
+pub trait HasStatusCondition {
+    fn conditions(&self) -> Vec<ClusterCondition>;
+}
+
+pub trait ConditionBuilder {
+    fn build_conditions(&self) -> Vec<ClusterCondition>;
+}
 
 #[derive(
     Clone, Debug, Default, Deserialize, Eq, Hash, JsonSchema, Ord, PartialEq, PartialOrd, Serialize,
@@ -69,59 +74,33 @@ pub struct ClusterCondition {
     pub type_: ClusterConditionType,
 }
 
-pub trait HasCondition {
-    fn conditions(&self) -> Vec<ClusterCondition>;
-}
+pub fn compute_conditions<T: ConditionBuilder>(condition_builder: &[T]) -> Vec<ClusterCondition> {
+    let mut current_conditions = BTreeMap::<ClusterConditionType, ClusterCondition>::new();
+    for cb in condition_builder {
+        let cb_conditions: HashMap<ClusterConditionType, ClusterCondition> = cb
+            .build_conditions()
+            .iter()
+            .map(|c| (c.type_.clone(), c.clone()))
+            .collect();
 
-pub trait ConditionBuilder {
-    fn build_conditions(&self) -> Vec<ClusterCondition>;
-}
+        for (current_condition_type, cb_condition) in cb_conditions {
+            let current_condition = current_conditions.get(&current_condition_type);
 
-pub struct StatefulSetConditionBuilder<'a, T: HasCondition> {
-    resource: &'a T,
-    stateful_sets: Vec<StatefulSet>,
-}
+            let next_condition = if let Some(current) = current_condition {
+                if current.status > cb_condition.status {
+                    current
+                } else {
+                    &cb_condition
+                }
+            } else {
+                &cb_condition
+            };
 
-impl<'a, T: HasCondition> StatefulSetConditionBuilder<'a, T> {
-    pub fn new(resource: &'a T) -> StatefulSetConditionBuilder<T> {
-        StatefulSetConditionBuilder {
-            resource,
-            stateful_sets: Vec::new(),
+            current_conditions.insert(current_condition_type, next_condition.clone());
         }
     }
 
-    pub fn add(&mut self, sts: StatefulSet) {
-        self.stateful_sets.push(sts);
-    }
-
-    pub fn available(&self) -> ClusterCondition {
-        let opt_old_available = self
-            .resource
-            .conditions()
-            .iter()
-            .find(|cond| cond.type_ == ClusterConditionType::Available)
-            .cloned();
-
-        let mut sts_available = ClusterConditionStatus::True;
-        for sts in &self.stateful_sets {
-            sts_available = cmp::max(sts_available, stateful_set_available(sts));
-        }
-
-        let message = match sts_available {
-            ClusterConditionStatus::True => "cluster has the requested amount of ready replicas",
-            ClusterConditionStatus::False => {
-                "cluster does not have the requested amount of ready replicas"
-            }
-            ClusterConditionStatus::Unknown => "Unknown",
-        };
-
-        update_condition(
-            ClusterConditionType::Available,
-            opt_old_available,
-            sts_available,
-            message,
-        )
-    }
+    current_conditions.values().cloned().collect()
 }
 
 fn update_condition(
@@ -136,9 +115,10 @@ fn update_condition(
         if old_condition.status == merged_condition_status {
             ClusterCondition {
                 last_update_time: Some(now),
+                message: Some(message.to_string()),
                 ..old_condition
             }
-        // Change in status -> set new message, status and update / transition times
+            // Change in status -> set new message, status and update / transition times
         } else {
             ClusterCondition {
                 last_update_time: Some(now.clone()),
@@ -148,7 +128,7 @@ fn update_condition(
                 ..old_condition
             }
         }
-    // No condition available -> create
+        // No condition available -> create
     } else {
         ClusterCondition {
             last_update_time: Some(now.clone()),
@@ -160,140 +140,3 @@ fn update_condition(
         }
     }
 }
-
-impl<'a, T: HasCondition> ConditionBuilder for StatefulSetConditionBuilder<'a, T> {
-    fn build_conditions(&self) -> Vec<ClusterCondition> {
-        vec![self.available()]
-    }
-}
-
-pub struct DaemonSetConditionBuilder<'a, T: HasCondition> {
-    resource: &'a T,
-    daemon_sets: Vec<DaemonSet>,
-}
-
-impl<'a, T: HasCondition> DaemonSetConditionBuilder<'a, T> {
-    pub fn new(resource: &'a T) -> DaemonSetConditionBuilder<T> {
-        DaemonSetConditionBuilder {
-            resource,
-            daemon_sets: Vec::new(),
-        }
-    }
-
-    pub fn add(&mut self, ds: DaemonSet) {
-        self.daemon_sets.push(ds);
-    }
-
-    pub fn available(&self) -> ClusterCondition {
-        let opt_old_available = self
-            .resource
-            .conditions()
-            .iter()
-            .find(|cond| cond.type_ == ClusterConditionType::Available)
-            .cloned();
-
-        let mut ds_available = ClusterConditionStatus::True;
-        for ds in &self.daemon_sets {
-            ds_available = cmp::max(ds_available, daemon_set_available(ds));
-        }
-
-        let message = match ds_available {
-            ClusterConditionStatus::True => "cluster has the requested amount of ready replicas",
-            ClusterConditionStatus::False => {
-                "cluster does not have the requested amount of ready replicas"
-            }
-            ClusterConditionStatus::Unknown => "Unknown",
-        };
-
-        update_condition(
-            ClusterConditionType::Available,
-            opt_old_available,
-            ds_available,
-            message,
-        )
-    }
-}
-
-impl<'a, T: HasCondition> ConditionBuilder for DaemonSetConditionBuilder<'a, T> {
-    fn build_conditions(&self) -> Vec<ClusterCondition> {
-        vec![self.available()]
-    }
-}
-
-pub fn compute_conditions<T: ConditionBuilder>(condition_builder: &[T]) -> Vec<ClusterCondition> {
-    let mut current_conditions = BTreeMap::<ClusterConditionType, ClusterCondition>::new();
-    for cb in condition_builder {
-        let cb_conditions: HashMap<ClusterConditionType, ClusterCondition> = cb
-            .build_conditions()
-            .iter()
-            .map(|c| (c.type_.clone(), c.clone()))
-            .collect();
-
-        for (current_condition_type, cb_condition) in cb_conditions {
-            let current_condition = current_conditions.get(&current_condition_type);
-
-            let next_condition = if let Some(current) = current_condition {
-                if current.status > cb_condition.status {
-                    current
-                } else {
-                    &cb_condition
-                }
-            } else {
-                &cb_condition
-            };
-
-            current_conditions.insert(current_condition_type, next_condition.clone());
-        }
-    }
-
-    current_conditions.values().cloned().collect()
-}
-
-fn stateful_set_available(sts: &StatefulSet) -> ClusterConditionStatus {
-    let requested_replicas = sts
-        .spec
-        .as_ref()
-        .and_then(|spec| spec.replicas)
-        .unwrap_or_default();
-    let available_replicas = sts
-        .status
-        .as_ref()
-        .and_then(|status| status.available_replicas)
-        .unwrap_or_default();
-
-    info!("STS: requested_replicas={requested_replicas}");
-    info!("STS: available_replicas={available_replicas}");
-
-    if requested_replicas == available_replicas {
-        ClusterConditionStatus::True
-    } else {
-        ClusterConditionStatus::False
-    }
-}
-
-fn daemon_set_available(ds: &DaemonSet) -> ClusterConditionStatus {
-    let desired_number_scheduled = ds
-        .status
-        .as_ref()
-        .map(|status| status.desired_number_scheduled)
-        .unwrap_or_default();
-    let number_ready = ds
-        .status
-        .as_ref()
-        .map(|status| status.number_ready)
-        .unwrap_or_default();
-
-    info!("Ds: desired_number_scheduled={desired_number_scheduled}");
-    info!("Ds: number_ready={number_ready}");
-    if desired_number_scheduled == number_ready {
-        ClusterConditionStatus::True
-    } else {
-        ClusterConditionStatus::False
-    }
-}
-
-#[cfg(test)]
-mod test {
-    #[test]
-    fn test() {}
-}

From 867f12ce88d6c172e4c180d642b7466b0a52e765 Mon Sep 17 00:00:00 2001
From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com>
Date: Wed, 22 Mar 2023 14:46:04 +0100
Subject: [PATCH 08/36] refactor for simplification

---
 src/status/condition/daemonset.rs | 37 ++++++++-----------
 src/status/condition/mod.rs       |  2 +-
 src/status/mod.rs                 | 59 ++++++++++++++-----------------
 3 files changed, 41 insertions(+), 57 deletions(-)

diff --git a/src/status/condition/daemonset.rs b/src/status/condition/daemonset.rs
index bbee3cdf4..73a9487d2 100644
--- a/src/status/condition/daemonset.rs
+++ b/src/status/condition/daemonset.rs
@@ -1,37 +1,26 @@
 use crate::status::{
-    update_condition, ClusterCondition, ClusterConditionStatus, ClusterConditionType,
-    ConditionBuilder, HasStatusCondition,
+    ClusterCondition, ClusterConditionStatus, ClusterConditionType, ConditionBuilder,
 };
 
 use k8s_openapi::api::apps::v1::DaemonSet;
 use kube::ResourceExt;
 use std::cmp;
 
-pub struct DaemonSetConditionBuilder<'a, T: HasStatusCondition> {
-    resource: &'a T,
+pub struct DaemonSetConditionBuilder {
     daemon_sets: Vec<DaemonSet>,
 }
 
-impl<'a, T: HasStatusCondition> DaemonSetConditionBuilder<'a, T> {
-    pub fn new(resource: &'a T) -> DaemonSetConditionBuilder<T> {
+impl DaemonSetConditionBuilder {
+    pub fn new() -> Self {
         DaemonSetConditionBuilder {
-            resource,
-            daemon_sets: Vec::new(),
+            daemon_sets: vec![],
         }
     }
-
     pub fn add(&mut self, ds: DaemonSet) {
         self.daemon_sets.push(ds);
     }
 
     pub fn available(&self) -> ClusterCondition {
-        let opt_old_available = self
-            .resource
-            .conditions()
-            .iter()
-            .find(|cond| cond.type_ == ClusterConditionType::Available)
-            .cloned();
-
         let mut available = ClusterConditionStatus::True;
         let mut unavailable_ds = vec![];
 
@@ -55,16 +44,18 @@ impl<'a, T: HasStatusCondition> DaemonSetConditionBuilder<'a, T> {
             ClusterConditionStatus::Unknown => "DaemonSet status cannot be determined.".to_string(),
         };
 
-        update_condition(
-            ClusterConditionType::Available,
-            opt_old_available,
-            available,
-            &message,
-        )
+        ClusterCondition {
+            reason: None,
+            message: Some(message),
+            status: available,
+            type_: ClusterConditionType::Available,
+            last_transition_time: None,
+            last_update_time: None,
+        }
     }
 }
 
-impl<'a, T: HasStatusCondition> ConditionBuilder for DaemonSetConditionBuilder<'a, T> {
+impl ConditionBuilder for DaemonSetConditionBuilder {
     fn build_conditions(&self) -> Vec<ClusterCondition> {
         vec![self.available()]
     }
diff --git a/src/status/condition/mod.rs b/src/status/condition/mod.rs
index 7a3d572ad..e213044d3 100644
--- a/src/status/condition/mod.rs
+++ b/src/status/condition/mod.rs
@@ -1,2 +1,2 @@
 pub mod daemonset;
-pub mod statefulset;
+//pub mod statefulset;
diff --git a/src/status/mod.rs b/src/status/mod.rs
index cfc139b57..eba7046fc 100644
--- a/src/status/mod.rs
+++ b/src/status/mod.rs
@@ -74,58 +74,54 @@ pub struct ClusterCondition {
     pub type_: ClusterConditionType,
 }
 
-pub fn compute_conditions<T: ConditionBuilder>(condition_builder: &[T]) -> Vec<ClusterCondition> {
-    let mut current_conditions = BTreeMap::<ClusterConditionType, ClusterCondition>::new();
+pub fn compute_conditions<T: ConditionBuilder, R: HasStatusCondition>(
+    resource: &R,
+    condition_builder: &[T],
+) -> Vec<ClusterCondition> {
+    let mut old_conditions: BTreeMap<ClusterConditionType, ClusterCondition> = resource
+        .conditions()
+        .into_iter()
+        .map(|c| (c.type_.clone(), c))
+        .collect();
+
     for cb in condition_builder {
-        let cb_conditions: HashMap<ClusterConditionType, ClusterCondition> = cb
+        let new_conditions: HashMap<ClusterConditionType, ClusterCondition> = cb
             .build_conditions()
             .iter()
             .map(|c| (c.type_.clone(), c.clone()))
             .collect();
 
-        for (current_condition_type, cb_condition) in cb_conditions {
-            let current_condition = current_conditions.get(&current_condition_type);
-
-            let next_condition = if let Some(current) = current_condition {
-                if current.status > cb_condition.status {
-                    current
-                } else {
-                    &cb_condition
-                }
-            } else {
-                &cb_condition
-            };
-
-            current_conditions.insert(current_condition_type, next_condition.clone());
+        for (condition_type, new_condition) in new_conditions {
+            let old_condition = old_conditions.get(&condition_type);
+            old_conditions.insert(
+                condition_type,
+                merge_condition(old_condition, new_condition),
+            );
         }
     }
 
-    current_conditions.values().cloned().collect()
+    old_conditions.values().cloned().collect()
 }
 
-fn update_condition(
-    condition_type: ClusterConditionType,
-    old_condition: Option<ClusterCondition>,
-    merged_condition_status: ClusterConditionStatus,
-    message: &str,
+fn merge_condition(
+    old_condition: Option<&ClusterCondition>,
+    new_condition: ClusterCondition,
 ) -> ClusterCondition {
     let now = Time(Utc::now());
     if let Some(old_condition) = old_condition {
         // No change in status -> update "last_update_time"
-        if old_condition.status == merged_condition_status {
+        if old_condition.status == new_condition.status {
             ClusterCondition {
                 last_update_time: Some(now),
-                message: Some(message.to_string()),
-                ..old_condition
+                last_transition_time: old_condition.last_transition_time.clone(),
+                ..new_condition
             }
             // Change in status -> set new message, status and update / transition times
         } else {
             ClusterCondition {
                 last_update_time: Some(now.clone()),
                 last_transition_time: Some(now),
-                status: merged_condition_status,
-                message: Some(message.to_string()),
-                ..old_condition
+                ..new_condition
             }
         }
         // No condition available -> create
@@ -133,10 +129,7 @@ fn update_condition(
         ClusterCondition {
             last_update_time: Some(now.clone()),
             last_transition_time: Some(now),
-            status: merged_condition_status,
-            message: Some(message.to_string()),
-            reason: None,
-            type_: condition_type,
+            ..new_condition
         }
     }
 }

From 05485434aaf87ea816ebe4c12c168f052db5da78 Mon Sep 17 00:00:00 2001
From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com>
Date: Wed, 22 Mar 2023 15:11:08 +0100
Subject: [PATCH 09/36] sync sts with daemon sets.

---
 src/status/condition/daemonset.rs   |  8 ++----
 src/status/condition/mod.rs         |  2 +-
 src/status/condition/statefulset.rs | 41 ++++++++++-------------------
 3 files changed, 17 insertions(+), 34 deletions(-)

diff --git a/src/status/condition/daemonset.rs b/src/status/condition/daemonset.rs
index 73a9487d2..0b43dc2bb 100644
--- a/src/status/condition/daemonset.rs
+++ b/src/status/condition/daemonset.rs
@@ -6,21 +6,17 @@ use k8s_openapi::api::apps::v1::DaemonSet;
 use kube::ResourceExt;
 use std::cmp;
 
+#[derive(Default)]
 pub struct DaemonSetConditionBuilder {
     daemon_sets: Vec<DaemonSet>,
 }
 
 impl DaemonSetConditionBuilder {
-    pub fn new() -> Self {
-        DaemonSetConditionBuilder {
-            daemon_sets: vec![],
-        }
-    }
     pub fn add(&mut self, ds: DaemonSet) {
         self.daemon_sets.push(ds);
     }
 
-    pub fn available(&self) -> ClusterCondition {
+    fn available(&self) -> ClusterCondition {
         let mut available = ClusterConditionStatus::True;
         let mut unavailable_ds = vec![];
 
diff --git a/src/status/condition/mod.rs b/src/status/condition/mod.rs
index e213044d3..7a3d572ad 100644
--- a/src/status/condition/mod.rs
+++ b/src/status/condition/mod.rs
@@ -1,2 +1,2 @@
 pub mod daemonset;
-//pub mod statefulset;
+pub mod statefulset;
diff --git a/src/status/condition/statefulset.rs b/src/status/condition/statefulset.rs
index 7222870e4..07cef0c62 100644
--- a/src/status/condition/statefulset.rs
+++ b/src/status/condition/statefulset.rs
@@ -1,37 +1,22 @@
 use crate::status::{
-    update_condition, ClusterCondition, ClusterConditionStatus, ClusterConditionType,
-    ConditionBuilder, HasStatusCondition,
+    ClusterCondition, ClusterConditionStatus, ClusterConditionType, ConditionBuilder,
 };
 
 use k8s_openapi::api::apps::v1::StatefulSet;
 use kube::ResourceExt;
 use std::cmp;
 
-pub struct StatefulSetConditionBuilder<'a, T: HasStatusCondition> {
-    resource: &'a T,
+#[derive(Default)]
+pub struct StatefulSetConditionBuilder {
     stateful_sets: Vec<StatefulSet>,
 }
 
-impl<'a, T: HasStatusCondition> StatefulSetConditionBuilder<'a, T> {
-    pub fn new(resource: &'a T) -> StatefulSetConditionBuilder<T> {
-        StatefulSetConditionBuilder {
-            resource,
-            stateful_sets: Vec::new(),
-        }
-    }
-
+impl StatefulSetConditionBuilder {
     pub fn add(&mut self, sts: StatefulSet) {
         self.stateful_sets.push(sts);
     }
 
-    pub fn available(&self) -> ClusterCondition {
-        let opt_old_available = self
-            .resource
-            .conditions()
-            .iter()
-            .find(|cond| cond.type_ == ClusterConditionType::Available)
-            .cloned();
-
+    fn available(&self) -> ClusterCondition {
         let mut available = ClusterConditionStatus::True;
         let mut unavailable_sts = vec![];
         for sts in &self.stateful_sets {
@@ -56,16 +41,18 @@ impl<'a, T: HasStatusCondition> StatefulSetConditionBuilder<'a, T> {
             }
         };
 
-        update_condition(
-            ClusterConditionType::Available,
-            opt_old_available,
-            available,
-            &message,
-        )
+        ClusterCondition {
+            reason: None,
+            message: Some(message),
+            status: available,
+            type_: ClusterConditionType::Available,
+            last_transition_time: None,
+            last_update_time: None,
+        }
     }
 }
 
-impl<'a, T: HasStatusCondition> ConditionBuilder for StatefulSetConditionBuilder<'a, T> {
+impl ConditionBuilder for StatefulSetConditionBuilder {
     fn build_conditions(&self) -> Vec<ClusterCondition> {
         vec![self.available()]
     }

From 8e0a1b0f4a3baae4b4354db6d0151779cbf296c9 Mon Sep 17 00:00:00 2001
From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com>
Date: Wed, 22 Mar 2023 16:52:22 +0100
Subject: [PATCH 10/36] Added clusterconditionset

---
 src/status/condition/daemonset.rs   |   7 +-
 src/status/condition/statefulset.rs |   7 +-
 src/status/mod.rs                   | 112 ++++++++++++++++++----------
 3 files changed, 81 insertions(+), 45 deletions(-)

diff --git a/src/status/condition/daemonset.rs b/src/status/condition/daemonset.rs
index 0b43dc2bb..450ed10d6 100644
--- a/src/status/condition/daemonset.rs
+++ b/src/status/condition/daemonset.rs
@@ -1,5 +1,6 @@
 use crate::status::{
-    ClusterCondition, ClusterConditionStatus, ClusterConditionType, ConditionBuilder,
+    ClusterCondition, ClusterConditionSet, ClusterConditionStatus, ClusterConditionType,
+    ConditionBuilder,
 };
 
 use k8s_openapi::api::apps::v1::DaemonSet;
@@ -52,8 +53,8 @@ impl DaemonSetConditionBuilder {
 }
 
 impl ConditionBuilder for DaemonSetConditionBuilder {
-    fn build_conditions(&self) -> Vec<ClusterCondition> {
-        vec![self.available()]
+    fn build_conditions(&self) -> ClusterConditionSet {
+        vec![self.available()].into()
     }
 }
 
diff --git a/src/status/condition/statefulset.rs b/src/status/condition/statefulset.rs
index 07cef0c62..1d3eac526 100644
--- a/src/status/condition/statefulset.rs
+++ b/src/status/condition/statefulset.rs
@@ -1,5 +1,6 @@
 use crate::status::{
-    ClusterCondition, ClusterConditionStatus, ClusterConditionType, ConditionBuilder,
+    ClusterCondition, ClusterConditionSet, ClusterConditionStatus, ClusterConditionType,
+    ConditionBuilder,
 };
 
 use k8s_openapi::api::apps::v1::StatefulSet;
@@ -53,8 +54,8 @@ impl StatefulSetConditionBuilder {
 }
 
 impl ConditionBuilder for StatefulSetConditionBuilder {
-    fn build_conditions(&self) -> Vec<ClusterCondition> {
-        vec![self.available()]
+    fn build_conditions(&self) -> ClusterConditionSet {
+        vec![self.available()].into()
     }
 }
 
diff --git a/src/status/mod.rs b/src/status/mod.rs
index eba7046fc..c8872532f 100644
--- a/src/status/mod.rs
+++ b/src/status/mod.rs
@@ -10,12 +10,68 @@ pub trait HasStatusCondition {
     fn conditions(&self) -> Vec<ClusterCondition>;
 }
 
+#[derive(Default)]
+pub struct ClusterConditionSet {
+    conditions: Vec<Option<ClusterCondition>>,
+}
+
+impl ClusterConditionSet {
+    pub fn new() -> Self {
+        ClusterConditionSet {
+            conditions: vec![None, None, None, None, None],
+        }
+    }
+    fn put(&mut self, condition: ClusterCondition) {
+        self.conditions[condition.type_ as usize] = Some(condition.clone());
+    }
+
+    pub fn merge(&mut self, other: &ClusterConditionSet) -> ClusterConditionSet {
+        let mut result = ClusterConditionSet::new();
+        for (old_condition, new_condition) in self.conditions.iter().zip(other.conditions.iter()) {
+            let c = match (old_condition, new_condition) {
+                (Some(old), Some(new)) => Some(merge_condition(old, new)),
+                (Some(old), None) => Some(old.clone()),
+                (None, Some(new)) => Some(new.clone()),
+                _ => None,
+            };
+            if c.is_some() {
+                result.put(c.unwrap());
+            }
+        }
+        result
+    }
+
+    pub fn to_vec(&self) -> Vec<ClusterCondition> {
+        self.conditions.clone().into_iter().flatten().collect()
+    }
+}
+
+impl From<Vec<ClusterCondition>> for ClusterConditionSet {
+    fn from(value: Vec<ClusterCondition>) -> Self {
+        let mut result = ClusterConditionSet::new();
+        for c in value {
+            result.put(c);
+        }
+        result
+    }
+}
 pub trait ConditionBuilder {
-    fn build_conditions(&self) -> Vec<ClusterCondition>;
+    fn build_conditions(&self) -> ClusterConditionSet;
 }
 
 #[derive(
-    Clone, Debug, Default, Deserialize, Eq, Hash, JsonSchema, Ord, PartialEq, PartialOrd, Serialize,
+    Clone,
+    Copy,
+    Debug,
+    Default,
+    Deserialize,
+    Eq,
+    Hash,
+    JsonSchema,
+    Ord,
+    PartialEq,
+    PartialOrd,
+    Serialize,
 )]
 #[serde(rename_all = "PascalCase")]
 pub enum ClusterConditionType {
@@ -78,58 +134,36 @@ pub fn compute_conditions<T: ConditionBuilder, R: HasStatusCondition>(
     resource: &R,
     condition_builder: &[T],
 ) -> Vec<ClusterCondition> {
-    let mut old_conditions: BTreeMap<ClusterConditionType, ClusterCondition> = resource
-        .conditions()
-        .into_iter()
-        .map(|c| (c.type_.clone(), c))
-        .collect();
+    let mut old_conditions: ClusterConditionSet = resource.conditions().into();
 
     for cb in condition_builder {
-        let new_conditions: HashMap<ClusterConditionType, ClusterCondition> = cb
-            .build_conditions()
-            .iter()
-            .map(|c| (c.type_.clone(), c.clone()))
-            .collect();
+        let new_conditions: ClusterConditionSet = cb.build_conditions();
 
-        for (condition_type, new_condition) in new_conditions {
-            let old_condition = old_conditions.get(&condition_type);
-            old_conditions.insert(
-                condition_type,
-                merge_condition(old_condition, new_condition),
-            );
-        }
+        old_conditions = old_conditions.merge(&new_conditions);
     }
 
-    old_conditions.values().cloned().collect()
+    old_conditions.to_vec()
 }
 
 fn merge_condition(
-    old_condition: Option<&ClusterCondition>,
-    new_condition: ClusterCondition,
+    old_condition: &ClusterCondition,
+    new_condition: &ClusterCondition,
 ) -> ClusterCondition {
     let now = Time(Utc::now());
-    if let Some(old_condition) = old_condition {
-        // No change in status -> update "last_update_time"
-        if old_condition.status == new_condition.status {
-            ClusterCondition {
-                last_update_time: Some(now),
-                last_transition_time: old_condition.last_transition_time.clone(),
-                ..new_condition
-            }
-            // Change in status -> set new message, status and update / transition times
-        } else {
-            ClusterCondition {
-                last_update_time: Some(now.clone()),
-                last_transition_time: Some(now),
-                ..new_condition
-            }
+    // No change in status -> update "last_update_time"
+    if old_condition.status == new_condition.status {
+        ClusterCondition {
+            last_update_time: Some(now),
+            last_transition_time: old_condition.last_transition_time.clone(),
+            ..new_condition.clone()
         }
-        // No condition available -> create
+        // Change in status -> set new message, status and update / transition times
     } else {
         ClusterCondition {
             last_update_time: Some(now.clone()),
             last_transition_time: Some(now),
-            ..new_condition
+            ..new_condition.clone()
         }
     }
+    // No condition available -> create
 }

From ccd7985d463d13ce937ab23a55be4be625f8c8f6 Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Wed, 22 Mar 2023 17:30:01 +0100
Subject: [PATCH 11/36] make ClusterConditionSet vector size depend on
 ClusterConditionType entries

---
 src/status/mod.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/status/mod.rs b/src/status/mod.rs
index c8872532f..4cd6a4cb0 100644
--- a/src/status/mod.rs
+++ b/src/status/mod.rs
@@ -4,7 +4,7 @@ use chrono::Utc;
 use k8s_openapi::apimachinery::pkg::apis::meta::v1::Time;
 use schemars::{self, JsonSchema};
 use serde::{Deserialize, Serialize};
-use std::collections::{BTreeMap, HashMap};
+use strum::EnumCount;
 
 pub trait HasStatusCondition {
     fn conditions(&self) -> Vec<ClusterCondition>;
@@ -18,9 +18,10 @@ pub struct ClusterConditionSet {
 impl ClusterConditionSet {
     pub fn new() -> Self {
         ClusterConditionSet {
-            conditions: vec![None, None, None, None, None],
+            conditions: Vec::with_capacity(ClusterConditionType::COUNT),
         }
     }
+
     fn put(&mut self, condition: ClusterCondition) {
         self.conditions[condition.type_ as usize] = Some(condition.clone());
     }
@@ -65,6 +66,7 @@ pub trait ConditionBuilder {
     Debug,
     Default,
     Deserialize,
+    EnumCount,
     Eq,
     Hash,
     JsonSchema,

From cfea0573d215ca0dda57e510af3ec7db52527d12 Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Wed, 22 Mar 2023 18:10:07 +0100
Subject: [PATCH 12/36] some refactoring

---
 src/status/mod.rs | 38 ++++++++++++++++++++++++--------------
 1 file changed, 24 insertions(+), 14 deletions(-)

diff --git a/src/status/mod.rs b/src/status/mod.rs
index 4cd6a4cb0..deb5b1541 100644
--- a/src/status/mod.rs
+++ b/src/status/mod.rs
@@ -6,10 +6,16 @@ use schemars::{self, JsonSchema};
 use serde::{Deserialize, Serialize};
 use strum::EnumCount;
 
+/// A **data structure** that contains a vector of `ClusterCondition`s.
+/// Should usually be the status of a `CustomResource`.
 pub trait HasStatusCondition {
     fn conditions(&self) -> Vec<ClusterCondition>;
 }
 
+pub trait ConditionBuilder {
+    fn build_conditions(&self) -> ClusterConditionSet;
+}
+
 #[derive(Default)]
 pub struct ClusterConditionSet {
     conditions: Vec<Option<ClusterCondition>>,
@@ -18,32 +24,40 @@ pub struct ClusterConditionSet {
 impl ClusterConditionSet {
     pub fn new() -> Self {
         ClusterConditionSet {
+            // We use this as a quasi "Set" where each ClusterConditionType has its fixed position
+            // This ensures ordering, and in contrast to e.g. a
+            // BTreeMap<ClusterConditionType, ClusterCondition>, prevents shenanigans like adding a
+            // ClusterCondition (as value) with a different ClusterConditionType than its key.
+            // See "put".
             conditions: Vec::with_capacity(ClusterConditionType::COUNT),
         }
     }
 
+    /// Adds a ClusterCondition to its assigned index in the conditions vector.
     fn put(&mut self, condition: ClusterCondition) {
-        self.conditions[condition.type_ as usize] = Some(condition.clone());
+        let index = condition.type_ as usize;
+        self.conditions[index] = Some(condition);
     }
 
     pub fn merge(&mut self, other: &ClusterConditionSet) -> ClusterConditionSet {
         let mut result = ClusterConditionSet::new();
         for (old_condition, new_condition) in self.conditions.iter().zip(other.conditions.iter()) {
-            let c = match (old_condition, new_condition) {
+            if let Some(condition) = match (old_condition, new_condition) {
                 (Some(old), Some(new)) => Some(merge_condition(old, new)),
                 (Some(old), None) => Some(old.clone()),
                 (None, Some(new)) => Some(new.clone()),
                 _ => None,
+            } {
+                result.put(condition);
             };
-            if c.is_some() {
-                result.put(c.unwrap());
-            }
         }
         result
     }
+}
 
-    pub fn to_vec(&self) -> Vec<ClusterCondition> {
-        self.conditions.clone().into_iter().flatten().collect()
+impl From<ClusterConditionSet> for Vec<ClusterCondition> {
+    fn from(value: ClusterConditionSet) -> Self {
+        value.conditions.into_iter().flatten().collect()
     }
 }
 
@@ -56,9 +70,6 @@ impl From<Vec<ClusterCondition>> for ClusterConditionSet {
         result
     }
 }
-pub trait ConditionBuilder {
-    fn build_conditions(&self) -> ClusterConditionSet;
-}
 
 #[derive(
     Clone,
@@ -144,7 +155,7 @@ pub fn compute_conditions<T: ConditionBuilder, R: HasStatusCondition>(
         old_conditions = old_conditions.merge(&new_conditions);
     }
 
-    old_conditions.to_vec()
+    old_conditions.into()
 }
 
 fn merge_condition(
@@ -152,14 +163,14 @@ fn merge_condition(
     new_condition: &ClusterCondition,
 ) -> ClusterCondition {
     let now = Time(Utc::now());
-    // No change in status -> update "last_update_time"
+    // No change in status -> update "last_update_time" and keep "last_transition_time"
     if old_condition.status == new_condition.status {
         ClusterCondition {
             last_update_time: Some(now),
             last_transition_time: old_condition.last_transition_time.clone(),
             ..new_condition.clone()
         }
-        // Change in status -> set new message, status and update / transition times
+    // Change in status -> set new "last_update_time" and "last_transition_time"
     } else {
         ClusterCondition {
             last_update_time: Some(now.clone()),
@@ -167,5 +178,4 @@ fn merge_condition(
             ..new_condition.clone()
         }
     }
-    // No condition available -> create
 }

From 26d6b44141fe9c7173485028a90cf8e4c4592172 Mon Sep 17 00:00:00 2001
From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com>
Date: Wed, 22 Mar 2023 18:16:05 +0100
Subject: [PATCH 13/36] added one test

---
 src/status/mod.rs | 51 ++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 50 insertions(+), 1 deletion(-)

diff --git a/src/status/mod.rs b/src/status/mod.rs
index deb5b1541..eff099bb9 100644
--- a/src/status/mod.rs
+++ b/src/status/mod.rs
@@ -29,7 +29,7 @@ impl ClusterConditionSet {
             // BTreeMap<ClusterConditionType, ClusterCondition>, prevents shenanigans like adding a
             // ClusterCondition (as value) with a different ClusterConditionType than its key.
             // See "put".
-            conditions: Vec::with_capacity(ClusterConditionType::COUNT),
+            conditions: (0..ClusterConditionType::COUNT).map(|_| None).collect(),
         }
     }
 
@@ -179,3 +179,52 @@ fn merge_condition(
         }
     }
 }
+#[cfg(test)]
+mod test {
+    use crate::status::*;
+
+    struct TestResource {}
+    impl HasStatusCondition for TestResource {
+        fn conditions(&self) -> Vec<ClusterCondition> {
+            vec![ClusterCondition {
+                type_: crate::status::ClusterConditionType::Available,
+                status: crate::status::ClusterConditionStatus::False,
+                message: Some("OMG! Thing is broken!".into()),
+                ..ClusterCondition::default()
+            }]
+        }
+    }
+    struct TestConditionBuilder {}
+    impl ConditionBuilder for TestConditionBuilder {
+        fn build_conditions(&self) -> ClusterConditionSet {
+            vec![ClusterCondition {
+                type_: crate::status::ClusterConditionType::Available,
+                status: crate::status::ClusterConditionStatus::True,
+                message: Some("Relax. Everything is fine.".into()),
+                ..ClusterCondition::default()
+            }]
+            .into()
+        }
+    }
+    #[test]
+    pub fn test_compute_conditions_with_transition() {
+        let resource = TestResource {};
+        let condition_builders = vec![TestConditionBuilder {}];
+        let got = compute_conditions(&resource, &condition_builders)
+            .get(0)
+            .cloned()
+            .unwrap();
+        let expected = ClusterCondition {
+            type_: crate::status::ClusterConditionType::Available,
+            status: crate::status::ClusterConditionStatus::True,
+            message: Some("Relax. Everything is fine.".into()),
+            ..ClusterCondition::default()
+        };
+
+        assert_eq!(got.type_, expected.type_);
+        assert_eq!(got.status, expected.status);
+        assert_eq!(got.message, expected.message);
+        assert_eq!(got.last_transition_time, got.last_update_time);
+        assert!(got.last_transition_time.is_some());
+    }
+}

From 8788e63146a53806d7a49f790c5b3cccb4f0be00 Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Wed, 22 Mar 2023 18:19:46 +0100
Subject: [PATCH 14/36] removed clones

---
 src/status/mod.rs | 165 ++++++++++++++++++++++++----------------------
 1 file changed, 86 insertions(+), 79 deletions(-)

diff --git a/src/status/mod.rs b/src/status/mod.rs
index deb5b1541..bdaa4f738 100644
--- a/src/status/mod.rs
+++ b/src/status/mod.rs
@@ -16,59 +16,26 @@ pub trait ConditionBuilder {
     fn build_conditions(&self) -> ClusterConditionSet;
 }
 
-#[derive(Default)]
-pub struct ClusterConditionSet {
-    conditions: Vec<Option<ClusterCondition>>,
-}
-
-impl ClusterConditionSet {
-    pub fn new() -> Self {
-        ClusterConditionSet {
-            // We use this as a quasi "Set" where each ClusterConditionType has its fixed position
-            // This ensures ordering, and in contrast to e.g. a
-            // BTreeMap<ClusterConditionType, ClusterCondition>, prevents shenanigans like adding a
-            // ClusterCondition (as value) with a different ClusterConditionType than its key.
-            // See "put".
-            conditions: Vec::with_capacity(ClusterConditionType::COUNT),
-        }
-    }
-
-    /// Adds a ClusterCondition to its assigned index in the conditions vector.
-    fn put(&mut self, condition: ClusterCondition) {
-        let index = condition.type_ as usize;
-        self.conditions[index] = Some(condition);
-    }
-
-    pub fn merge(&mut self, other: &ClusterConditionSet) -> ClusterConditionSet {
-        let mut result = ClusterConditionSet::new();
-        for (old_condition, new_condition) in self.conditions.iter().zip(other.conditions.iter()) {
-            if let Some(condition) = match (old_condition, new_condition) {
-                (Some(old), Some(new)) => Some(merge_condition(old, new)),
-                (Some(old), None) => Some(old.clone()),
-                (None, Some(new)) => Some(new.clone()),
-                _ => None,
-            } {
-                result.put(condition);
-            };
-        }
-        result
-    }
-}
-
-impl From<ClusterConditionSet> for Vec<ClusterCondition> {
-    fn from(value: ClusterConditionSet) -> Self {
-        value.conditions.into_iter().flatten().collect()
-    }
-}
-
-impl From<Vec<ClusterCondition>> for ClusterConditionSet {
-    fn from(value: Vec<ClusterCondition>) -> Self {
-        let mut result = ClusterConditionSet::new();
-        for c in value {
-            result.put(c);
-        }
-        result
-    }
+#[derive(Clone, Debug, Default, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ClusterCondition {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Last time the condition transitioned from one status to another.
+    pub last_transition_time: Option<Time>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// The last time this condition was updated.
+    pub last_update_time: Option<Time>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// A human readable message indicating details about the transition.
+    pub message: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// The reason for the condition's last transition.
+    pub reason: Option<String>,
+    /// Status of the condition, one of True, False, Unknown.
+    pub status: ClusterConditionStatus,
+    /// Type of deployment condition.
+    #[serde(rename = "type")]
+    pub type_: ClusterConditionType,
 }
 
 #[derive(
@@ -121,26 +88,66 @@ pub enum ClusterConditionStatus {
     Unknown,
 }
 
-#[derive(Clone, Debug, Default, PartialEq, Eq, JsonSchema, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ClusterCondition {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    /// Last time the condition transitioned from one status to another.
-    pub last_transition_time: Option<Time>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    /// The last time this condition was updated.
-    pub last_update_time: Option<Time>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    /// A human readable message indicating details about the transition.
-    pub message: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    /// The reason for the condition's last transition.
-    pub reason: Option<String>,
-    /// Status of the condition, one of True, False, Unknown.
-    pub status: ClusterConditionStatus,
-    /// Type of deployment condition.
-    #[serde(rename = "type")]
-    pub type_: ClusterConditionType,
+#[derive(Default)]
+/// Helper to order and merge `ClusterCondition` objects.
+pub struct ClusterConditionSet {
+    conditions: Vec<Option<ClusterCondition>>,
+}
+
+impl ClusterConditionSet {
+    pub fn new() -> Self {
+        ClusterConditionSet {
+            // We use this as a quasi "Set" where each ClusterConditionType has its fixed position
+            // This ensures ordering, and in contrast to e.g. a
+            // BTreeMap<ClusterConditionType, ClusterCondition>, prevents shenanigans like adding a
+            // ClusterCondition (as value) with a different ClusterConditionType than its key.
+            // See "put".
+            conditions: Vec::with_capacity(ClusterConditionType::COUNT),
+        }
+    }
+
+    /// Adds a ClusterCondition to its assigned index in the conditions vector.
+    fn put(&mut self, condition: ClusterCondition) {
+        let index = condition.type_ as usize;
+        self.conditions[index] = Some(condition);
+    }
+
+    pub fn merge(self, other: ClusterConditionSet) -> ClusterConditionSet {
+        let mut result = ClusterConditionSet::new();
+
+        for (old_condition, new_condition) in self
+            .conditions
+            .into_iter()
+            .zip(other.conditions.into_iter())
+        {
+            if let Some(condition) = match (old_condition, new_condition) {
+                (Some(old), Some(new)) => Some(merge_condition(old, new)),
+                (Some(old), None) => Some(old),
+                (None, Some(new)) => Some(new),
+                _ => None,
+            } {
+                result.put(condition);
+            };
+        }
+
+        result
+    }
+}
+
+impl From<ClusterConditionSet> for Vec<ClusterCondition> {
+    fn from(value: ClusterConditionSet) -> Self {
+        value.conditions.into_iter().flatten().collect()
+    }
+}
+
+impl From<Vec<ClusterCondition>> for ClusterConditionSet {
+    fn from(value: Vec<ClusterCondition>) -> Self {
+        let mut result = ClusterConditionSet::new();
+        for c in value {
+            result.put(c);
+        }
+        result
+    }
 }
 
 pub fn compute_conditions<T: ConditionBuilder, R: HasStatusCondition>(
@@ -152,30 +159,30 @@ pub fn compute_conditions<T: ConditionBuilder, R: HasStatusCondition>(
     for cb in condition_builder {
         let new_conditions: ClusterConditionSet = cb.build_conditions();
 
-        old_conditions = old_conditions.merge(&new_conditions);
+        old_conditions = old_conditions.merge(new_conditions);
     }
 
     old_conditions.into()
 }
 
 fn merge_condition(
-    old_condition: &ClusterCondition,
-    new_condition: &ClusterCondition,
+    old_condition: ClusterCondition,
+    new_condition: ClusterCondition,
 ) -> ClusterCondition {
     let now = Time(Utc::now());
     // No change in status -> update "last_update_time" and keep "last_transition_time"
     if old_condition.status == new_condition.status {
         ClusterCondition {
             last_update_time: Some(now),
-            last_transition_time: old_condition.last_transition_time.clone(),
-            ..new_condition.clone()
+            last_transition_time: old_condition.last_transition_time,
+            ..new_condition
         }
     // Change in status -> set new "last_update_time" and "last_transition_time"
     } else {
         ClusterCondition {
             last_update_time: Some(now.clone()),
             last_transition_time: Some(now),
-            ..new_condition.clone()
+            ..new_condition
         }
     }
 }

From 3acce6f17fec8cb645ba4ec6156985fe500a31e8 Mon Sep 17 00:00:00 2001
From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com>
Date: Thu, 23 Mar 2023 09:13:51 +0100
Subject: [PATCH 15/36] Use vec! macro to initialize conditions.

---
 src/status/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/status/mod.rs b/src/status/mod.rs
index 39f49766e..de0946b81 100644
--- a/src/status/mod.rs
+++ b/src/status/mod.rs
@@ -102,7 +102,7 @@ impl ClusterConditionSet {
             // BTreeMap<ClusterConditionType, ClusterCondition>, prevents shenanigans like adding a
             // ClusterCondition (as value) with a different ClusterConditionType than its key.
             // See "put".
-            conditions: (0..ClusterConditionType::COUNT).map(|_| None).collect(),
+            conditions: vec![None; ClusterConditionType::COUNT],
         }
     }
 

From f20a05e21336dd510eefb03e694e6b9524c12566 Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Thu, 23 Mar 2023 10:10:46 +0100
Subject: [PATCH 16/36] refactoring & comments

---
 src/status/mod.rs | 163 +++++++++++++++++++++++++++++++++-------------
 1 file changed, 116 insertions(+), 47 deletions(-)

diff --git a/src/status/mod.rs b/src/status/mod.rs
index de0946b81..9eda070cc 100644
--- a/src/status/mod.rs
+++ b/src/status/mod.rs
@@ -12,10 +12,77 @@ pub trait HasStatusCondition {
     fn conditions(&self) -> Vec<ClusterCondition>;
 }
 
+/// A **data structure** that produces a `ClusterConditionSet` containing all required
+/// `ClusterCondition`s.
 pub trait ConditionBuilder {
     fn build_conditions(&self) -> ClusterConditionSet;
 }
 
+/// Computes the final conditions to be set in the operator status condition field.
+///
+/// # Arguments
+///
+/// * `resource` - A cluster resource or status implementing [`HasStatusCondition`] in order to
+///    retrieve the "current" conditions set in the cluster. This is required to  compute
+///    condition change and set proper update / transition times.
+/// * `condition_builders` - A slice of structs implementing [`ConditionBuilder`]. This can be a
+///    one of the predefined ConditionBuilders like `DaemonSetConditionBuilder` or a custom
+///    implementation.
+///                    
+/// # Examples
+///
+/// ```
+/// use stackable_operator::status::{ClusterCondition, ConditionBuilder, HasStatusCondition};
+/// use stackable_operator::status::condition::daemonset::DaemonSetConditionBuilder;
+/// use stackable_operator::status::condition::statefulset::StatefulSetConditionBuilder;
+/// use k8s_openapi::api::apps::v1::{DaemonSet, StatefulSet};
+///
+/// struct ClusterStatus {
+///     conditions: Vec<ClusterCondition>
+/// }
+///
+/// impl HasStatusCondition for ClusterStatus {
+///     fn conditions(&self) -> Vec<ClusterCondition> {
+///         self.conditions.clone()
+///     }
+/// }
+///
+/// let mut daemonset_condition_builder = DaemonSetConditionBuilder::default();
+/// daemonset_condition_builder.add(DaemonSet::default());
+///
+/// let mut statefulset_condition_builder = StatefulSetConditionBuilder::default();
+/// statefulset_condition_builder.add(StatefulSet::default());
+///
+/// let old_status = ClusterStatus {
+///     conditions: vec![]
+/// };
+///
+/// let new_status = ClusterStatus {
+///     conditions: stackable_operator::status::compute_conditions(&old_status,
+///         &[
+///             &daemonset_condition_builder as &dyn ConditionBuilder,
+///             &statefulset_condition_builder as &dyn ConditionBuilder
+///         ]
+///     )
+/// };
+///
+/// ```
+///
+pub fn compute_conditions<T: HasStatusCondition>(
+    resource: &T,
+    condition_builders: &[&dyn ConditionBuilder],
+) -> Vec<ClusterCondition> {
+    let mut old_conditions: ClusterConditionSet = resource.conditions().into();
+
+    for cb in condition_builders {
+        let new_conditions: ClusterConditionSet = cb.build_conditions();
+
+        old_conditions = old_conditions.merge(new_conditions);
+    }
+
+    old_conditions.into()
+}
+
 #[derive(Clone, Debug, Default, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ClusterCondition {
@@ -89,7 +156,7 @@ pub enum ClusterConditionStatus {
 }
 
 #[derive(Default)]
-/// Helper to order and merge `ClusterCondition` objects.
+/// Helper struct to order and merge `ClusterCondition` objects.
 pub struct ClusterConditionSet {
     conditions: Vec<Option<ClusterCondition>>,
 }
@@ -106,12 +173,13 @@ impl ClusterConditionSet {
         }
     }
 
-    /// Adds a ClusterCondition to its assigned index in the conditions vector.
+    /// Adds a [`ClusterCondition`] to its assigned index in the conditions vector.
     fn put(&mut self, condition: ClusterCondition) {
         let index = condition.type_ as usize;
         self.conditions[index] = Some(condition);
     }
 
+    /// Merges two [`ClusterConditionSet`]s.
     pub fn merge(self, other: ClusterConditionSet) -> ClusterConditionSet {
         let mut result = ClusterConditionSet::new();
 
@@ -121,7 +189,7 @@ impl ClusterConditionSet {
             .zip(other.conditions.into_iter())
         {
             if let Some(condition) = match (old_condition, new_condition) {
-                (Some(old), Some(new)) => Some(merge_condition(old, new)),
+                (Some(old), Some(new)) => Some(Self::merge_condition(old, new)),
                 (Some(old), None) => Some(old),
                 (None, Some(new)) => Some(new),
                 _ => None,
@@ -132,6 +200,28 @@ impl ClusterConditionSet {
 
         result
     }
+
+    fn merge_condition(
+        old_condition: ClusterCondition,
+        new_condition: ClusterCondition,
+    ) -> ClusterCondition {
+        let now = Time(Utc::now());
+        // No change in status -> update "last_update_time" and keep "last_transition_time"
+        if old_condition.status == new_condition.status {
+            ClusterCondition {
+                last_update_time: Some(now),
+                last_transition_time: old_condition.last_transition_time,
+                ..new_condition
+            }
+            // Change in status -> set new "last_update_time" and "last_transition_time"
+        } else {
+            ClusterCondition {
+                last_update_time: Some(now.clone()),
+                last_transition_time: Some(now),
+                ..new_condition
+            }
+        }
+    }
 }
 
 impl From<ClusterConditionSet> for Vec<ClusterCondition> {
@@ -150,42 +240,6 @@ impl From<Vec<ClusterCondition>> for ClusterConditionSet {
     }
 }
 
-pub fn compute_conditions<T: ConditionBuilder, R: HasStatusCondition>(
-    resource: &R,
-    condition_builder: &[T],
-) -> Vec<ClusterCondition> {
-    let mut old_conditions: ClusterConditionSet = resource.conditions().into();
-
-    for cb in condition_builder {
-        let new_conditions: ClusterConditionSet = cb.build_conditions();
-
-        old_conditions = old_conditions.merge(new_conditions);
-    }
-
-    old_conditions.into()
-}
-
-fn merge_condition(
-    old_condition: ClusterCondition,
-    new_condition: ClusterCondition,
-) -> ClusterCondition {
-    let now = Time(Utc::now());
-    // No change in status -> update "last_update_time" and keep "last_transition_time"
-    if old_condition.status == new_condition.status {
-        ClusterCondition {
-            last_update_time: Some(now),
-            last_transition_time: old_condition.last_transition_time,
-            ..new_condition
-        }
-    // Change in status -> set new "last_update_time" and "last_transition_time"
-    } else {
-        ClusterCondition {
-            last_update_time: Some(now.clone()),
-            last_transition_time: Some(now),
-            ..new_condition
-        }
-    }
-}
 #[cfg(test)]
 mod test {
     use crate::status::*;
@@ -194,36 +248,51 @@ mod test {
     impl HasStatusCondition for TestResource {
         fn conditions(&self) -> Vec<ClusterCondition> {
             vec![ClusterCondition {
-                type_: crate::status::ClusterConditionType::Available,
-                status: crate::status::ClusterConditionStatus::False,
+                type_: ClusterConditionType::Available,
+                status: ClusterConditionStatus::False,
                 message: Some("OMG! Thing is broken!".into()),
                 ..ClusterCondition::default()
             }]
         }
     }
+
     struct TestConditionBuilder {}
+    struct TestConditionBuilder2 {}
+
     impl ConditionBuilder for TestConditionBuilder {
         fn build_conditions(&self) -> ClusterConditionSet {
             vec![ClusterCondition {
-                type_: crate::status::ClusterConditionType::Available,
-                status: crate::status::ClusterConditionStatus::True,
+                type_: ClusterConditionType::Available,
+                status: ClusterConditionStatus::True,
                 message: Some("Relax. Everything is fine.".into()),
                 ..ClusterCondition::default()
             }]
             .into()
         }
     }
+
+    impl ConditionBuilder for TestConditionBuilder2 {
+        fn build_conditions(&self) -> ClusterConditionSet {
+            vec![].into()
+        }
+    }
+
     #[test]
     pub fn test_compute_conditions_with_transition() {
         let resource = TestResource {};
-        let condition_builders = vec![TestConditionBuilder {}];
-        let got = compute_conditions(&resource, &condition_builders)
+        let condition_builders = &[
+            &TestConditionBuilder {} as &dyn ConditionBuilder,
+            &TestConditionBuilder2 {} as &dyn ConditionBuilder,
+        ];
+
+        let got = compute_conditions(&resource, condition_builders)
             .get(0)
             .cloned()
             .unwrap();
+
         let expected = ClusterCondition {
-            type_: crate::status::ClusterConditionType::Available,
-            status: crate::status::ClusterConditionStatus::True,
+            type_: ClusterConditionType::Available,
+            status: ClusterConditionStatus::True,
             message: Some("Relax. Everything is fine.".into()),
             ..ClusterCondition::default()
         };

From b2ba70af5ea9987f2589b995f88a36eb4e16f8a4 Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Thu, 23 Mar 2023 10:25:10 +0100
Subject: [PATCH 17/36] move status condition definitions to correct mod
 definition

---
 src/status/condition/daemonset.rs   |  34 ++--
 src/status/condition/mod.rs         | 303 +++++++++++++++++++++++++++
 src/status/condition/statefulset.rs |  44 ++--
 src/status/mod.rs                   | 305 ----------------------------
 4 files changed, 344 insertions(+), 342 deletions(-)

diff --git a/src/status/condition/daemonset.rs b/src/status/condition/daemonset.rs
index 450ed10d6..4d0f07c3f 100644
--- a/src/status/condition/daemonset.rs
+++ b/src/status/condition/daemonset.rs
@@ -1,4 +1,4 @@
-use crate::status::{
+use crate::status::condition::{
     ClusterCondition, ClusterConditionSet, ClusterConditionStatus, ClusterConditionType,
     ConditionBuilder,
 };
@@ -7,6 +7,8 @@ use k8s_openapi::api::apps::v1::DaemonSet;
 use kube::ResourceExt;
 use std::cmp;
 
+/// Default implementation to build [`crate::status::condition::ClusterCondition`]s for
+/// `DaemonSet` resources.
 #[derive(Default)]
 pub struct DaemonSetConditionBuilder {
     daemon_sets: Vec<DaemonSet>,
@@ -22,7 +24,7 @@ impl DaemonSetConditionBuilder {
         let mut unavailable_ds = vec![];
 
         for ds in &self.daemon_sets {
-            let current_status = daemon_set_available(ds);
+            let current_status = Self::daemon_set_available(ds);
 
             if current_status != ClusterConditionStatus::True {
                 unavailable_ds.push(ds.name_any())
@@ -50,6 +52,20 @@ impl DaemonSetConditionBuilder {
             last_update_time: None,
         }
     }
+
+    fn daemon_set_available(ds: &DaemonSet) -> ClusterConditionStatus {
+        let number_unavailable = ds
+            .status
+            .as_ref()
+            .and_then(|status| status.number_unavailable)
+            .unwrap_or_default();
+
+        if number_unavailable == 0 {
+            ClusterConditionStatus::True
+        } else {
+            ClusterConditionStatus::False
+        }
+    }
 }
 
 impl ConditionBuilder for DaemonSetConditionBuilder {
@@ -57,17 +73,3 @@ impl ConditionBuilder for DaemonSetConditionBuilder {
         vec![self.available()].into()
     }
 }
-
-fn daemon_set_available(ds: &DaemonSet) -> ClusterConditionStatus {
-    let number_unavailable = ds
-        .status
-        .as_ref()
-        .and_then(|status| status.number_unavailable)
-        .unwrap_or_default();
-
-    if number_unavailable == 0 {
-        ClusterConditionStatus::True
-    } else {
-        ClusterConditionStatus::False
-    }
-}
diff --git a/src/status/condition/mod.rs b/src/status/condition/mod.rs
index 7a3d572ad..7ffef18d1 100644
--- a/src/status/condition/mod.rs
+++ b/src/status/condition/mod.rs
@@ -1,2 +1,305 @@
 pub mod daemonset;
 pub mod statefulset;
+
+use chrono::Utc;
+use k8s_openapi::apimachinery::pkg::apis::meta::v1::Time;
+use schemars::{self, JsonSchema};
+use serde::{Deserialize, Serialize};
+use strum::EnumCount;
+
+/// A **data structure** that contains a vector of `ClusterCondition`s.
+/// Should usually be implemented on the status of a `CustomResource` or the `CustomResource` itself.
+pub trait HasStatusCondition {
+    fn conditions(&self) -> Vec<ClusterCondition>;
+}
+
+/// A **data structure** that produces a `ClusterConditionSet` containing all required
+/// `ClusterCondition`s.
+pub trait ConditionBuilder {
+    fn build_conditions(&self) -> ClusterConditionSet;
+}
+
+/// Computes the final conditions to be set in the operator status condition field.
+///
+/// # Arguments
+///
+/// * `resource` - A cluster resource or status implementing [`HasStatusCondition`] in order to
+///    retrieve the "current" conditions set in the cluster. This is required to  compute
+///    condition change and set proper update / transition times.
+/// * `condition_builders` - A slice of structs implementing [`ConditionBuilder`]. This can be a
+///    one of the predefined ConditionBuilders like `DaemonSetConditionBuilder` or a custom
+///    implementation for special resources or different behavior.
+///
+/// # Examples
+/// ```
+/// use stackable_operator::status::condition::daemonset::DaemonSetConditionBuilder;
+/// use stackable_operator::status::condition::statefulset::StatefulSetConditionBuilder;
+/// use k8s_openapi::api::apps::v1::{DaemonSet, StatefulSet};
+/// use stackable_operator::status::condition::{ClusterCondition, ConditionBuilder, HasStatusCondition};
+///
+/// struct ClusterStatus {
+///     conditions: Vec<ClusterCondition>
+/// }
+///
+/// impl HasStatusCondition for ClusterStatus {
+///     fn conditions(&self) -> Vec<ClusterCondition> {
+///         self.conditions.clone()
+///     }
+/// }
+///
+/// let mut daemonset_condition_builder = DaemonSetConditionBuilder::default();
+/// daemonset_condition_builder.add(DaemonSet::default());
+///
+/// let mut statefulset_condition_builder = StatefulSetConditionBuilder::default();
+/// statefulset_condition_builder.add(StatefulSet::default());
+///
+/// let old_status = ClusterStatus {
+///     conditions: vec![]
+/// };
+///
+/// let new_status = ClusterStatus {
+///     conditions: stackable_operator::status::compute_conditions(&old_status,
+///         &[
+///             &daemonset_condition_builder as &dyn ConditionBuilder,
+///             &statefulset_condition_builder as &dyn ConditionBuilder
+///         ]
+///     )
+/// };
+///
+/// ```
+pub fn compute_conditions<T: HasStatusCondition>(
+    resource: &T,
+    condition_builders: &[&dyn ConditionBuilder],
+) -> Vec<ClusterCondition> {
+    let mut old_conditions: ClusterConditionSet = resource.conditions().into();
+
+    for cb in condition_builders {
+        let new_conditions: ClusterConditionSet = cb.build_conditions();
+
+        old_conditions = old_conditions.merge(new_conditions);
+    }
+
+    old_conditions.into()
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ClusterCondition {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Last time the condition transitioned from one status to another.
+    pub last_transition_time: Option<Time>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// The last time this condition was updated.
+    pub last_update_time: Option<Time>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// A human readable message indicating details about the transition.
+    pub message: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    /// The reason for the condition's last transition.
+    pub reason: Option<String>,
+    /// Status of the condition, one of True, False, Unknown.
+    pub status: ClusterConditionStatus,
+    /// Type of deployment condition.
+    #[serde(rename = "type")]
+    pub type_: ClusterConditionType,
+}
+
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Default,
+    Deserialize,
+    EnumCount,
+    Eq,
+    Hash,
+    JsonSchema,
+    Ord,
+    PartialEq,
+    PartialOrd,
+    Serialize,
+)]
+#[serde(rename_all = "PascalCase")]
+pub enum ClusterConditionType {
+    #[default]
+    /// Available indicates that the binary maintained by the operator (eg: zookeeper for the
+    /// zookeeper-operator), is functional and available in the cluster.
+    Available,
+    /// Degraded indicates that the operand is not functioning completely. An example of a degraded
+    /// state would be if there should be 5 copies of the operand running but only 4 are running.
+    /// It may still be available, but it is degraded.
+    Degraded,
+    /// Progressing indicates that the operator is actively making changes to the binary maintained
+    /// by the operator (eg: zookeeper for the zookeeper-operator).
+    Progressing,
+    /// Paused indicates that the operator is not reconciling the cluster. This may be used for
+    /// debugging or operator updating.
+    Paused,
+    /// Stopped indicates that all the cluster replicas are scaled down to 0. All resources (e.g.
+    /// ConfigMaps, Services etc.) are kept.
+    Stopped,
+}
+
+#[derive(
+    Clone, Debug, Default, Deserialize, Eq, JsonSchema, Ord, PartialEq, PartialOrd, Serialize,
+)]
+#[serde(rename_all = "PascalCase")]
+pub enum ClusterConditionStatus {
+    #[default]
+    /// True means a resource is in the condition.
+    True,
+    /// False means a resource is not in the condition.
+    False,
+    /// Unknown means kubernetes cannot decide if a resource is in the condition or not.
+    Unknown,
+}
+
+#[derive(Default)]
+/// Helper struct to order and merge `ClusterCondition` objects.
+pub struct ClusterConditionSet {
+    conditions: Vec<Option<ClusterCondition>>,
+}
+
+impl ClusterConditionSet {
+    pub fn new() -> Self {
+        ClusterConditionSet {
+            // We use this as a quasi "Set" where each ClusterConditionType has its fixed position
+            // This ensures ordering, and in contrast to e.g. a
+            // BTreeMap<ClusterConditionType, ClusterCondition>, prevents shenanigans like adding a
+            // ClusterCondition (as value) with a different ClusterConditionType than its key.
+            // See "put".
+            conditions: vec![None; ClusterConditionType::COUNT],
+        }
+    }
+
+    /// Adds a [`ClusterCondition`] to its assigned index in the conditions vector.
+    fn put(&mut self, condition: ClusterCondition) {
+        let index = condition.type_ as usize;
+        self.conditions[index] = Some(condition);
+    }
+
+    /// Merges two [`ClusterConditionSet`]s.
+    pub fn merge(self, other: ClusterConditionSet) -> ClusterConditionSet {
+        let mut result = ClusterConditionSet::new();
+
+        for (old_condition, new_condition) in self
+            .conditions
+            .into_iter()
+            .zip(other.conditions.into_iter())
+        {
+            if let Some(condition) = match (old_condition, new_condition) {
+                (Some(old), Some(new)) => Some(Self::merge_condition(old, new)),
+                (Some(old), None) => Some(old),
+                (None, Some(new)) => Some(new),
+                _ => None,
+            } {
+                result.put(condition);
+            };
+        }
+
+        result
+    }
+
+    fn merge_condition(
+        old_condition: ClusterCondition,
+        new_condition: ClusterCondition,
+    ) -> ClusterCondition {
+        let now = Time(Utc::now());
+        // No change in status -> update "last_update_time" and keep "last_transition_time"
+        if old_condition.status == new_condition.status {
+            ClusterCondition {
+                last_update_time: Some(now),
+                last_transition_time: old_condition.last_transition_time,
+                ..new_condition
+            }
+            // Change in status -> set new "last_update_time" and "last_transition_time"
+        } else {
+            ClusterCondition {
+                last_update_time: Some(now.clone()),
+                last_transition_time: Some(now),
+                ..new_condition
+            }
+        }
+    }
+}
+
+impl From<ClusterConditionSet> for Vec<ClusterCondition> {
+    fn from(value: ClusterConditionSet) -> Self {
+        value.conditions.into_iter().flatten().collect()
+    }
+}
+
+impl From<Vec<ClusterCondition>> for ClusterConditionSet {
+    fn from(value: Vec<ClusterCondition>) -> Self {
+        let mut result = ClusterConditionSet::new();
+        for c in value {
+            result.put(c);
+        }
+        result
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    struct TestResource {}
+    impl HasStatusCondition for TestResource {
+        fn conditions(&self) -> Vec<ClusterCondition> {
+            vec![ClusterCondition {
+                type_: ClusterConditionType::Available,
+                status: ClusterConditionStatus::False,
+                message: Some("OMG! Thing is broken!".into()),
+                ..ClusterCondition::default()
+            }]
+        }
+    }
+
+    struct TestConditionBuilder {}
+    struct TestConditionBuilder2 {}
+
+    impl ConditionBuilder for TestConditionBuilder {
+        fn build_conditions(&self) -> ClusterConditionSet {
+            vec![ClusterCondition {
+                type_: ClusterConditionType::Available,
+                status: ClusterConditionStatus::True,
+                message: Some("Relax. Everything is fine.".into()),
+                ..ClusterCondition::default()
+            }]
+            .into()
+        }
+    }
+
+    impl ConditionBuilder for TestConditionBuilder2 {
+        fn build_conditions(&self) -> ClusterConditionSet {
+            vec![].into()
+        }
+    }
+
+    #[test]
+    pub fn test_compute_conditions_with_transition() {
+        let resource = TestResource {};
+        let condition_builders = &[
+            &TestConditionBuilder {} as &dyn ConditionBuilder,
+            &TestConditionBuilder2 {} as &dyn ConditionBuilder,
+        ];
+
+        let got = compute_conditions(&resource, condition_builders)
+            .get(0)
+            .cloned()
+            .unwrap();
+
+        let expected = ClusterCondition {
+            type_: ClusterConditionType::Available,
+            status: ClusterConditionStatus::True,
+            message: Some("Relax. Everything is fine.".into()),
+            ..ClusterCondition::default()
+        };
+
+        assert_eq!(got.type_, expected.type_);
+        assert_eq!(got.status, expected.status);
+        assert_eq!(got.message, expected.message);
+        assert_eq!(got.last_transition_time, got.last_update_time);
+        assert!(got.last_transition_time.is_some());
+    }
+}
diff --git a/src/status/condition/statefulset.rs b/src/status/condition/statefulset.rs
index 1d3eac526..3a1b1940e 100644
--- a/src/status/condition/statefulset.rs
+++ b/src/status/condition/statefulset.rs
@@ -1,4 +1,4 @@
-use crate::status::{
+use crate::status::condition::{
     ClusterCondition, ClusterConditionSet, ClusterConditionStatus, ClusterConditionType,
     ConditionBuilder,
 };
@@ -7,6 +7,8 @@ use k8s_openapi::api::apps::v1::StatefulSet;
 use kube::ResourceExt;
 use std::cmp;
 
+/// Default implementation to build [`crate::status::condition::ClusterCondition`]s for
+/// `StatefulSet` resources.
 #[derive(Default)]
 pub struct StatefulSetConditionBuilder {
     stateful_sets: Vec<StatefulSet>,
@@ -21,7 +23,7 @@ impl StatefulSetConditionBuilder {
         let mut available = ClusterConditionStatus::True;
         let mut unavailable_sts = vec![];
         for sts in &self.stateful_sets {
-            let current_status = stateful_set_available(sts);
+            let current_status = Self::stateful_set_available(sts);
 
             if current_status != ClusterConditionStatus::True {
                 unavailable_sts.push(sts.name_any())
@@ -51,6 +53,25 @@ impl StatefulSetConditionBuilder {
             last_update_time: None,
         }
     }
+
+    fn stateful_set_available(sts: &StatefulSet) -> ClusterConditionStatus {
+        let requested_replicas = sts
+            .spec
+            .as_ref()
+            .and_then(|spec| spec.replicas)
+            .unwrap_or_default();
+        let available_replicas = sts
+            .status
+            .as_ref()
+            .and_then(|status| status.available_replicas)
+            .unwrap_or_default();
+
+        if requested_replicas == available_replicas {
+            ClusterConditionStatus::True
+        } else {
+            ClusterConditionStatus::False
+        }
+    }
 }
 
 impl ConditionBuilder for StatefulSetConditionBuilder {
@@ -59,25 +80,6 @@ impl ConditionBuilder for StatefulSetConditionBuilder {
     }
 }
 
-fn stateful_set_available(sts: &StatefulSet) -> ClusterConditionStatus {
-    let requested_replicas = sts
-        .spec
-        .as_ref()
-        .and_then(|spec| spec.replicas)
-        .unwrap_or_default();
-    let available_replicas = sts
-        .status
-        .as_ref()
-        .and_then(|status| status.available_replicas)
-        .unwrap_or_default();
-
-    if requested_replicas == available_replicas {
-        ClusterConditionStatus::True
-    } else {
-        ClusterConditionStatus::False
-    }
-}
-
 #[cfg(test)]
 mod test {
     #[test]
diff --git a/src/status/mod.rs b/src/status/mod.rs
index 9eda070cc..db3947f61 100644
--- a/src/status/mod.rs
+++ b/src/status/mod.rs
@@ -1,306 +1 @@
 pub mod condition;
-
-use chrono::Utc;
-use k8s_openapi::apimachinery::pkg::apis::meta::v1::Time;
-use schemars::{self, JsonSchema};
-use serde::{Deserialize, Serialize};
-use strum::EnumCount;
-
-/// A **data structure** that contains a vector of `ClusterCondition`s.
-/// Should usually be the status of a `CustomResource`.
-pub trait HasStatusCondition {
-    fn conditions(&self) -> Vec<ClusterCondition>;
-}
-
-/// A **data structure** that produces a `ClusterConditionSet` containing all required
-/// `ClusterCondition`s.
-pub trait ConditionBuilder {
-    fn build_conditions(&self) -> ClusterConditionSet;
-}
-
-/// Computes the final conditions to be set in the operator status condition field.
-///
-/// # Arguments
-///
-/// * `resource` - A cluster resource or status implementing [`HasStatusCondition`] in order to
-///    retrieve the "current" conditions set in the cluster. This is required to  compute
-///    condition change and set proper update / transition times.
-/// * `condition_builders` - A slice of structs implementing [`ConditionBuilder`]. This can be a
-///    one of the predefined ConditionBuilders like `DaemonSetConditionBuilder` or a custom
-///    implementation.
-///                    
-/// # Examples
-///
-/// ```
-/// use stackable_operator::status::{ClusterCondition, ConditionBuilder, HasStatusCondition};
-/// use stackable_operator::status::condition::daemonset::DaemonSetConditionBuilder;
-/// use stackable_operator::status::condition::statefulset::StatefulSetConditionBuilder;
-/// use k8s_openapi::api::apps::v1::{DaemonSet, StatefulSet};
-///
-/// struct ClusterStatus {
-///     conditions: Vec<ClusterCondition>
-/// }
-///
-/// impl HasStatusCondition for ClusterStatus {
-///     fn conditions(&self) -> Vec<ClusterCondition> {
-///         self.conditions.clone()
-///     }
-/// }
-///
-/// let mut daemonset_condition_builder = DaemonSetConditionBuilder::default();
-/// daemonset_condition_builder.add(DaemonSet::default());
-///
-/// let mut statefulset_condition_builder = StatefulSetConditionBuilder::default();
-/// statefulset_condition_builder.add(StatefulSet::default());
-///
-/// let old_status = ClusterStatus {
-///     conditions: vec![]
-/// };
-///
-/// let new_status = ClusterStatus {
-///     conditions: stackable_operator::status::compute_conditions(&old_status,
-///         &[
-///             &daemonset_condition_builder as &dyn ConditionBuilder,
-///             &statefulset_condition_builder as &dyn ConditionBuilder
-///         ]
-///     )
-/// };
-///
-/// ```
-///
-pub fn compute_conditions<T: HasStatusCondition>(
-    resource: &T,
-    condition_builders: &[&dyn ConditionBuilder],
-) -> Vec<ClusterCondition> {
-    let mut old_conditions: ClusterConditionSet = resource.conditions().into();
-
-    for cb in condition_builders {
-        let new_conditions: ClusterConditionSet = cb.build_conditions();
-
-        old_conditions = old_conditions.merge(new_conditions);
-    }
-
-    old_conditions.into()
-}
-
-#[derive(Clone, Debug, Default, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ClusterCondition {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    /// Last time the condition transitioned from one status to another.
-    pub last_transition_time: Option<Time>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    /// The last time this condition was updated.
-    pub last_update_time: Option<Time>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    /// A human readable message indicating details about the transition.
-    pub message: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    /// The reason for the condition's last transition.
-    pub reason: Option<String>,
-    /// Status of the condition, one of True, False, Unknown.
-    pub status: ClusterConditionStatus,
-    /// Type of deployment condition.
-    #[serde(rename = "type")]
-    pub type_: ClusterConditionType,
-}
-
-#[derive(
-    Clone,
-    Copy,
-    Debug,
-    Default,
-    Deserialize,
-    EnumCount,
-    Eq,
-    Hash,
-    JsonSchema,
-    Ord,
-    PartialEq,
-    PartialOrd,
-    Serialize,
-)]
-#[serde(rename_all = "PascalCase")]
-pub enum ClusterConditionType {
-    #[default]
-    /// Available indicates that the binary maintained by the operator (eg: zookeeper for the
-    /// zookeeper-operator), is functional and available in the cluster.
-    Available,
-    /// Degraded indicates that the operand is not functioning completely. An example of a degraded
-    /// state would be if there should be 5 copies of the operand running but only 4 are running.
-    /// It may still be available, but it is degraded.
-    Degraded,
-    /// Progressing indicates that the operator is actively making changes to the binary maintained
-    /// by the operator (eg: zookeeper for the zookeeper-operator).
-    Progressing,
-    /// Paused indicates that the operator is not reconciling the cluster. This may be used for
-    /// debugging or operator updating.
-    Paused,
-    /// Stopped indicates that all the cluster replicas are scaled down to 0. All resources (e.g.
-    /// ConfigMaps, Services etc.) are kept.
-    Stopped,
-}
-
-#[derive(
-    Clone, Debug, Default, Deserialize, Eq, JsonSchema, Ord, PartialEq, PartialOrd, Serialize,
-)]
-#[serde(rename_all = "PascalCase")]
-pub enum ClusterConditionStatus {
-    #[default]
-    /// True means a resource is in the condition.
-    True,
-    /// False means a resource is not in the condition.
-    False,
-    /// Unknown means kubernetes cannot decide if a resource is in the condition or not.
-    Unknown,
-}
-
-#[derive(Default)]
-/// Helper struct to order and merge `ClusterCondition` objects.
-pub struct ClusterConditionSet {
-    conditions: Vec<Option<ClusterCondition>>,
-}
-
-impl ClusterConditionSet {
-    pub fn new() -> Self {
-        ClusterConditionSet {
-            // We use this as a quasi "Set" where each ClusterConditionType has its fixed position
-            // This ensures ordering, and in contrast to e.g. a
-            // BTreeMap<ClusterConditionType, ClusterCondition>, prevents shenanigans like adding a
-            // ClusterCondition (as value) with a different ClusterConditionType than its key.
-            // See "put".
-            conditions: vec![None; ClusterConditionType::COUNT],
-        }
-    }
-
-    /// Adds a [`ClusterCondition`] to its assigned index in the conditions vector.
-    fn put(&mut self, condition: ClusterCondition) {
-        let index = condition.type_ as usize;
-        self.conditions[index] = Some(condition);
-    }
-
-    /// Merges two [`ClusterConditionSet`]s.
-    pub fn merge(self, other: ClusterConditionSet) -> ClusterConditionSet {
-        let mut result = ClusterConditionSet::new();
-
-        for (old_condition, new_condition) in self
-            .conditions
-            .into_iter()
-            .zip(other.conditions.into_iter())
-        {
-            if let Some(condition) = match (old_condition, new_condition) {
-                (Some(old), Some(new)) => Some(Self::merge_condition(old, new)),
-                (Some(old), None) => Some(old),
-                (None, Some(new)) => Some(new),
-                _ => None,
-            } {
-                result.put(condition);
-            };
-        }
-
-        result
-    }
-
-    fn merge_condition(
-        old_condition: ClusterCondition,
-        new_condition: ClusterCondition,
-    ) -> ClusterCondition {
-        let now = Time(Utc::now());
-        // No change in status -> update "last_update_time" and keep "last_transition_time"
-        if old_condition.status == new_condition.status {
-            ClusterCondition {
-                last_update_time: Some(now),
-                last_transition_time: old_condition.last_transition_time,
-                ..new_condition
-            }
-            // Change in status -> set new "last_update_time" and "last_transition_time"
-        } else {
-            ClusterCondition {
-                last_update_time: Some(now.clone()),
-                last_transition_time: Some(now),
-                ..new_condition
-            }
-        }
-    }
-}
-
-impl From<ClusterConditionSet> for Vec<ClusterCondition> {
-    fn from(value: ClusterConditionSet) -> Self {
-        value.conditions.into_iter().flatten().collect()
-    }
-}
-
-impl From<Vec<ClusterCondition>> for ClusterConditionSet {
-    fn from(value: Vec<ClusterCondition>) -> Self {
-        let mut result = ClusterConditionSet::new();
-        for c in value {
-            result.put(c);
-        }
-        result
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::status::*;
-
-    struct TestResource {}
-    impl HasStatusCondition for TestResource {
-        fn conditions(&self) -> Vec<ClusterCondition> {
-            vec![ClusterCondition {
-                type_: ClusterConditionType::Available,
-                status: ClusterConditionStatus::False,
-                message: Some("OMG! Thing is broken!".into()),
-                ..ClusterCondition::default()
-            }]
-        }
-    }
-
-    struct TestConditionBuilder {}
-    struct TestConditionBuilder2 {}
-
-    impl ConditionBuilder for TestConditionBuilder {
-        fn build_conditions(&self) -> ClusterConditionSet {
-            vec![ClusterCondition {
-                type_: ClusterConditionType::Available,
-                status: ClusterConditionStatus::True,
-                message: Some("Relax. Everything is fine.".into()),
-                ..ClusterCondition::default()
-            }]
-            .into()
-        }
-    }
-
-    impl ConditionBuilder for TestConditionBuilder2 {
-        fn build_conditions(&self) -> ClusterConditionSet {
-            vec![].into()
-        }
-    }
-
-    #[test]
-    pub fn test_compute_conditions_with_transition() {
-        let resource = TestResource {};
-        let condition_builders = &[
-            &TestConditionBuilder {} as &dyn ConditionBuilder,
-            &TestConditionBuilder2 {} as &dyn ConditionBuilder,
-        ];
-
-        let got = compute_conditions(&resource, condition_builders)
-            .get(0)
-            .cloned()
-            .unwrap();
-
-        let expected = ClusterCondition {
-            type_: ClusterConditionType::Available,
-            status: ClusterConditionStatus::True,
-            message: Some("Relax. Everything is fine.".into()),
-            ..ClusterCondition::default()
-        };
-
-        assert_eq!(got.type_, expected.type_);
-        assert_eq!(got.status, expected.status);
-        assert_eq!(got.message, expected.message);
-        assert_eq!(got.last_transition_time, got.last_update_time);
-        assert!(got.last_transition_time.is_some());
-    }
-}

From eda6d33ba579ec7c2f13a90945188992c2228add Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Thu, 23 Mar 2023 14:58:30 +0100
Subject: [PATCH 18/36] wip

---
 src/status/condition/daemonset.rs   |  22 +++---
 src/status/condition/mod.rs         | 115 +++++++++++++++++++++++-----
 src/status/condition/statefulset.rs |  22 +++---
 3 files changed, 122 insertions(+), 37 deletions(-)

diff --git a/src/status/condition/daemonset.rs b/src/status/condition/daemonset.rs
index 4d0f07c3f..82599005c 100644
--- a/src/status/condition/daemonset.rs
+++ b/src/status/condition/daemonset.rs
@@ -14,6 +14,12 @@ pub struct DaemonSetConditionBuilder {
     daemon_sets: Vec<DaemonSet>,
 }
 
+impl ConditionBuilder for DaemonSetConditionBuilder {
+    fn build_conditions(&self) -> ClusterConditionSet {
+        vec![self.available()].into()
+    }
+}
+
 impl DaemonSetConditionBuilder {
     pub fn add(&mut self, ds: DaemonSet) {
         self.daemon_sets.push(ds);
@@ -21,24 +27,28 @@ impl DaemonSetConditionBuilder {
 
     fn available(&self) -> ClusterCondition {
         let mut available = ClusterConditionStatus::True;
-        let mut unavailable_ds = vec![];
+        let mut unavailable_resources = vec![];
 
         for ds in &self.daemon_sets {
             let current_status = Self::daemon_set_available(ds);
 
             if current_status != ClusterConditionStatus::True {
-                unavailable_ds.push(ds.name_any())
+                unavailable_resources.push(ds.name_any())
             }
 
             available = cmp::max(available, current_status);
         }
 
+        // We need to sort here to make sure roles and role groups are not changing position
+        // due to the HashMap (random order) logic.
+        unavailable_resources.sort();
+
         let message = match available {
             ClusterConditionStatus::True => {
                 "All DaemonSet have the requested amount of ready replicas.".to_string()
             }
             ClusterConditionStatus::False => {
-                format!("DaemonSet {unavailable_ds:?} missing ready replicas.")
+                format!("DaemonSet {unavailable_resources:?} missing ready replicas.")
             }
             ClusterConditionStatus::Unknown => "DaemonSet status cannot be determined.".to_string(),
         };
@@ -67,9 +77,3 @@ impl DaemonSetConditionBuilder {
         }
     }
 }
-
-impl ConditionBuilder for DaemonSetConditionBuilder {
-    fn build_conditions(&self) -> ClusterConditionSet {
-        vec![self.available()].into()
-    }
-}
diff --git a/src/status/condition/mod.rs b/src/status/condition/mod.rs
index 7ffef18d1..57e6fa9cd 100644
--- a/src/status/condition/mod.rs
+++ b/src/status/condition/mod.rs
@@ -75,7 +75,6 @@ pub fn compute_conditions<T: HasStatusCondition>(
 
     for cb in condition_builders {
         let new_conditions: ClusterConditionSet = cb.build_conditions();
-
         old_conditions = old_conditions.merge(new_conditions);
     }
 
@@ -154,7 +153,7 @@ pub enum ClusterConditionStatus {
     Unknown,
 }
 
-#[derive(Default)]
+#[derive(Clone, Default)]
 /// Helper struct to order and merge `ClusterCondition` objects.
 pub struct ClusterConditionSet {
     conditions: Vec<Option<ClusterCondition>>,
@@ -207,12 +206,26 @@ impl ClusterConditionSet {
         let now = Time(Utc::now());
         // No change in status -> update "last_update_time" and keep "last_transition_time"
         if old_condition.status == new_condition.status {
+            // concat message if required
+            let message = if let (Some(old_msg), Some(new_msg)) =
+                (old_condition.message, &new_condition.message)
+            {
+                if !old_msg.contains(new_msg) {
+                    Some(format!("{old_msg}\n{new_msg}"))
+                } else {
+                    new_condition.message
+                }
+            } else {
+                new_condition.message
+            };
+
             ClusterCondition {
                 last_update_time: Some(now),
                 last_transition_time: old_condition.last_transition_time,
+                message,
                 ..new_condition
             }
-            // Change in status -> set new "last_update_time" and "last_transition_time"
+        // Change in status -> set new "last_update_time" and "last_transition_time"
         } else {
             ClusterCondition {
                 last_update_time: Some(now.clone()),
@@ -243,46 +256,61 @@ impl From<Vec<ClusterCondition>> for ClusterConditionSet {
 mod test {
     use super::*;
 
-    struct TestResource {}
-    impl HasStatusCondition for TestResource {
+    struct TestClusterCondition {}
+    impl HasStatusCondition for TestClusterCondition {
         fn conditions(&self) -> Vec<ClusterCondition> {
             vec![ClusterCondition {
                 type_: ClusterConditionType::Available,
-                status: ClusterConditionStatus::False,
-                message: Some("OMG! Thing is broken!".into()),
+                status: ClusterConditionStatus::Unknown,
+                message: Some("TestClusterCondition=Unknown".into()),
                 ..ClusterCondition::default()
             }]
         }
     }
 
-    struct TestConditionBuilder {}
-    struct TestConditionBuilder2 {}
+    struct AvailableFalseConditionBuilder {}
+    impl ConditionBuilder for AvailableFalseConditionBuilder {
+        fn build_conditions(&self) -> ClusterConditionSet {
+            vec![ClusterCondition {
+                type_: ClusterConditionType::Available,
+                status: ClusterConditionStatus::False,
+                message: Some("AvailableFalseConditionBuilder".into()),
+                ..ClusterCondition::default()
+            }]
+            .into()
+        }
+    }
 
-    impl ConditionBuilder for TestConditionBuilder {
+    struct AvailableTrueConditionBuilder1 {}
+    impl ConditionBuilder for AvailableTrueConditionBuilder1 {
         fn build_conditions(&self) -> ClusterConditionSet {
             vec![ClusterCondition {
                 type_: ClusterConditionType::Available,
                 status: ClusterConditionStatus::True,
-                message: Some("Relax. Everything is fine.".into()),
+                message: Some("AvailableTrueConditionBuilder_1".into()),
                 ..ClusterCondition::default()
             }]
             .into()
         }
     }
 
-    impl ConditionBuilder for TestConditionBuilder2 {
+    struct AvailableTrueConditionBuilder2 {}
+    impl ConditionBuilder for AvailableTrueConditionBuilder2 {
         fn build_conditions(&self) -> ClusterConditionSet {
-            vec![].into()
+            vec![ClusterCondition {
+                type_: ClusterConditionType::Available,
+                status: ClusterConditionStatus::True,
+                message: Some("AvailableTrueConditionBuilder_2".into()),
+                ..ClusterCondition::default()
+            }]
+            .into()
         }
     }
 
     #[test]
     pub fn test_compute_conditions_with_transition() {
-        let resource = TestResource {};
-        let condition_builders = &[
-            &TestConditionBuilder {} as &dyn ConditionBuilder,
-            &TestConditionBuilder2 {} as &dyn ConditionBuilder,
-        ];
+        let resource = TestClusterCondition {};
+        let condition_builders = &[&AvailableTrueConditionBuilder1 {} as &dyn ConditionBuilder];
 
         let got = compute_conditions(&resource, condition_builders)
             .get(0)
@@ -292,7 +320,7 @@ mod test {
         let expected = ClusterCondition {
             type_: ClusterConditionType::Available,
             status: ClusterConditionStatus::True,
-            message: Some("Relax. Everything is fine.".into()),
+            message: Some("AvailableTrueConditionBuilder_1".into()),
             ..ClusterCondition::default()
         };
 
@@ -302,4 +330,53 @@ mod test {
         assert_eq!(got.last_transition_time, got.last_update_time);
         assert!(got.last_transition_time.is_some());
     }
+
+    #[test]
+    pub fn test_compute_conditions_message_concatenation() {
+        let resource = TestClusterCondition {};
+        let condition_builders = &[
+            &AvailableTrueConditionBuilder1 {} as &dyn ConditionBuilder,
+            &AvailableTrueConditionBuilder2 {} as &dyn ConditionBuilder,
+        ];
+
+        let got = compute_conditions(&resource, condition_builders)
+            .get(0)
+            .cloned()
+            .unwrap();
+
+        let expected = ClusterCondition {
+            type_: ClusterConditionType::Available,
+            status: ClusterConditionStatus::True,
+            message: Some(
+                "AvailableTrueConditionBuilder_1\nAvailableTrueConditionBuilder_2".into(),
+            ),
+            ..ClusterCondition::default()
+        };
+
+        assert_eq!(got.type_, expected.type_);
+        assert_eq!(got.status, expected.status);
+        assert_eq!(got.message, expected.message);
+
+        let condition_builders = &[
+            &AvailableTrueConditionBuilder1 {} as &dyn ConditionBuilder,
+            &AvailableFalseConditionBuilder {} as &dyn ConditionBuilder,
+            &AvailableTrueConditionBuilder2 {} as &dyn ConditionBuilder,
+        ];
+
+        let got = compute_conditions(&resource, condition_builders)
+            .get(0)
+            .cloned()
+            .unwrap();
+
+        let expected = ClusterCondition {
+            type_: ClusterConditionType::Available,
+            status: ClusterConditionStatus::False,
+            message: Some("AvailableFalseConditionBuilder".into()),
+            ..ClusterCondition::default()
+        };
+
+        assert_eq!(got.type_, expected.type_);
+        assert_eq!(got.status, expected.status);
+        assert_eq!(got.message, expected.message);
+    }
 }
diff --git a/src/status/condition/statefulset.rs b/src/status/condition/statefulset.rs
index 3a1b1940e..a2e9c79b6 100644
--- a/src/status/condition/statefulset.rs
+++ b/src/status/condition/statefulset.rs
@@ -14,6 +14,12 @@ pub struct StatefulSetConditionBuilder {
     stateful_sets: Vec<StatefulSet>,
 }
 
+impl ConditionBuilder for StatefulSetConditionBuilder {
+    fn build_conditions(&self) -> ClusterConditionSet {
+        vec![self.available()].into()
+    }
+}
+
 impl StatefulSetConditionBuilder {
     pub fn add(&mut self, sts: StatefulSet) {
         self.stateful_sets.push(sts);
@@ -21,23 +27,27 @@ impl StatefulSetConditionBuilder {
 
     fn available(&self) -> ClusterCondition {
         let mut available = ClusterConditionStatus::True;
-        let mut unavailable_sts = vec![];
+        let mut unavailable_resources = vec![];
         for sts in &self.stateful_sets {
             let current_status = Self::stateful_set_available(sts);
 
             if current_status != ClusterConditionStatus::True {
-                unavailable_sts.push(sts.name_any())
+                unavailable_resources.push(sts.name_any())
             }
 
             available = cmp::max(available, current_status);
         }
 
+        // We need to sort here to make sure roles and role groups are not changing position
+        // due to the HashMap (random order) logic.
+        unavailable_resources.sort();
+
         let message = match available {
             ClusterConditionStatus::True => {
                 "All StatefulSet have the requested amount of ready replicas.".to_string()
             }
             ClusterConditionStatus::False => {
-                format!("StatefulSet {unavailable_sts:?} missing ready replicas.")
+                format!("StatefulSet {unavailable_resources:?} missing ready replicas.")
             }
             ClusterConditionStatus::Unknown => {
                 "StatefulSet status cannot be determined.".to_string()
@@ -74,12 +84,6 @@ impl StatefulSetConditionBuilder {
     }
 }
 
-impl ConditionBuilder for StatefulSetConditionBuilder {
-    fn build_conditions(&self) -> ClusterConditionSet {
-        vec![self.available()].into()
-    }
-}
-
 #[cfg(test)]
 mod test {
     #[test]

From a2ecfd209781c535dc41b0b55dd9e1099950cb10 Mon Sep 17 00:00:00 2001
From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com>
Date: Thu, 23 Mar 2023 20:14:17 +0100
Subject: [PATCH 19/36] merge/combine and fix tests.

---
 src/status/condition/mod.rs | 59 +++++++++++++++++++++++--------------
 1 file changed, 37 insertions(+), 22 deletions(-)

diff --git a/src/status/condition/mod.rs b/src/status/condition/mod.rs
index 57e6fa9cd..7665cf704 100644
--- a/src/status/condition/mod.rs
+++ b/src/status/condition/mod.rs
@@ -71,14 +71,17 @@ pub fn compute_conditions<T: HasStatusCondition>(
     resource: &T,
     condition_builders: &[&dyn ConditionBuilder],
 ) -> Vec<ClusterCondition> {
-    let mut old_conditions: ClusterConditionSet = resource.conditions().into();
-
+    let mut new_resource_conditions = ClusterConditionSet::new();
     for cb in condition_builders {
-        let new_conditions: ClusterConditionSet = cb.build_conditions();
-        old_conditions = old_conditions.merge(new_conditions);
+        let conditions: ClusterConditionSet = cb.build_conditions();
+        new_resource_conditions = new_resource_conditions.merge(conditions, false);
     }
 
-    old_conditions.into()
+    let old_resource_conditions: ClusterConditionSet = resource.conditions().into();
+
+    old_resource_conditions
+        .merge(new_resource_conditions, true)
+        .into()
 }
 
 #[derive(Clone, Debug, Default, Deserialize, Eq, JsonSchema, PartialEq, Serialize)]
@@ -178,7 +181,7 @@ impl ClusterConditionSet {
     }
 
     /// Merges two [`ClusterConditionSet`]s.
-    pub fn merge(self, other: ClusterConditionSet) -> ClusterConditionSet {
+    pub fn merge(self, other: ClusterConditionSet, merge_combine: bool) -> ClusterConditionSet {
         let mut result = ClusterConditionSet::new();
 
         for (old_condition, new_condition) in self
@@ -187,7 +190,11 @@ impl ClusterConditionSet {
             .zip(other.conditions.into_iter())
         {
             if let Some(condition) = match (old_condition, new_condition) {
-                (Some(old), Some(new)) => Some(Self::merge_condition(old, new)),
+                (Some(old), Some(new)) => Some(if merge_combine {
+                    Self::merge_condition(old, new)
+                } else {
+                    Self::combine_condition(old, new)
+                }),
                 (Some(old), None) => Some(old),
                 (None, Some(new)) => Some(new),
                 _ => None,
@@ -198,7 +205,6 @@ impl ClusterConditionSet {
 
         result
     }
-
     fn merge_condition(
         old_condition: ClusterCondition,
         new_condition: ClusterCondition,
@@ -206,23 +212,9 @@ impl ClusterConditionSet {
         let now = Time(Utc::now());
         // No change in status -> update "last_update_time" and keep "last_transition_time"
         if old_condition.status == new_condition.status {
-            // concat message if required
-            let message = if let (Some(old_msg), Some(new_msg)) =
-                (old_condition.message, &new_condition.message)
-            {
-                if !old_msg.contains(new_msg) {
-                    Some(format!("{old_msg}\n{new_msg}"))
-                } else {
-                    new_condition.message
-                }
-            } else {
-                new_condition.message
-            };
-
             ClusterCondition {
                 last_update_time: Some(now),
                 last_transition_time: old_condition.last_transition_time,
-                message,
                 ..new_condition
             }
         // Change in status -> set new "last_update_time" and "last_transition_time"
@@ -234,6 +226,29 @@ impl ClusterConditionSet {
             }
         }
     }
+    fn combine_condition(
+        old_condition: ClusterCondition,
+        new_condition: ClusterCondition,
+    ) -> ClusterCondition {
+        match old_condition.status.cmp(&new_condition.status) {
+            std::cmp::Ordering::Equal => {
+                let message = Some(
+                    vec![old_condition.message, new_condition.message]
+                        .into_iter()
+                        .flatten()
+                        .collect::<Vec<String>>()
+                        .join("\n"),
+                );
+
+                ClusterCondition {
+                    message,
+                    ..new_condition
+                }
+            }
+            std::cmp::Ordering::Less => new_condition,
+            std::cmp::Ordering::Greater => old_condition,
+        }
+    }
 }
 
 impl From<ClusterConditionSet> for Vec<ClusterCondition> {

From 94aec8d50f7e2a3be44ff332550919ac562c20c0 Mon Sep 17 00:00:00 2001
From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com>
Date: Thu, 23 Mar 2023 20:35:05 +0100
Subject: [PATCH 20/36] Use callback instead of bool parameter.

---
 src/status/condition/mod.rs | 110 ++++++++++++++++++++----------------
 1 file changed, 62 insertions(+), 48 deletions(-)

diff --git a/src/status/condition/mod.rs b/src/status/condition/mod.rs
index 7665cf704..c9178f51e 100644
--- a/src/status/condition/mod.rs
+++ b/src/status/condition/mod.rs
@@ -74,13 +74,13 @@ pub fn compute_conditions<T: HasStatusCondition>(
     let mut new_resource_conditions = ClusterConditionSet::new();
     for cb in condition_builders {
         let conditions: ClusterConditionSet = cb.build_conditions();
-        new_resource_conditions = new_resource_conditions.merge(conditions, false);
+        new_resource_conditions = new_resource_conditions.merge(conditions, update_message);
     }
 
     let old_resource_conditions: ClusterConditionSet = resource.conditions().into();
 
     old_resource_conditions
-        .merge(new_resource_conditions, true)
+        .merge(new_resource_conditions, update_timestamps)
         .into()
 }
 
@@ -180,8 +180,13 @@ impl ClusterConditionSet {
         self.conditions[index] = Some(condition);
     }
 
-    /// Merges two [`ClusterConditionSet`]s.
-    pub fn merge(self, other: ClusterConditionSet, merge_combine: bool) -> ClusterConditionSet {
+    /// Merges two [`ClusterConditionSet`]s. The condition_combiner implements the strategy used to merge two conditions of
+    /// of the same type_.
+    fn merge(
+        self,
+        other: ClusterConditionSet,
+        condition_combiner: fn(ClusterCondition, ClusterCondition) -> ClusterCondition,
+    ) -> ClusterConditionSet {
         let mut result = ClusterConditionSet::new();
 
         for (old_condition, new_condition) in self
@@ -190,11 +195,7 @@ impl ClusterConditionSet {
             .zip(other.conditions.into_iter())
         {
             if let Some(condition) = match (old_condition, new_condition) {
-                (Some(old), Some(new)) => Some(if merge_combine {
-                    Self::merge_condition(old, new)
-                } else {
-                    Self::combine_condition(old, new)
-                }),
+                (Some(old), Some(new)) => Some(condition_combiner(old, new)),
                 (Some(old), None) => Some(old),
                 (None, Some(new)) => Some(new),
                 _ => None,
@@ -205,49 +206,62 @@ impl ClusterConditionSet {
 
         result
     }
-    fn merge_condition(
-        old_condition: ClusterCondition,
-        new_condition: ClusterCondition,
-    ) -> ClusterCondition {
-        let now = Time(Utc::now());
-        // No change in status -> update "last_update_time" and keep "last_transition_time"
-        if old_condition.status == new_condition.status {
-            ClusterCondition {
-                last_update_time: Some(now),
-                last_transition_time: old_condition.last_transition_time,
-                ..new_condition
-            }
-        // Change in status -> set new "last_update_time" and "last_transition_time"
-        } else {
-            ClusterCondition {
-                last_update_time: Some(now.clone()),
-                last_transition_time: Some(now),
-                ..new_condition
-            }
+}
+
+/// A condition combiner strategy where the timestamps are updated to reflect a
+/// state transition (if needed).
+fn update_timestamps(
+    old_condition: ClusterCondition,
+    new_condition: ClusterCondition,
+) -> ClusterCondition {
+    // sanity check
+    assert!(old_condition.type_ == new_condition.type_);
+
+    let now = Time(Utc::now());
+    // No change in status -> update "last_update_time" and keep "last_transition_time"
+    if old_condition.status == new_condition.status {
+        ClusterCondition {
+            last_update_time: Some(now),
+            last_transition_time: old_condition.last_transition_time,
+            ..new_condition
+        }
+    // Change in status -> set new "last_update_time" and "last_transition_time"
+    } else {
+        ClusterCondition {
+            last_update_time: Some(now.clone()),
+            last_transition_time: Some(now),
+            ..new_condition
         }
     }
-    fn combine_condition(
-        old_condition: ClusterCondition,
-        new_condition: ClusterCondition,
-    ) -> ClusterCondition {
-        match old_condition.status.cmp(&new_condition.status) {
-            std::cmp::Ordering::Equal => {
-                let message = Some(
-                    vec![old_condition.message, new_condition.message]
-                        .into_iter()
-                        .flatten()
-                        .collect::<Vec<String>>()
-                        .join("\n"),
-                );
-
-                ClusterCondition {
-                    message,
-                    ..new_condition
-                }
+}
+
+/// A condition combiner strategy with the following properties:
+/// 1. It preserves the condition with the highest status.
+/// 2. It joins the previous messages to the current one if both conditions
+/// have the same status.
+fn update_message(
+    old_condition: ClusterCondition,
+    new_condition: ClusterCondition,
+) -> ClusterCondition {
+    assert!(old_condition.type_ == new_condition.type_);
+
+    match old_condition.status.cmp(&new_condition.status) {
+        std::cmp::Ordering::Equal => {
+            let message = Some(
+                vec![old_condition.message, new_condition.message]
+                    .into_iter()
+                    .flatten()
+                    .collect::<Vec<String>>()
+                    .join("\n"),
+            );
+
+            ClusterCondition {
+                message,
+                ..new_condition
             }
-            std::cmp::Ordering::Less => new_condition,
-            std::cmp::Ordering::Greater => old_condition,
         }
+        std::cmp::Ordering::Less => new_condition,
+        std::cmp::Ordering::Greater => old_condition,
     }
 }
 

From 9fdcd3c8b6f7d1387fa3fda54cd3fb34a2eb45c2 Mon Sep 17 00:00:00 2001
From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com>
Date: Fri, 24 Mar 2023 09:20:51 +0100
Subject: [PATCH 21/36] Fix doctest

---
 src/status/condition/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/status/condition/mod.rs b/src/status/condition/mod.rs
index c9178f51e..6a8bde154 100644
--- a/src/status/condition/mod.rs
+++ b/src/status/condition/mod.rs
@@ -35,7 +35,7 @@ pub trait ConditionBuilder {
 /// use stackable_operator::status::condition::daemonset::DaemonSetConditionBuilder;
 /// use stackable_operator::status::condition::statefulset::StatefulSetConditionBuilder;
 /// use k8s_openapi::api::apps::v1::{DaemonSet, StatefulSet};
-/// use stackable_operator::status::condition::{ClusterCondition, ConditionBuilder, HasStatusCondition};
+/// use stackable_operator::status::condition::{ClusterCondition, ConditionBuilder, HasStatusCondition, compute_conditions};
 ///
 /// struct ClusterStatus {
 ///     conditions: Vec<ClusterCondition>
@@ -58,7 +58,7 @@ pub trait ConditionBuilder {
 /// };
 ///
 /// let new_status = ClusterStatus {
-///     conditions: stackable_operator::status::compute_conditions(&old_status,
+///     conditions: compute_conditions(&old_status,
 ///         &[
 ///             &daemonset_condition_builder as &dyn ConditionBuilder,
 ///             &statefulset_condition_builder as &dyn ConditionBuilder

From 280d15039fbd96da3ae889364cef5a4154dc2c67 Mon Sep 17 00:00:00 2001
From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com>
Date: Fri, 24 Mar 2023 09:22:42 +0100
Subject: [PATCH 22/36] update changelog

---
 CHANGELOG.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bd043e70e..fc1c3c041 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,8 +7,10 @@ All notable changes to this project will be documented in this file.
 ### Added
 
 - Helper Method to add a restart_policy to PodBuilder([#565]).
+- status::condition module ([#xxx])
 
 [#565]: https://github.com/stackabletech/operator-rs/pull/565
+[#xxx]: https://github.com/stackabletech/operator-rs/pull/xxx
 
 ## [0.37.0] - 2023-03-06
 

From aa6d011d64bb2e29db70e056a78a2dcfbbafd814 Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Fri, 24 Mar 2023 09:26:43 +0100
Subject: [PATCH 23/36] added another test case

---
 src/status/condition/mod.rs | 30 +++++++++++++++++++++++++-----
 1 file changed, 25 insertions(+), 5 deletions(-)

diff --git a/src/status/condition/mod.rs b/src/status/condition/mod.rs
index 6a8bde154..9d4b836c3 100644
--- a/src/status/condition/mod.rs
+++ b/src/status/condition/mod.rs
@@ -243,7 +243,7 @@ fn update_message(
     old_condition: ClusterCondition,
     new_condition: ClusterCondition,
 ) -> ClusterCondition {
-    assert!(old_condition.type_ == new_condition.type_);
+    assert_eq!(old_condition.type_, new_condition.type_);
 
     match old_condition.status.cmp(&new_condition.status) {
         std::cmp::Ordering::Equal => {
@@ -297,8 +297,8 @@ mod test {
         }
     }
 
-    struct AvailableFalseConditionBuilder {}
-    impl ConditionBuilder for AvailableFalseConditionBuilder {
+    struct AvailableFalseConditionBuilder1 {}
+    impl ConditionBuilder for AvailableFalseConditionBuilder1 {
         fn build_conditions(&self) -> ClusterConditionSet {
             vec![ClusterCondition {
                 type_: ClusterConditionType::Available,
@@ -310,6 +310,19 @@ mod test {
         }
     }
 
+    struct AvailableFalseConditionBuilder2 {}
+    impl ConditionBuilder for AvailableFalseConditionBuilder2 {
+        fn build_conditions(&self) -> ClusterConditionSet {
+            vec![ClusterCondition {
+                type_: ClusterConditionType::Available,
+                status: ClusterConditionStatus::False,
+                message: Some("AvailableFalseConditionBuilder_2".into()),
+                ..ClusterCondition::default()
+            }]
+            .into()
+        }
+    }
+
     struct AvailableTrueConditionBuilder1 {}
     impl ConditionBuilder for AvailableTrueConditionBuilder1 {
         fn build_conditions(&self) -> ClusterConditionSet {
@@ -385,10 +398,15 @@ mod test {
         assert_eq!(got.type_, expected.type_);
         assert_eq!(got.status, expected.status);
         assert_eq!(got.message, expected.message);
+    }
 
+    #[test]
+    pub fn test_compute_conditions_message_concatenation_with_different_status() {
+        let resource = TestClusterCondition {};
         let condition_builders = &[
+            &AvailableFalseConditionBuilder1 {} as &dyn ConditionBuilder,
             &AvailableTrueConditionBuilder1 {} as &dyn ConditionBuilder,
-            &AvailableFalseConditionBuilder {} as &dyn ConditionBuilder,
+            &AvailableFalseConditionBuilder2 {} as &dyn ConditionBuilder,
             &AvailableTrueConditionBuilder2 {} as &dyn ConditionBuilder,
         ];
 
@@ -400,7 +418,9 @@ mod test {
         let expected = ClusterCondition {
             type_: ClusterConditionType::Available,
             status: ClusterConditionStatus::False,
-            message: Some("AvailableFalseConditionBuilder".into()),
+            message: Some(
+                "AvailableFalseConditionBuilder\nAvailableFalseConditionBuilder_2".into(),
+            ),
             ..ClusterCondition::default()
         };
 

From f5c452855849fe9aa6e24b23caa2fa8ee8608892 Mon Sep 17 00:00:00 2001
From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com>
Date: Fri, 24 Mar 2023 09:27:16 +0100
Subject: [PATCH 24/36] update pr number

---
 CHANGELOG.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fc1c3c041..84d2fe3c9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,10 +7,10 @@ All notable changes to this project will be documented in this file.
 ### Added
 
 - Helper Method to add a restart_policy to PodBuilder([#565]).
-- status::condition module ([#xxx])
+- status::condition module ([#571])
 
 [#565]: https://github.com/stackabletech/operator-rs/pull/565
-[#xxx]: https://github.com/stackabletech/operator-rs/pull/xxx
+[#571]: https://github.com/stackabletech/operator-rs/pull/571
 
 ## [0.37.0] - 2023-03-06
 

From 347f7886363bd2bc6ee5dcc2d44a9139291cd0f7 Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Fri, 24 Mar 2023 09:29:25 +0100
Subject: [PATCH 25/36] more tests

---
 src/status/condition/mod.rs | 39 +++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/src/status/condition/mod.rs b/src/status/condition/mod.rs
index 9d4b836c3..78c0069f0 100644
--- a/src/status/condition/mod.rs
+++ b/src/status/condition/mod.rs
@@ -349,6 +349,19 @@ mod test {
         }
     }
 
+    struct AvailableUnknownConditionBuilder {}
+    impl ConditionBuilder for AvailableUnknownConditionBuilder {
+        fn build_conditions(&self) -> ClusterConditionSet {
+            vec![ClusterCondition {
+                type_: ClusterConditionType::Available,
+                status: ClusterConditionStatus::Unknown,
+                message: Some("AvailableUnknownConditionBuilder".into()),
+                ..ClusterCondition::default()
+            }]
+            .into()
+        }
+    }
+
     #[test]
     pub fn test_compute_conditions_with_transition() {
         let resource = TestClusterCondition {};
@@ -428,4 +441,30 @@ mod test {
         assert_eq!(got.status, expected.status);
         assert_eq!(got.message, expected.message);
     }
+
+    #[test]
+    pub fn test_compute_conditions_status_priority() {
+        let resource = TestClusterCondition {};
+        let condition_builders = &[
+            &AvailableUnknownConditionBuilder {} as &dyn ConditionBuilder,
+            &AvailableFalseConditionBuilder1 {} as &dyn ConditionBuilder,
+            &AvailableTrueConditionBuilder1 {} as &dyn ConditionBuilder,
+        ];
+
+        let got = compute_conditions(&resource, condition_builders)
+            .get(0)
+            .cloned()
+            .unwrap();
+
+        let expected = ClusterCondition {
+            type_: ClusterConditionType::Available,
+            status: ClusterConditionStatus::Unknown,
+            message: Some("AvailableUnknownConditionBuilder".into()),
+            ..ClusterCondition::default()
+        };
+
+        assert_eq!(got.type_, expected.type_);
+        assert_eq!(got.status, expected.status);
+        assert_eq!(got.message, expected.message);
+    }
 }

From 2796ee9292582a01e2706504c36205fbff5d5e9e Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Fri, 24 Mar 2023 09:40:34 +0100
Subject: [PATCH 26/36] clippy

---
 src/status/condition/mod.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/status/condition/mod.rs b/src/status/condition/mod.rs
index 78c0069f0..73808df53 100644
--- a/src/status/condition/mod.rs
+++ b/src/status/condition/mod.rs
@@ -215,7 +215,7 @@ fn update_timestamps(
     new_condition: ClusterCondition,
 ) -> ClusterCondition {
     // sanity check
-    assert!(old_condition.type_ == new_condition.type_);
+    assert_eq!(old_condition.type_, new_condition.type_);
 
     let now = Time(Utc::now());
     // No change in status -> update "last_update_time" and keep "last_transition_time"
@@ -243,6 +243,7 @@ fn update_message(
     old_condition: ClusterCondition,
     new_condition: ClusterCondition,
 ) -> ClusterCondition {
+    // sanity check
     assert_eq!(old_condition.type_, new_condition.type_);
 
     match old_condition.status.cmp(&new_condition.status) {

From fb24f72495ead8ca12362cf1a7f47a1b38670b18 Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Fri, 24 Mar 2023 09:56:24 +0100
Subject: [PATCH 27/36] added tests for statefulset condition builder

---
 src/status/condition/statefulset.rs | 84 ++++++++++++++++++++++++++++-
 1 file changed, 83 insertions(+), 1 deletion(-)

diff --git a/src/status/condition/statefulset.rs b/src/status/condition/statefulset.rs
index a2e9c79b6..abe6bbb4b 100644
--- a/src/status/condition/statefulset.rs
+++ b/src/status/condition/statefulset.rs
@@ -86,6 +86,88 @@ impl StatefulSetConditionBuilder {
 
 #[cfg(test)]
 mod test {
+    use crate::status::condition::statefulset::StatefulSetConditionBuilder;
+    use crate::status::condition::{
+        ClusterCondition, ClusterConditionStatus, ClusterConditionType, ConditionBuilder,
+    };
+    use k8s_openapi::api::apps::v1::{StatefulSet, StatefulSetSpec, StatefulSetStatus};
+
+    fn build_sts(spec_replicas: i32, available_replicas: i32) -> StatefulSet {
+        StatefulSet {
+            spec: Some(StatefulSetSpec {
+                replicas: Some(spec_replicas),
+                ..StatefulSetSpec::default()
+            }),
+            status: Some(StatefulSetStatus {
+                available_replicas: Some(available_replicas),
+                ..StatefulSetStatus::default()
+            }),
+            ..StatefulSet::default()
+        }
+    }
+
+    #[test]
+    fn test_stateful_set_available_true() {
+        let sts = build_sts(3, 3);
+
+        assert_eq!(
+            StatefulSetConditionBuilder::stateful_set_available(&sts),
+            ClusterConditionStatus::True
+        );
+    }
+
+    #[test]
+    fn test_stateful_set_available_false() {
+        let sts = build_sts(3, 2);
+
+        assert_eq!(
+            StatefulSetConditionBuilder::stateful_set_available(&sts),
+            ClusterConditionStatus::False
+        );
+
+        let sts = build_sts(3, 4);
+
+        assert_eq!(
+            StatefulSetConditionBuilder::stateful_set_available(&sts),
+            ClusterConditionStatus::False
+        );
+    }
+
     #[test]
-    fn test() {}
+    fn test_stateful_set_available_condition_true() {
+        let mut sts_condition_builder = StatefulSetConditionBuilder::default();
+        sts_condition_builder.add(build_sts(3, 3));
+
+        let conditions = sts_condition_builder.build_conditions();
+
+        let got = conditions.conditions.get(0).cloned().unwrap().unwrap();
+
+        let expected = ClusterCondition {
+            type_: ClusterConditionType::Available,
+            status: ClusterConditionStatus::True,
+            ..ClusterCondition::default()
+        };
+
+        assert_eq!(got.type_, expected.type_);
+        assert_eq!(got.status, expected.status);
+    }
+
+    #[test]
+    fn test_stateful_set_available_condition_false() {
+        let mut sts_condition_builder = StatefulSetConditionBuilder::default();
+        sts_condition_builder.add(build_sts(3, 2));
+
+        let conditions = sts_condition_builder.build_conditions();
+
+        let got = conditions.conditions.get(0).cloned().unwrap().unwrap();
+
+        let expected = ClusterCondition {
+            type_: ClusterConditionType::Available,
+            status: ClusterConditionStatus::False,
+            ..ClusterCondition::default()
+        };
+
+        assert_eq!(got.type_, expected.type_);
+        assert_eq!(got.status, expected.status);
+    }
 }

From f62bcd9c53b0ed64ed2f7dc5e3aa7bd6484ce7cf Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Fri, 24 Mar 2023 10:00:21 +0100
Subject: [PATCH 28/36] added tests for daemonset condition builder

---
 src/status/condition/daemonset.rs | 76 +++++++++++++++++++++++++++++++
 1 file changed, 76 insertions(+)

diff --git a/src/status/condition/daemonset.rs b/src/status/condition/daemonset.rs
index 82599005c..710c09654 100644
--- a/src/status/condition/daemonset.rs
+++ b/src/status/condition/daemonset.rs
@@ -77,3 +77,79 @@ impl DaemonSetConditionBuilder {
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use crate::status::condition::daemonset::DaemonSetConditionBuilder;
+    use crate::status::condition::{
+        ClusterCondition, ClusterConditionStatus, ClusterConditionType, ConditionBuilder,
+    };
+    use k8s_openapi::api::apps::v1::{DaemonSet, DaemonSetStatus};
+
+    fn build_ds(number_unavailable: i32) -> DaemonSet {
+        DaemonSet {
+            status: Some(DaemonSetStatus {
+                number_unavailable: Some(number_unavailable),
+                ..DaemonSetStatus::default()
+            }),
+            ..DaemonSet::default()
+        }
+    }
+
+    #[test]
+    fn test_daemon_set_available_true() {
+        let ds = build_ds(0);
+
+        assert_eq!(
+            DaemonSetConditionBuilder::daemon_set_available(&ds),
+            ClusterConditionStatus::True
+        );
+    }
+
+    #[test]
+    fn test_daemon_set_available_false() {
+        let ds = build_ds(1);
+        assert_eq!(
+            DaemonSetConditionBuilder::daemon_set_available(&ds),
+            ClusterConditionStatus::False
+        );
+    }
+
+    #[test]
+    fn test_daemon_set_available_condition_true() {
+        let mut ds_condition_builder = DaemonSetConditionBuilder::default();
+        ds_condition_builder.add(build_ds(0));
+
+        let conditions = ds_condition_builder.build_conditions();
+
+        let got = conditions.conditions.get(0).cloned().unwrap().unwrap();
+
+        let expected = ClusterCondition {
+            type_: ClusterConditionType::Available,
+            status: ClusterConditionStatus::True,
+            ..ClusterCondition::default()
+        };
+
+        assert_eq!(got.type_, expected.type_);
+        assert_eq!(got.status, expected.status);
+    }
+
+    #[test]
+    fn test_daemon_set_available_condition_false() {
+        let mut ds_condition_builder = DaemonSetConditionBuilder::default();
+        ds_condition_builder.add(build_ds(3));
+
+        let conditions = ds_condition_builder.build_conditions();
+
+        let got = conditions.conditions.get(0).cloned().unwrap().unwrap();
+
+        let expected = ClusterCondition {
+            type_: ClusterConditionType::Available,
+            status: ClusterConditionStatus::False,
+            ..ClusterCondition::default()
+        };
+
+        assert_eq!(got.type_, expected.type_);
+        assert_eq!(got.status, expected.status);
+    }
+}

From 419cdb9e3099d779d55e41c9cb7e54681469866d Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Fri, 24 Mar 2023 10:05:07 +0100
Subject: [PATCH 29/36] added comment for daemonset and statefulset condition
 builder that only type available is currently implemented

---
 src/status/condition/daemonset.rs   | 3 +++
 src/status/condition/statefulset.rs | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/src/status/condition/daemonset.rs b/src/status/condition/daemonset.rs
index 710c09654..c5d17ece2 100644
--- a/src/status/condition/daemonset.rs
+++ b/src/status/condition/daemonset.rs
@@ -9,6 +9,9 @@ use std::cmp;
 
 /// Default implementation to build [`crate::status::condition::ClusterCondition`]s for
 /// `DaemonSet` resources.
+///
+/// Currently only the `ClusterConditionType::Available` is implemented. This will be extended
+/// to support all `ClusterConditionType`s in the future.
 #[derive(Default)]
 pub struct DaemonSetConditionBuilder {
     daemon_sets: Vec<DaemonSet>,
diff --git a/src/status/condition/statefulset.rs b/src/status/condition/statefulset.rs
index abe6bbb4b..5f6189c32 100644
--- a/src/status/condition/statefulset.rs
+++ b/src/status/condition/statefulset.rs
@@ -9,6 +9,9 @@ use std::cmp;
 
 /// Default implementation to build [`crate::status::condition::ClusterCondition`]s for
 /// `StatefulSet` resources.
+///
+/// Currently only the `ClusterConditionType::Available` is implemented. This will be extended
+/// to support all `ClusterConditionType`s in the future.
 #[derive(Default)]
 pub struct StatefulSetConditionBuilder {
     stateful_sets: Vec<StatefulSet>,

From cdaffc3d46b48d08b02ae5b22396820d644f431a Mon Sep 17 00:00:00 2001
From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com>
Date: Mon, 27 Mar 2023 11:49:21 +0200
Subject: [PATCH 30/36] Rename Paused to ReconciliationPaused.

---
 src/status/condition/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/status/condition/mod.rs b/src/status/condition/mod.rs
index 73808df53..e91ddca92 100644
--- a/src/status/condition/mod.rs
+++ b/src/status/condition/mod.rs
@@ -136,7 +136,7 @@ pub enum ClusterConditionType {
     Progressing,
     /// Paused indicates that the operator is not reconciling the cluster. This may be used for
     /// debugging or operator updating.
-    Paused,
+    ReconciliationPaused,
     /// Stopped indicates that all the cluster replicas are scaled down to 0. All resources (e.g.
     /// ConfigMaps, Services etc.) are kept.
     Stopped,

From ef52649e6a684b1e517b1ba637482f8e64c14315 Mon Sep 17 00:00:00 2001
From: Razvan-Daniel Mihai <84674+razvan@users.noreply.github.com>
Date: Wed, 29 Mar 2023 17:41:36 +0200
Subject: [PATCH 31/36] Update availability tests for daemonsets and
 statefulsets.

---
 src/status/condition/daemonset.rs   | 23 ++++++++++++++---------
 src/status/condition/statefulset.rs |  5 ++++-
 2 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/src/status/condition/daemonset.rs b/src/status/condition/daemonset.rs
index c5d17ece2..c4e344acd 100644
--- a/src/status/condition/daemonset.rs
+++ b/src/status/condition/daemonset.rs
@@ -66,14 +66,19 @@ impl DaemonSetConditionBuilder {
         }
     }
 
+    /// Returns a condition "Available: True" if the number of ready Pods is greater than zero.
+    /// This is an heuristic that doesn't take into consideration if *all* eligible nodes have
+    /// running Pods.
+    /// Other fields of the daemon set status have been considered and discarded for being even less
+    /// reliable/informative.
     fn daemon_set_available(ds: &DaemonSet) -> ClusterConditionStatus {
-        let number_unavailable = ds
+        let number_ready = ds
             .status
             .as_ref()
-            .and_then(|status| status.number_unavailable)
+            .map(|status| status.number_ready)
             .unwrap_or_default();
 
-        if number_unavailable == 0 {
+        if number_ready > 0 {
             ClusterConditionStatus::True
         } else {
             ClusterConditionStatus::False
@@ -89,10 +94,10 @@ mod test {
     };
     use k8s_openapi::api::apps::v1::{DaemonSet, DaemonSetStatus};
 
-    fn build_ds(number_unavailable: i32) -> DaemonSet {
+    fn build_ds(number_ready: i32) -> DaemonSet {
         DaemonSet {
             status: Some(DaemonSetStatus {
-                number_unavailable: Some(number_unavailable),
+                number_ready,
                 ..DaemonSetStatus::default()
             }),
             ..DaemonSet::default()
@@ -101,7 +106,7 @@ mod test {
 
     #[test]
     fn test_daemon_set_available_true() {
-        let ds = build_ds(0);
+        let ds = build_ds(1);
 
         assert_eq!(
             DaemonSetConditionBuilder::daemon_set_available(&ds),
@@ -111,7 +116,7 @@ mod test {
 
     #[test]
     fn test_daemon_set_available_false() {
-        let ds = build_ds(1);
+        let ds = build_ds(0);
         assert_eq!(
             DaemonSetConditionBuilder::daemon_set_available(&ds),
             ClusterConditionStatus::False
@@ -121,7 +126,7 @@ mod test {
     #[test]
     fn test_daemon_set_available_condition_true() {
         let mut ds_condition_builder = DaemonSetConditionBuilder::default();
-        ds_condition_builder.add(build_ds(0));
+        ds_condition_builder.add(build_ds(1));
 
         let conditions = ds_condition_builder.build_conditions();
 
@@ -140,7 +145,7 @@ mod test {
     #[test]
     fn test_daemon_set_available_condition_false() {
         let mut ds_condition_builder = DaemonSetConditionBuilder::default();
-        ds_condition_builder.add(build_ds(3));
+        ds_condition_builder.add(build_ds(0));
 
         let conditions = ds_condition_builder.build_conditions();
 
diff --git a/src/status/condition/statefulset.rs b/src/status/condition/statefulset.rs
index 5f6189c32..a59740118 100644
--- a/src/status/condition/statefulset.rs
+++ b/src/status/condition/statefulset.rs
@@ -67,6 +67,9 @@ impl StatefulSetConditionBuilder {
         }
     }
 
+    /// Returns a condition "Available: True" if the number of requested replicas matches
+    /// the number of available replicas. In addition, there needs to be at least one replica
+    /// available.
     fn stateful_set_available(sts: &StatefulSet) -> ClusterConditionStatus {
         let requested_replicas = sts
             .spec
@@ -79,7 +82,7 @@ impl StatefulSetConditionBuilder {
             .and_then(|status| status.available_replicas)
             .unwrap_or_default();
 
-        if requested_replicas == available_replicas {
+        if requested_replicas == available_replicas && requested_replicas != 0 {
             ClusterConditionStatus::True
         } else {
             ClusterConditionStatus::False

From b151030b0e5ce1ee7710fd108d53a3272b1d6d59 Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Thu, 30 Mar 2023 16:59:40 +0200
Subject: [PATCH 32/36] use ClusterConditionType as index

---
 src/status/condition/daemonset.rs   | 14 ++++++++++++--
 src/status/condition/statefulset.rs | 14 ++++++++++++--
 2 files changed, 24 insertions(+), 4 deletions(-)

diff --git a/src/status/condition/daemonset.rs b/src/status/condition/daemonset.rs
index c4e344acd..27ea4fe87 100644
--- a/src/status/condition/daemonset.rs
+++ b/src/status/condition/daemonset.rs
@@ -130,7 +130,12 @@ mod test {
 
         let conditions = ds_condition_builder.build_conditions();
 
-        let got = conditions.conditions.get(0).cloned().unwrap().unwrap();
+        let got = conditions
+            .conditions
+            .get(ClusterConditionType::Available as usize)
+            .cloned()
+            .unwrap()
+            .unwrap();
 
         let expected = ClusterCondition {
             type_: ClusterConditionType::Available,
@@ -149,7 +154,12 @@ mod test {
 
         let conditions = ds_condition_builder.build_conditions();
 
-        let got = conditions.conditions.get(0).cloned().unwrap().unwrap();
+        let got = conditions
+            .conditions
+            .get(ClusterConditionType::Available as usize)
+            .cloned()
+            .unwrap()
+            .unwrap();
 
         let expected = ClusterCondition {
             type_: ClusterConditionType::Available,
diff --git a/src/status/condition/statefulset.rs b/src/status/condition/statefulset.rs
index a59740118..72d16f5fb 100644
--- a/src/status/condition/statefulset.rs
+++ b/src/status/condition/statefulset.rs
@@ -146,7 +146,12 @@ mod test {
 
         let conditions = sts_condition_builder.build_conditions();
 
-        let got = conditions.conditions.get(0).cloned().unwrap().unwrap();
+        let got = conditions
+            .conditions
+            .get(ClusterConditionType::Available as usize)
+            .cloned()
+            .unwrap()
+            .unwrap();
 
         let expected = ClusterCondition {
             type_: ClusterConditionType::Available,
@@ -165,7 +170,12 @@ mod test {
 
         let conditions = sts_condition_builder.build_conditions();
 
-        let got = conditions.conditions.get(0).cloned().unwrap().unwrap();
+        let got = conditions
+            .conditions
+            .get(ClusterConditionType::Available as usize)
+            .cloned()
+            .unwrap()
+            .unwrap();
 
         let expected = ClusterCondition {
             type_: ClusterConditionType::Available,

From 063140aae19d476167c13668211cfcd03ce124d3 Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Thu, 30 Mar 2023 17:12:44 +0200
Subject: [PATCH 33/36] added ClusterOperationsConditionBuilder

---
 src/status/condition/mod.rs        |   1 +
 src/status/condition/operations.rs | 146 +++++++++++++++++++++++++++++
 2 files changed, 147 insertions(+)
 create mode 100644 src/status/condition/operations.rs

diff --git a/src/status/condition/mod.rs b/src/status/condition/mod.rs
index e91ddca92..51e4bedd9 100644
--- a/src/status/condition/mod.rs
+++ b/src/status/condition/mod.rs
@@ -1,4 +1,5 @@
 pub mod daemonset;
+pub mod operations;
 pub mod statefulset;
 
 use chrono::Utc;
diff --git a/src/status/condition/operations.rs b/src/status/condition/operations.rs
new file mode 100644
index 000000000..ed9f0a9b3
--- /dev/null
+++ b/src/status/condition/operations.rs
@@ -0,0 +1,146 @@
+use crate::commons::cluster_operation::ClusterOperation;
+use crate::status::condition::{
+    ClusterCondition, ClusterConditionSet, ClusterConditionStatus, ClusterConditionType,
+    ConditionBuilder,
+};
+
+#[derive(Debug, Clone)]
+pub struct ClusterOperationsConditionBuilder<'a> {
+    cluster_operation: &'a ClusterOperation,
+}
+
+impl<'a> ConditionBuilder for ClusterOperationsConditionBuilder<'a> {
+    fn build_conditions(&self) -> ClusterConditionSet {
+        vec![self.reconciliation_paused(), self.cluster_stopped()].into()
+    }
+}
+
+impl<'a> ClusterOperationsConditionBuilder<'a> {
+    pub fn new(cluster_operation: &'a ClusterOperation) -> Self {
+        Self { cluster_operation }
+    }
+
+    fn reconciliation_paused(&self) -> ClusterCondition {
+        let status = if self.cluster_operation.reconciliation_paused {
+            ClusterConditionStatus::True
+        } else {
+            ClusterConditionStatus::False
+        };
+
+        let message = match status {
+            ClusterConditionStatus::True => {
+                "The cluster reconciliation is paused. Only the cluster status is reconciled."
+                    .to_string()
+            }
+            ClusterConditionStatus::False => "The cluster is reconciled normally.".to_string(),
+            ClusterConditionStatus::Unknown => {
+                "The cluster reconciliation status could not be determined.".to_string()
+            }
+        };
+
+        ClusterCondition {
+            reason: None,
+            message: Some(message),
+            status,
+            type_: ClusterConditionType::ReconciliationPaused,
+            last_transition_time: None,
+            last_update_time: None,
+        }
+    }
+
+    fn cluster_stopped(&self) -> ClusterCondition {
+        let status =
+            if self.cluster_operation.stopped && self.cluster_operation.reconciliation_paused {
+                ClusterConditionStatus::Unknown
+            } else if self.cluster_operation.stopped {
+                ClusterConditionStatus::True
+            } else {
+                ClusterConditionStatus::False
+            };
+
+        let message = match status {
+            ClusterConditionStatus::True => {
+                "The cluster is stopped.".to_string()
+            }
+            ClusterConditionStatus::False => {
+                "The cluster is running.".to_string()
+            }
+            ClusterConditionStatus::Unknown => {
+                "The cluster stopped status could not be determined. This might be due to the cluster reconciliation being paused.".to_string()
+            }
+        };
+
+        ClusterCondition {
+            reason: None,
+            message: Some(message),
+            status,
+            type_: ClusterConditionType::Stopped,
+            last_transition_time: None,
+            last_update_time: None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use rstest::*;
+
+    #[rstest]
+    #[case::not_paused_not_stopped(
+        false,
+        false,
+        ClusterConditionStatus::False,
+        ClusterConditionStatus::False
+    )]
+    #[case::paused_not_stopped(
+        true,
+        false,
+        ClusterConditionStatus::True,
+        ClusterConditionStatus::False
+    )]
+    #[case::not_paused_stopped(
+        false,
+        true,
+        ClusterConditionStatus::False,
+        ClusterConditionStatus::True
+    )]
+    #[case::paused_stopped(
+        true,
+        true,
+        ClusterConditionStatus::True,
+        ClusterConditionStatus::Unknown
+    )]
+    fn test_cluster_operation_condition(
+        #[case] reconciliation_paused: bool,
+        #[case] stopped: bool,
+        #[case] expected_paused_status: ClusterConditionStatus,
+        #[case] expected_stopped_status: ClusterConditionStatus,
+    ) {
+        let cluster_operation = ClusterOperation {
+            reconciliation_paused,
+            stopped,
+        };
+
+        let op_condition_builder = ClusterOperationsConditionBuilder::new(&cluster_operation);
+        let conditions = op_condition_builder.build_conditions();
+
+        let got = conditions
+            .conditions
+            .get(ClusterConditionType::ReconciliationPaused as usize)
+            .cloned()
+            .unwrap()
+            .unwrap();
+
+        assert_eq!(got.status, expected_paused_status);
+
+        let got = conditions
+            .conditions
+            .get(ClusterConditionType::Stopped as usize)
+            .cloned()
+            .unwrap()
+            .unwrap();
+
+        assert_eq!(got.status, expected_stopped_status);
+    }
+}

From 842bec8dfbf911ab0a1fcac64fef06878b07269e Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Thu, 30 Mar 2023 17:48:44 +0200
Subject: [PATCH 34/36] improved docs

---
 src/status/condition/daemonset.rs   | 2 +-
 src/status/condition/operations.rs  | 4 ++++
 src/status/condition/statefulset.rs | 2 +-
 3 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/status/condition/daemonset.rs b/src/status/condition/daemonset.rs
index 27ea4fe87..38f77c7c5 100644
--- a/src/status/condition/daemonset.rs
+++ b/src/status/condition/daemonset.rs
@@ -7,7 +7,7 @@ use k8s_openapi::api::apps::v1::DaemonSet;
 use kube::ResourceExt;
 use std::cmp;
 
-/// Default implementation to build [`crate::status::condition::ClusterCondition`]s for
+/// Default implementation to build [`ClusterCondition`]s for
 /// `DaemonSet` resources.
 ///
 /// Currently only the `ClusterConditionType::Available` is implemented. This will be extended
diff --git a/src/status/condition/operations.rs b/src/status/condition/operations.rs
index ed9f0a9b3..ac02862fd 100644
--- a/src/status/condition/operations.rs
+++ b/src/status/condition/operations.rs
@@ -4,6 +4,8 @@ use crate::status::condition::{
     ConditionBuilder,
 };
 
+/// Default implementation to build [`ClusterCondition`]s for
+/// the ClusterOperation.
 #[derive(Debug, Clone)]
 pub struct ClusterOperationsConditionBuilder<'a> {
     cluster_operation: &'a ClusterOperation,
@@ -20,6 +22,7 @@ impl<'a> ClusterOperationsConditionBuilder<'a> {
         Self { cluster_operation }
     }
 
+    /// Returns the `ReconciliationPaused` cluster condition.
     fn reconciliation_paused(&self) -> ClusterCondition {
         let status = if self.cluster_operation.reconciliation_paused {
             ClusterConditionStatus::True
@@ -48,6 +51,7 @@ impl<'a> ClusterOperationsConditionBuilder<'a> {
         }
     }
 
+    /// Returns the `Stopped` cluster condition.
     fn cluster_stopped(&self) -> ClusterCondition {
         let status =
             if self.cluster_operation.stopped && self.cluster_operation.reconciliation_paused {
diff --git a/src/status/condition/statefulset.rs b/src/status/condition/statefulset.rs
index 72d16f5fb..212390c96 100644
--- a/src/status/condition/statefulset.rs
+++ b/src/status/condition/statefulset.rs
@@ -7,7 +7,7 @@ use k8s_openapi::api::apps::v1::StatefulSet;
 use kube::ResourceExt;
 use std::cmp;
 
-/// Default implementation to build [`crate::status::condition::ClusterCondition`]s for
+/// Default implementation to build [`ClusterCondition`]s for
 /// `StatefulSet` resources.
 ///
 /// Currently only the `ClusterConditionType::Available` is implemented. This will be extended

From 0b61613ea3f1329677d50dcefcb2815ecd1ec4b8 Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Fri, 31 Mar 2023 14:18:01 +0200
Subject: [PATCH 35/36] added some more inline comments

---
 src/status/condition/mod.rs | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/src/status/condition/mod.rs b/src/status/condition/mod.rs
index 51e4bedd9..ad4741bf0 100644
--- a/src/status/condition/mod.rs
+++ b/src/status/condition/mod.rs
@@ -73,13 +73,14 @@ pub fn compute_conditions<T: HasStatusCondition>(
     condition_builders: &[&dyn ConditionBuilder],
 ) -> Vec<ClusterCondition> {
     let mut new_resource_conditions = ClusterConditionSet::new();
+    // compute current conditions and merge their message if required
     for cb in condition_builders {
         let conditions: ClusterConditionSet = cb.build_conditions();
         new_resource_conditions = new_resource_conditions.merge(conditions, update_message);
     }
 
     let old_resource_conditions: ClusterConditionSet = resource.conditions().into();
-
+    // merge the computed conditions and update e.g. transition timestamps if required
     old_resource_conditions
         .merge(new_resource_conditions, update_timestamps)
         .into()
@@ -181,8 +182,16 @@ impl ClusterConditionSet {
         self.conditions[index] = Some(condition);
     }
 
-    /// Merges two [`ClusterConditionSet`]s. The condition_combiner implements the strategy used to merge two conditions of
-    /// of the same type_.
+    /// Merges two [`ClusterConditionSet`]s. The condition_combiner implements the strategy used to
+    /// merge two conditions of the same `type_`.
+    ///
+    /// # Arguments
+    ///
+    /// * `other` - The [`ClusterConditionSet`] to be merged
+    /// * `condition_combiner` - This is either be `update_message` or `update_timestamps`. The
+    /// `update_message` is used to concatenate messages of the same [`ClusterConditionStatus`] and
+    /// the same [`ClusterConditionType`]. The `update_timestamps` is required to merge the old
+    /// cluster status with the new one and update transition timestamps correctly.
     fn merge(
         self,
         other: ClusterConditionSet,
@@ -190,14 +199,19 @@ impl ClusterConditionSet {
     ) -> ClusterConditionSet {
         let mut result = ClusterConditionSet::new();
 
+        // Combine the two condition vectors of old and new `ClusterConditionSet`.
         for (old_condition, new_condition) in self
             .conditions
             .into_iter()
             .zip(other.conditions.into_iter())
         {
             if let Some(condition) = match (old_condition, new_condition) {
+                // If both are set use the `condition_combiner` to update timestamps or concatenate
+                // the message
                 (Some(old), Some(new)) => Some(condition_combiner(old, new)),
+                // No new condition is computed, keep the old one
                 (Some(old), None) => Some(old),
+                // No condition of that type existed, use the new one
                 (None, Some(new)) => Some(new),
                 _ => None,
             } {

From ef2462b05b937c5f1c6ed3385533420dda7247f9 Mon Sep 17 00:00:00 2001
From: Malte Sander <malte.sander.it@gmail.com>
Date: Fri, 31 Mar 2023 14:30:37 +0200
Subject: [PATCH 36/36] implemented From<ClusterConditionType> for usize

---
 src/status/condition/daemonset.rs   |  4 ++--
 src/status/condition/mod.rs         | 26 +++++++++++++++++++++-----
 src/status/condition/operations.rs  |  4 ++--
 src/status/condition/statefulset.rs |  4 ++--
 4 files changed, 27 insertions(+), 11 deletions(-)

diff --git a/src/status/condition/daemonset.rs b/src/status/condition/daemonset.rs
index 38f77c7c5..6bdc39b1b 100644
--- a/src/status/condition/daemonset.rs
+++ b/src/status/condition/daemonset.rs
@@ -132,7 +132,7 @@ mod test {
 
         let got = conditions
             .conditions
-            .get(ClusterConditionType::Available as usize)
+            .get::<usize>(ClusterConditionType::Available.into())
             .cloned()
             .unwrap()
             .unwrap();
@@ -156,7 +156,7 @@ mod test {
 
         let got = conditions
             .conditions
-            .get(ClusterConditionType::Available as usize)
+            .get::<usize>(ClusterConditionType::Available.into())
             .cloned()
             .unwrap()
             .unwrap();
diff --git a/src/status/condition/mod.rs b/src/status/condition/mod.rs
index ad4741bf0..4a7db91ac 100644
--- a/src/status/condition/mod.rs
+++ b/src/status/condition/mod.rs
@@ -144,6 +144,22 @@ pub enum ClusterConditionType {
     Stopped,
 }
 
+// These are indices for the `ClusterConditionSet` conditions vector and should not be altered.
+// This may lead to problems when upgrading the operator later on.
+// When introducing a new `ClusterConditionType` it MUST be the direct successor of the last
+// condition index due to the "array" access of the `ClusterConditionSet` conditions vector.
+impl From<ClusterConditionType> for usize {
+    fn from(condition_type: ClusterConditionType) -> Self {
+        match condition_type {
+            ClusterConditionType::Available => 0,
+            ClusterConditionType::Degraded => 1,
+            ClusterConditionType::Progressing => 2,
+            ClusterConditionType::ReconciliationPaused => 3,
+            ClusterConditionType::Stopped => 4,
+        }
+    }
+}
+
 #[derive(
     Clone, Debug, Default, Deserialize, Eq, JsonSchema, Ord, PartialEq, PartialOrd, Serialize,
 )]
@@ -178,7 +194,7 @@ impl ClusterConditionSet {
 
     /// Adds a [`ClusterCondition`] to its assigned index in the conditions vector.
     fn put(&mut self, condition: ClusterCondition) {
-        let index = condition.type_ as usize;
+        let index: usize = condition.type_.into();
         self.conditions[index] = Some(condition);
     }
 
@@ -384,7 +400,7 @@ mod test {
         let condition_builders = &[&AvailableTrueConditionBuilder1 {} as &dyn ConditionBuilder];
 
         let got = compute_conditions(&resource, condition_builders)
-            .get(0)
+            .get::<usize>(ClusterConditionType::Available.into())
             .cloned()
             .unwrap();
 
@@ -411,7 +427,7 @@ mod test {
         ];
 
         let got = compute_conditions(&resource, condition_builders)
-            .get(0)
+            .get::<usize>(ClusterConditionType::Available.into())
             .cloned()
             .unwrap();
 
@@ -440,7 +456,7 @@ mod test {
         ];
 
         let got = compute_conditions(&resource, condition_builders)
-            .get(0)
+            .get::<usize>(ClusterConditionType::Available.into())
             .cloned()
             .unwrap();
 
@@ -468,7 +484,7 @@ mod test {
         ];
 
         let got = compute_conditions(&resource, condition_builders)
-            .get(0)
+            .get::<usize>(ClusterConditionType::Available.into())
             .cloned()
             .unwrap();
 
diff --git a/src/status/condition/operations.rs b/src/status/condition/operations.rs
index ac02862fd..d0e3c36ba 100644
--- a/src/status/condition/operations.rs
+++ b/src/status/condition/operations.rs
@@ -131,7 +131,7 @@ mod test {
 
         let got = conditions
             .conditions
-            .get(ClusterConditionType::ReconciliationPaused as usize)
+            .get::<usize>(ClusterConditionType::ReconciliationPaused.into())
             .cloned()
             .unwrap()
             .unwrap();
@@ -140,7 +140,7 @@ mod test {
 
         let got = conditions
             .conditions
-            .get(ClusterConditionType::Stopped as usize)
+            .get::<usize>(ClusterConditionType::Stopped.into())
             .cloned()
             .unwrap()
             .unwrap();
diff --git a/src/status/condition/statefulset.rs b/src/status/condition/statefulset.rs
index 212390c96..6a6d62a9f 100644
--- a/src/status/condition/statefulset.rs
+++ b/src/status/condition/statefulset.rs
@@ -148,7 +148,7 @@ mod test {
 
         let got = conditions
             .conditions
-            .get(ClusterConditionType::Available as usize)
+            .get::<usize>(ClusterConditionType::Available.into())
             .cloned()
             .unwrap()
             .unwrap();
@@ -172,7 +172,7 @@ mod test {
 
         let got = conditions
             .conditions
-            .get(ClusterConditionType::Available as usize)
+            .get::<usize>(ClusterConditionType::Available.into())
             .cloned()
             .unwrap()
             .unwrap();