fix: rustfmt lint

NickLarsenNZ · NickLarsenNZ · commit a9145391fba0 · 2025-04-02T19:43:57.000+02:00
diff --git a/rust/olm-deployer/src/data.rs b/rust/olm-deployer/src/data.rs
@@ -1,5 +1,5 @@
-use anyhow::{anyhow, Context};
-use stackable_operator::kube::{api::DynamicObject, ResourceExt};
+use anyhow::{Context, anyhow};
+use stackable_operator::kube::{ResourceExt, api::DynamicObject};
 
 pub fn container<'a>(
     target: &'a mut DynamicObject,
diff --git a/rust/olm-deployer/src/env/mod.rs b/rust/olm-deployer/src/env/mod.rs
@@ -1,8 +1,8 @@
 use stackable_operator::{
     k8s_openapi::api::{apps::v1::Deployment, core::v1::EnvVar},
     kube::{
-        api::{DynamicObject, GroupVersionKind},
         ResourceExt,
+        api::{DynamicObject, GroupVersionKind},
     },
 };
 
diff --git a/rust/olm-deployer/src/main.rs b/rust/olm-deployer/src/main.rs
@@ -17,8 +17,8 @@ mod owner;
 mod resources;
 mod tolerations;
 
-use anyhow::{anyhow, bail, Context, Result};
-use clap::{crate_description, crate_version, Parser};
+use anyhow::{Context, Result, anyhow, bail};
+use clap::{Parser, crate_description, crate_version};
 use stackable_operator::{
     cli::Command,
     client,
diff --git a/rust/olm-deployer/src/owner/mod.rs b/rust/olm-deployer/src/owner/mod.rs
@@ -5,9 +5,9 @@ use stackable_operator::{
         apimachinery::pkg::apis::meta::v1::OwnerReference,
     },
     kube::{
+        Resource,
         api::{DynamicObject, ResourceExt},
         discovery::Scope,
-        Resource,
     },
 };
 
diff --git a/rust/olm-deployer/src/resources/mod.rs b/rust/olm-deployer/src/resources/mod.rs
@@ -1,8 +1,8 @@
 use stackable_operator::{
     k8s_openapi::api::{apps::v1::Deployment, core::v1::ResourceRequirements},
     kube::{
-        api::{DynamicObject, GroupVersionKind},
         ResourceExt,
+        api::{DynamicObject, GroupVersionKind},
     },
 };
 
diff --git a/rust/olm-deployer/src/tolerations/mod.rs b/rust/olm-deployer/src/tolerations/mod.rs
@@ -1,9 +1,9 @@
-use anyhow::{anyhow, Context};
+use anyhow::{Context, anyhow};
 use stackable_operator::{
     k8s_openapi::api::{apps::v1::Deployment, core::v1::Toleration},
     kube::{
-        api::{DynamicObject, GroupVersionKind},
         ResourceExt,
+        api::{DynamicObject, GroupVersionKind},
     },
 };
 
@@ -27,10 +27,12 @@ pub(super) fn maybe_copy_tolerations(
                     .pointer_mut("/spec")
                     .context(anyhow!("DaemonSet named [{tname}] has empty .spec"))?,
                 path,
-            )? = serde_json::json!(tolerations
-                .iter()
-                .map(|t| serde_json::json!(t))
-                .collect::<Vec<serde_json::Value>>());
+            )? = serde_json::json!(
+                tolerations
+                    .iter()
+                    .map(|t| serde_json::json!(t))
+                    .collect::<Vec<serde_json::Value>>()
+            );
         }
     }
 
@@ -114,11 +116,13 @@ spec:
         let mut daemonset = DAEMONSET.clone();
         maybe_copy_tolerations(&DEPLOYMENT, &mut daemonset, &gvk)?;
 
