fix: rustfmt lint

NickLarsenNZ · NickLarsenNZ · commit 51cf3cc4d7c7 · 2025-04-02T17:35:56.000+02:00
diff --git a/rust/operator-binary/src/config/jvm.rs b/rust/operator-binary/src/config/jvm.rs
@@ -5,8 +5,8 @@ use stackable_operator::{
 };
 
 use crate::crd::{
-    v1alpha1, AnyServiceConfig, HbaseRole, CONFIG_DIR_NAME, JVM_SECURITY_PROPERTIES_FILE,
-    METRICS_PORT,
+    AnyServiceConfig, CONFIG_DIR_NAME, HbaseRole, JVM_SECURITY_PROPERTIES_FILE, METRICS_PORT,
+    v1alpha1,
 };
 
 const JAVA_HEAP_FACTOR: f32 = 0.8;
@@ -144,7 +144,7 @@ fn is_heap_jvm_argument(jvm_argument: &str) -> bool {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::crd::{v1alpha1, HbaseRole};
+    use crate::crd::{HbaseRole, v1alpha1};
 
     #[test]
     fn test_construct_jvm_arguments_defaults() {
diff --git a/rust/operator-binary/src/crd/affinity.rs b/rust/operator-binary/src/crd/affinity.rs
@@ -1,11 +1,11 @@
 use stackable_operator::{
     commons::affinity::{
-        affinity_between_cluster_pods, affinity_between_role_pods, StackableAffinityFragment,
+        StackableAffinityFragment, affinity_between_cluster_pods, affinity_between_role_pods,
     },
     k8s_openapi::api::core::v1::{PodAffinity, PodAntiAffinity},
 };
 
-use crate::crd::{HbaseRole, APP_NAME};
+use crate::crd::{APP_NAME, HbaseRole};
 
 pub fn get_affinity(
     cluster_name: &str,
@@ -186,45 +186,39 @@ mod tests {
             HbaseRole::RestServer => (),
         };
 
-        assert_eq!(
-            affinity,
-            StackableAffinity {
-                pod_affinity: Some(PodAffinity {
-                    preferred_during_scheduling_ignored_during_execution: Some(expected_affinities),
-                    required_during_scheduling_ignored_during_execution: None,
-                }),
-                pod_anti_affinity: Some(PodAntiAffinity {
-                    preferred_during_scheduling_ignored_during_execution: Some(vec![
-                        WeightedPodAffinityTerm {
-                            pod_affinity_term: PodAffinityTerm {
-                                label_selector: Some(LabelSelector {
-                                    match_expressions: None,
-                                    match_labels: Some(BTreeMap::from([
-                                        ("app.kubernetes.io/name".to_string(), "hbase".to_string(),),
-                                        (
-                                            "app.kubernetes.io/instance".to_string(),
-                                            "simple-hbase".to_string(),
-                                        ),
-                                        (
-                                            "app.kubernetes.io/component".to_string(),
-                                            role.to_string(),
-                                        )
-                                    ]))
-                                }),
-                                match_label_keys: None,
-                                mismatch_label_keys: None,
-                                namespace_selector: None,
-                                namespaces: None,
-                                topology_key: "kubernetes.io/hostname".to_string(),
-                            },
-                            weight: 70
-                        }
-                    ]),
-                    required_during_scheduling_ignored_during_execution: None,
-                }),
-                node_affinity: None,
-                node_selector: None,
-            }
-        );
+        assert_eq!(affinity, StackableAffinity {
+            pod_affinity: Some(PodAffinity {
+                preferred_during_scheduling_ignored_during_execution: Some(expected_affinities),
+                required_during_scheduling_ignored_during_execution: None,
+            }),
+            pod_anti_affinity: Some(PodAntiAffinity {
+                preferred_during_scheduling_ignored_during_execution: Some(vec![
+                    WeightedPodAffinityTerm {
+                        pod_affinity_term: PodAffinityTerm {
+                            label_selector: Some(LabelSelector {
+                                match_expressions: None,
+                                match_labels: Some(BTreeMap::from([
+                                    ("app.kubernetes.io/name".to_string(), "hbase".to_string(),),
+                                    (
+                                        "app.kubernetes.io/instance".to_string(),
+                                        "simple-hbase".to_string(),
+                                    ),
+                                    ("app.kubernetes.io/component".to_string(), role.to_string(),)
+                                ]))
+                            }),
+                            match_label_keys: None,
+                            mismatch_label_keys: None,
+                            namespace_selector: None,
+                            namespaces: None,
+                            topology_key: "kubernetes.io/hostname".to_string(),
+                        },
+                        weight: 70
+                    }
+                ]),
+                required_during_scheduling_ignored_during_execution: None,
+            }),
+            node_affinity: None,
+            node_selector: None,
+        });
     }
 }
diff --git a/rust/operator-binary/src/crd/mod.rs b/rust/operator-binary/src/crd/mod.rs
@@ -20,11 +20,11 @@ use stackable_operator::{
         merge::{Atomic, Merge},
     },
     k8s_openapi::{
+        DeepMerge,
         api::core::v1::{EnvVar, PodTemplateSpec},
         apimachinery::pkg::api::resource::Quantity,
-        DeepMerge,
     },
-    kube::{runtime::reflector::ObjectRef, CustomResource, ResourceExt},
+    kube::{CustomResource, ResourceExt, runtime::reflector::ObjectRef},
     product_config_utils::Configuration,
     product_logging::{self, spec::Logging},
     role_utils::{GenericRoleConfig, JavaCommonConfig, Role, RoleGroupRef},
@@ -640,15 +640,14 @@ pub enum HbaseRole {
 
 impl HbaseRole {
     const DEFAULT_MASTER_GRACEFUL_SHUTDOWN_TIMEOUT: Duration = Duration::from_minutes_unchecked(20);
-    const DEFAULT_REGION_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT: Duration =
-        Duration::from_minutes_unchecked(60);
-    const DEFAULT_REST_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT: Duration =
-        Duration::from_minutes_unchecked(5);
-
     // Auto TLS certificate lifetime
     const DEFAULT_MASTER_SECRET_LIFETIME: Duration = Duration::from_days_unchecked(1);
     const DEFAULT_REGION_SECRET_LIFETIME: Duration = Duration::from_days_unchecked(1);
+    const DEFAULT_REGION_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT: Duration =
+        Duration::from_minutes_unchecked(60);
     const DEFAULT_REST_SECRET_LIFETIME: Duration = Duration::from_days_unchecked(1);
+    const DEFAULT_REST_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT: Duration =
+        Duration::from_minutes_unchecked(5);
 
     pub fn default_config(
         &self,
@@ -1153,27 +1152,31 @@ impl AnyServiceConfig {
             AnyServiceConfig::RestServer(config) => &config.resources,
         }
     }
+
     pub fn logging(&self) -> &Logging<Container> {
         match self {
             AnyServiceConfig::Master(config) => &config.logging,
             AnyServiceConfig::RegionServer(config) => &config.logging,
             AnyServiceConfig::RestServer(config) => &config.logging,
         }
     }
+
     pub fn affinity(&self) -> &StackableAffinity {
         match self {
             AnyServiceConfig::Master(config) => &config.affinity,
             AnyServiceConfig::RegionServer(config) => &config.affinity,
             AnyServiceConfig::RestServer(config) => &config.affinity,
         }
     }
+
     pub fn graceful_shutdown_timeout(&self) -> &Option<Duration> {
         match self {
             AnyServiceConfig::Master(config) => &config.graceful_shutdown_timeout,
             AnyServiceConfig::RegionServer(config) => &config.graceful_shutdown_timeout,
             AnyServiceConfig::RestServer(config) => &config.graceful_shutdown_timeout,
         }
     }
+
     pub fn requested_secret_lifetime(&self) -> Option<Duration> {
         match self {
             AnyServiceConfig::Master(config) => config.requested_secret_lifetime,
@@ -1243,7 +1246,7 @@ mod tests {
     use std::collections::{BTreeMap, HashMap};
 
     use indoc::indoc;
-    use product_config::{types::PropertyNameKind, ProductConfigManager};
+    use product_config::{ProductConfigManager, types::PropertyNameKind};
     use rstest::rstest;
     use stackable_operator::product_config_utils::{
         transform_all_roles_to_config, validate_all_roles_and_groups_config,
diff --git a/rust/operator-binary/src/discovery.rs b/rust/operator-binary/src/discovery.rs
@@ -11,7 +11,7 @@ use stackable_operator::{
 };
 
 use crate::{
-    crd::{v1alpha1, HbaseRole, HBASE_SITE_XML},
+    crd::{HBASE_SITE_XML, HbaseRole, v1alpha1},
     hbase_controller::build_recommended_labels,
     kerberos::{self, kerberos_discovery_config_properties},
     zookeeper::ZookeeperConnectionInformation,
diff --git a/rust/operator-binary/src/hbase_controller.rs b/rust/operator-binary/src/hbase_controller.rs
@@ -9,9 +9,9 @@ use std::{
 
 use const_format::concatcp;
 use product_config::{
-    types::PropertyNameKind,
-    writer::{to_hadoop_xml, to_java_properties_string, PropertiesWriterError},
     ProductConfigManager,
+    types::PropertyNameKind,
+    writer::{PropertiesWriterError, to_hadoop_xml, to_java_properties_string},
 };
 use snafu::{OptionExt, ResultExt, Snafu};
 use stackable_operator::{
@@ -20,8 +20,8 @@ use stackable_operator::{
         configmap::ConfigMapBuilder,
         meta::ObjectMetaBuilder,
         pod::{
-            container::ContainerBuilder, resources::ResourceRequirementsBuilder,
-            security::PodSecurityContextBuilder, PodBuilder,
+            PodBuilder, container::ContainerBuilder, resources::ResourceRequirementsBuilder,
+            security::PodSecurityContextBuilder,
         },
     },
     cluster_resources::{ClusterResourceApplyStrategy, ClusterResources},
@@ -37,9 +37,9 @@ use stackable_operator::{
         apimachinery::pkg::{apis::meta::v1::LabelSelector, util::intstr::IntOrString},
     },
     kube::{
-        core::{error_boundary, DeserializeGuard},
-        runtime::controller::Action,
         Resource, ResourceExt,
+        core::{DeserializeGuard, error_boundary},
+        runtime::controller::Action,
     },
     kvp::{Label, LabelError, Labels, ObjectLabels},
     logging::controller::ReconcilerError,
@@ -64,14 +64,15 @@ use stackable_operator::{
 use strum::{EnumDiscriminants, IntoStaticStr, ParseError};
 
 use crate::{
+    OPERATOR_NAME,
     config::jvm::{
         construct_global_jvm_args, construct_hbase_heapsize_env,
         construct_role_specific_non_heap_jvm_args,
     },
     crd::{
-        merged_env, v1alpha1, AnyServiceConfig, Container, HbaseClusterStatus, HbaseRole, APP_NAME,
-        HBASE_ENV_SH, HBASE_REST_PORT_NAME_HTTP, HBASE_REST_PORT_NAME_HTTPS, HBASE_SITE_XML,
-        JVM_SECURITY_PROPERTIES_FILE, SSL_CLIENT_XML, SSL_SERVER_XML,
+        APP_NAME, AnyServiceConfig, Container, HBASE_ENV_SH, HBASE_REST_PORT_NAME_HTTP,
+        HBASE_REST_PORT_NAME_HTTPS, HBASE_SITE_XML, HbaseClusterStatus, HbaseRole,
+        JVM_SECURITY_PROPERTIES_FILE, SSL_CLIENT_XML, SSL_SERVER_XML, merged_env, v1alpha1,
     },
     discovery::build_discovery_configmap,
     kerberos::{
@@ -80,12 +81,11 @@ use crate::{
     },
     operations::{graceful_shutdown::add_graceful_shutdown_config, pdb::add_pdbs},
     product_logging::{
-        extend_role_group_config_map, resolve_vector_aggregator_address,
-        CONTAINERDEBUG_LOG_DIRECTORY, STACKABLE_LOG_DIR,
+        CONTAINERDEBUG_LOG_DIRECTORY, STACKABLE_LOG_DIR, extend_role_group_config_map,
+        resolve_vector_aggregator_address,
     },
     security::{self, opa::HbaseOpaConfig},
     zookeeper::{self, ZookeeperConnectionInformation},
-    OPERATOR_NAME,
 };
 
 pub const HBASE_CONTROLLER_NAME: &str = "hbasecluster";
diff --git a/rust/operator-binary/src/kerberos.rs b/rust/operator-binary/src/kerberos.rs
@@ -5,17 +5,17 @@ use stackable_operator::{
     builder::{
         self,
         pod::{
+            PodBuilder,
             container::ContainerBuilder,
             volume::{SecretFormat, SecretOperatorVolumeSourceBuilder, VolumeBuilder},
-            PodBuilder,
         },
     },
-    kube::{runtime::reflector::ObjectRef, ResourceExt},
+    kube::{ResourceExt, runtime::reflector::ObjectRef},
     time::Duration,
     utils::cluster_info::KubernetesClusterInfo,
 };
 
-use crate::crd::{v1alpha1, TLS_STORE_DIR, TLS_STORE_PASSWORD, TLS_STORE_VOLUME_NAME};
+use crate::crd::{TLS_STORE_DIR, TLS_STORE_PASSWORD, TLS_STORE_VOLUME_NAME, v1alpha1};
 
 #[derive(Snafu, Debug)]
 pub enum Error {
diff --git a/rust/operator-binary/src/main.rs b/rust/operator-binary/src/main.rs
@@ -4,21 +4,22 @@ use clap::Parser;
 use futures::StreamExt;
 use hbase_controller::FULL_HBASE_CONTROLLER_NAME;
 use stackable_operator::{
+    YamlSchema,
     cli::{Command, ProductOperatorRun},
     k8s_openapi::api::{apps::v1::StatefulSet, core::v1::Service},
     kube::{
         core::DeserializeGuard,
         runtime::{
+            Controller,
             events::{Recorder, Reporter},
-            watcher, Controller,
+            watcher,
         },
     },
     logging::controller::report_controller_reconciled,
     shared::yaml::SerializeOptions,
-    YamlSchema,
 };
 
-use crate::crd::{v1alpha1, HbaseCluster, APP_NAME};
+use crate::crd::{APP_NAME, HbaseCluster, v1alpha1};
 
 mod config;
 mod crd;
@@ -80,13 +81,10 @@ async fn main() -> anyhow::Result<()> {
             )
             .await?;
 
-            let event_recorder = Arc::new(Recorder::new(
-                client.as_kube_client(),
-                Reporter {
-                    controller: FULL_HBASE_CONTROLLER_NAME.to_string(),
-                    instance: None,
-                },
-            ));
+            let event_recorder = Arc::new(Recorder::new(client.as_kube_client(), Reporter {
+                controller: FULL_HBASE_CONTROLLER_NAME.to_string(),
+                instance: None,
+            }));
 
             Controller::new(
                 watch_namespace.get_api::<DeserializeGuard<v1alpha1::HbaseCluster>>(&client),
diff --git a/rust/operator-binary/src/operations/pdb.rs b/rust/operator-binary/src/operations/pdb.rs
@@ -5,9 +5,9 @@ use stackable_operator::{
 };
 
 use crate::{
-    crd::{v1alpha1, HbaseRole, APP_NAME},
-    hbase_controller::HBASE_CONTROLLER_NAME,
     OPERATOR_NAME,
+    crd::{APP_NAME, HbaseRole, v1alpha1},
+    hbase_controller::HBASE_CONTROLLER_NAME,
 };
 
 #[derive(Snafu, Debug)]
diff --git a/rust/operator-binary/src/product_logging.rs b/rust/operator-binary/src/product_logging.rs
@@ -15,7 +15,7 @@ use stackable_operator::{
 };
 
 use crate::{
-    crd::{v1alpha1, Container},
+    crd::{Container, v1alpha1},
     hbase_controller::MAX_HBASE_LOG_FILES_SIZE,
 };
 
diff --git a/rust/operator-binary/src/security/opa.rs b/rust/operator-binary/src/security/opa.rs
@@ -46,6 +46,7 @@ impl HbaseOpaConfig {
             ..HbaseOpaConfig::default()
         }
     }
+
     pub async fn from_opa_config(
         client: &Client,
         hbase: &v1alpha1::HbaseCluster,
diff --git a/rust/operator-binary/src/zookeeper.rs b/rust/operator-binary/src/zookeeper.rs
@@ -105,9 +105,11 @@ impl ZookeeperConnectionInformation {
 
         // Check if a user points to a discovery CM of a HBaseCluster rather than a ZNode.
         if chroot == "/" {
-            warn!("It is recommended to let the HBase cluster point to a discovery ConfigMap of a ZNode rater than a ZookeeperCluster. \
+            warn!(
+                "It is recommended to let the HBase cluster point to a discovery ConfigMap of a ZNode rater than a ZookeeperCluster. \
             This prevents accidental reuse of the same Zookeeper path for multiple product instances. \
-            See https://docs.stackable.tech/home/stable/zookeeper/getting_started/first_steps for details");
+            See https://docs.stackable.tech/home/stable/zookeeper/getting_started/first_steps for details"
+            );
             chroot = "/hbase".to_string();
         } else {
             chroot = format!("{chroot}/hbase");

Original file line number	Diff line number	Diff line change
`@@ -46,6 +46,7 @@ impl HbaseOpaConfig {`
`46`	`46`	`..HbaseOpaConfig::default()`
`47`	`47`	`}`
`48`	`48`	`}`
	`49`	`+`
`49`	`50`	`pub async fn from_opa_config(`
`50`	`51`	`client: &Client,`
`51`	`52`	`hbase: &v1alpha1::HbaseCluster,`