-        let expected = serde_json::json!(deployment_tolerations(&DEPLOYMENT)
-            .unwrap()
-            .iter()
-            .map(|t| serde_json::json!(t))
-            .collect::<Vec<serde_json::Value>>());
+        let expected = serde_json::json!(
+            deployment_tolerations(&DEPLOYMENT)
+                .unwrap()
+                .iter()
+                .map(|t| serde_json::json!(t))
+                .collect::<Vec<serde_json::Value>>()
+        );
 
         assert_eq!(
             daemonset.data.pointer("/spec/template/spec/tolerations"),
diff --git a/rust/operator-binary/src/csi_server/controller.rs b/rust/operator-binary/src/csi_server/controller.rs
@@ -1,5 +1,5 @@
 use csi_grpc as csi;
-use serde::{de::IntoDeserializer, Deserialize};
+use serde::{Deserialize, de::IntoDeserializer};
 use snafu::{OptionExt, ResultExt, Snafu};
 use stackable_operator::{
     commons::listener::{Listener, ListenerClass, ServiceType},
@@ -8,7 +8,7 @@ use stackable_operator::{
 };
 use tonic::{Request, Response, Status};
 
-use super::{tonic_unimplemented, ListenerSelector, ListenerVolumeContext};
+use super::{ListenerSelector, ListenerVolumeContext, tonic_unimplemented};
 use crate::utils::error::error_full_message;
 
 pub struct ListenerOperatorController {
diff --git a/rust/operator-binary/src/csi_server/node.rs b/rust/operator-binary/src/csi_server/node.rs
@@ -1,7 +1,7 @@
 use std::{fmt::Debug, path::PathBuf};
 
 use csi_grpc::{self as csi, v1::Topology};
-use serde::{de::IntoDeserializer, Deserialize};
+use serde::{Deserialize, de::IntoDeserializer};
 use snafu::{OptionExt, ResultExt, Snafu};
 use stackable_operator::{
     builder::meta::OwnerReferenceBuilder,
@@ -17,11 +17,11 @@ use stackable_operator::{
 };
 use tonic::{Request, Response, Status};
 
-use super::{tonic_unimplemented, ListenerSelector, ListenerVolumeContext};
+use super::{ListenerSelector, ListenerVolumeContext, tonic_unimplemented};
 use crate::{
     listener_controller::{
-        listener_mounted_pod_label, listener_persistent_volume_label, ListenerMountedPodLabelError,
-        ListenerPersistentVolumeLabelError,
+        ListenerMountedPodLabelError, ListenerPersistentVolumeLabelError,
+        listener_mounted_pod_label, listener_persistent_volume_label,
     },
     utils::{address::node_primary_addresses, error::error_full_message},
 };
@@ -258,10 +258,12 @@ impl csi::v1::node_server::Node for ListenerOperatorNode {
                     metadata: ObjectMeta {
                         namespace: Some(ns.clone()),
                         name: Some(pvc_name.to_string()),
-                        owner_references: Some(vec![OwnerReferenceBuilder::new()
-                            .initialize_from_resource(&pv)
-                            .build()
-                            .context(BuildListenerOwnerRefSnafu)?]),
+                        owner_references: Some(vec![
+                            OwnerReferenceBuilder::new()
+                                .initialize_from_resource(&pv)
+                                .build()
+                                .context(BuildListenerOwnerRefSnafu)?,
+                        ]),
                         // Propagate the labels from the PVC to the Listener object, so it can be found easier, e.g. to
                         // determine the endpoints of stacklets.
                         labels: pvc.metadata.labels,
@@ -302,21 +304,17 @@ impl csi::v1::node_server::Node for ListenerOperatorNode {
         // Add listener label to PV, allowing traffic to be directed based on reservations, rather than which replicas are *currently* active.
         // See https://github.com/stackabletech/listener-operator/issues/220
         self.client
-            .apply_patch(
-                FIELD_MANAGER_SCOPE,
-                &pv,
-                &PersistentVolume {
-                    metadata: ObjectMeta {
-                        labels: Some(listener_persistent_volume_label(&listener).context(
-                            ListenerPvReferenceSnafu {
-                                listener: ObjectRef::from_obj(&listener),
-                            },
-                        )?),
-                        ..Default::default()
-                    },
+            .apply_patch(FIELD_MANAGER_SCOPE, &pv, &PersistentVolume {
+                metadata: ObjectMeta {
+                    labels: Some(listener_persistent_volume_label(&listener).context(
+                        ListenerPvReferenceSnafu {
+                            listener: ObjectRef::from_obj(&listener),
+                        },
+                    )?),
                     ..Default::default()
                 },
-            )
+                ..Default::default()
+            })
             .await
             .with_context(|_| AddListenerLabelToPvSnafu {
                 pv: ObjectRef::from_obj(&pv),
@@ -327,23 +325,20 @@ impl csi::v1::node_server::Node for ListenerOperatorNode {
             // IMPORTANT
             // Use a merge patch rather than an apply so that we don't delete labels added by other listener volumes.
             // Volumes aren't hot-swappable anyway, and all labels will be removed when the pod is deleted.
-            .merge_patch(
-                &pod,
-                &Pod {
-                    metadata: ObjectMeta {
-                        labels: Some(
-                            [listener_mounted_pod_label(&listener).context(
-                                ListenerPodSelectorSnafu {
-                                    listener: ObjectRef::from_obj(&listener),
-                                },
-                            )?]
-                            .into(),
-                        ),
-                        ..Default::default()
-                    },
+            .merge_patch(&pod, &Pod {
+                metadata: ObjectMeta {
+                    labels: Some(
+                        [listener_mounted_pod_label(&listener).context(
+                            ListenerPodSelectorSnafu {
+                                listener: ObjectRef::from_obj(&listener),
+                            },
+                        )?]
+                        .into(),
+                    ),
                     ..Default::default()
                 },
-            )
+                ..Default::default()
+            })
             .await
             .with_context(|_| AddListenerLabelToPodSnafu {
                 pod: ObjectRef::from_obj(&pod),
@@ -517,29 +512,28 @@ async fn publish_pod_listener(
         metadata: ObjectMeta {
             name: pod.metadata.uid.as_deref().map(|uid| format!("pod-{uid}")),
             namespace: pod.metadata.namespace.clone(),
-            owner_references: Some(vec![OwnerReferenceBuilder::new()
-                .initialize_from_resource(pod)
-                .build()
-                .context(BuildListenerOwnerRefSnafu)?]),
+            owner_references: Some(vec![
+                OwnerReferenceBuilder::new()
+                    .initialize_from_resource(pod)
+                    .build()
+                    .context(BuildListenerOwnerRefSnafu)?,
+            ]),
             ..Default::default()
         },
         spec: PodListenersSpec {
-            listeners: [(
-                listener_pod_volume.name.clone(),
-                PodListener {
-                    scope: if listener
-                        .status
-                        .as_ref()
-                        .and_then(|s| s.node_ports.as_ref())
-                        .is_some()
-                    {
-                        PodListenerScope::Node
-                    } else {
-                        PodListenerScope::Cluster
-                    },
-                    ingress_addresses: Some(listener_addresses.to_vec()),
+            listeners: [(listener_pod_volume.name.clone(), PodListener {
+                scope: if listener
+                    .status
+                    .as_ref()
+                    .and_then(|s| s.node_ports.as_ref())
+                    .is_some()
+                {
+                    PodListenerScope::Node
+                } else {
+                    PodListenerScope::Cluster
                 },
-            )]
+                ingress_addresses: Some(listener_addresses.to_vec()),
+            })]
             .into(),
         },
     };
diff --git a/rust/operator-binary/src/listener_controller.rs b/rust/operator-binary/src/listener_controller.rs
@@ -5,8 +5,8 @@ use std::{
 
 use const_format::concatcp;
 use futures::{
-    future::{try_join, try_join_all},
     StreamExt,
+    future::{try_join, try_join_all},
 };
 use snafu::{OptionExt, ResultExt, Snafu};
 #[cfg(doc)]
@@ -24,26 +24,26 @@ use stackable_operator::{
         apimachinery::pkg::apis::meta::v1::LabelSelector,
     },
     kube::{
+        Resource, ResourceExt,
         api::{DynamicObject, ObjectMeta},
-        core::{error_boundary, DeserializeGuard},
+        core::{DeserializeGuard, error_boundary},
         runtime::{
             controller,
             events::{Recorder, Reporter},
             reflector::ObjectRef,
             watcher,
         },
-        Resource, ResourceExt,
     },
     kvp::{Annotations, Labels},
-    logging::controller::{report_controller_reconciled, ReconcilerError},
+    logging::controller::{ReconcilerError, report_controller_reconciled},
     time::Duration,
 };
 use strum::IntoStaticStr;
 
 use crate::{
-    csi_server::node::NODE_TOPOLOGY_LABEL_HOSTNAME,
-    utils::address::{node_primary_addresses, AddressCandidates},
     APP_NAME, OPERATOR_KEY,
+    csi_server::node::NODE_TOPOLOGY_LABEL_HOSTNAME,
+    utils::address::{AddressCandidates, node_primary_addresses},
 };
 
 const OPERATOR_NAME: &str = "listeners.stackable.tech";
@@ -56,13 +56,10 @@ pub async fn run(client: stackable_operator::client::Client) {
         watcher::Config::default(),
     );
     let listener_store = controller.store();
-    let event_recorder = Arc::new(Recorder::new(
-        client.as_kube_client(),
-        Reporter {
-            controller: FULL_CONTROLLER_NAME.to_string(),
-            instance: None,
-        },
-    ));
+    let event_recorder = Arc::new(Recorder::new(client.as_kube_client(), Reporter {
+        controller: FULL_CONTROLLER_NAME.to_string(),
+        instance: None,
+    }));
     controller
         .owns(
             client.get_all_api::<DeserializeGuard<Service>>(),
@@ -302,15 +299,12 @@ pub async fn reconcile(
                  port,
                  protocol,
              }| {
-                (
-                    (protocol, name),
-                    ServicePort {
-                        name: Some(name.clone()),
-                        protocol: protocol.clone(),
-                        port: *port,
-                        ..Default::default()
-                    },
-                )
+                ((protocol, name), ServicePort {
+                    name: Some(name.clone()),
+                    protocol: protocol.clone(),
+                    port: *port,
+                    ..Default::default()
+                })
             },
         )
         // Deduplicate ports by (protocol, name)
@@ -527,13 +521,10 @@ async fn node_names_for_nodeport_listener(
     let (pvs, endpoints) = try_join(
         async {
             client
-                .list_with_label_selector::<PersistentVolume>(
-                    &(),
-                    &LabelSelector {
-                        match_labels: Some(listener_persistent_volume_label(listener).unwrap()),
-                        ..Default::default()
-                    },
-                )
+                .list_with_label_selector::<PersistentVolume>(&(), &LabelSelector {
+                    match_labels: Some(listener_persistent_volume_label(listener).unwrap()),
+                    ..Default::default()
+                })
                 .await
                 .context(GetListenerPvsSnafu)
         },
diff --git a/rust/operator-binary/src/main.rs b/rust/operator-binary/src/main.rs
@@ -1,24 +1,24 @@
 use std::{os::unix::prelude::FileTypeExt, path::PathBuf};
 
-use clap::{crate_description, crate_version, Parser};
+use clap::{Parser, crate_description, crate_version};
 use csi_grpc::v1::{
     controller_server::ControllerServer, identity_server::IdentityServer, node_server::NodeServer,
 };
 use csi_server::{
     controller::ListenerOperatorController, identity::ListenerOperatorIdentity,
     node::ListenerOperatorNode,
 };
-use futures::{pin_mut, FutureExt, TryStreamExt};
+use futures::{FutureExt, TryStreamExt, pin_mut};
 use stackable_operator::{
+    CustomResourceExt,
     commons::listener::{Listener, ListenerClass, PodListeners},
     logging::TracingTarget,
     utils::cluster_info::KubernetesClusterInfoOpts,
-    CustomResourceExt,
 };
-use tokio::signal::unix::{signal, SignalKind};
+use tokio::signal::unix::{SignalKind, signal};
 use tokio_stream::wrappers::UnixListenerStream;
 use tonic::transport::Server;
-use utils::unix_stream::{uds_bind_private, TonicUnixStream};
+use utils::unix_stream::{TonicUnixStream, uds_bind_private};
 
 mod csi_server;
 mod listener_controller;
