chore: Bump stackable-operator to 0.93.0 and bump deps

Bump stackable-operator to 0.93.0 which versions common CRD structs.

Author: NickLarsenNZ

Cargo.lock

@@ -10,10 +10,10 @@ edition = "2021"
 repository = "https://github.com/stackabletech/listener-operator"
 
 [workspace.dependencies]
-stackable-operator = { git = "https://github.com/stackabletech/operator-rs.git", features = ["telemetry", "versioned"], tag = "stackable-operator-0.92.0" }
+stackable-operator = { git = "https://github.com/stackabletech/operator-rs.git", features = ["telemetry", "versioned"], tag = "stackable-operator-0.93.0" }
 
 anyhow = "1.0"
-built = { version = "0.7", features = ["chrono", "git2"] }
+built = { version = "0.8", features = ["chrono", "git2"] }
 clap = "4.5"
 const_format = "0.2"
 futures = { version = "0.3" }
@@ -30,9 +30,9 @@ strum = { version = "0.27", features = ["derive"] }
 socket2 = { version = "0.5", features = ["all"] }
 tokio = { version = "1.40", features = ["full"] }
 tokio-stream = { version = "0.1", features = ["net"] }
-tonic = "0.12"
-tonic-build = "0.12"
-tonic-reflection = "0.12"
+tonic = "0.13"
+tonic-build = "0.13"
+tonic-reflection = "0.13"
 tracing = "0.1.40"
 walkdir = "2.5.0"
 

Cargo.nix

@@ -2,7 +2,7 @@ use csi_grpc as csi;
 use serde::{Deserialize, de::IntoDeserializer};
 use snafu::{OptionExt, ResultExt, Snafu};
 use stackable_operator::{
-    commons::listener::{Listener, ListenerClass, ServiceType},
+    crd::listener,
     k8s_openapi::api::core::v1::PersistentVolumeClaim,
     kube::{core::DynamicObject, runtime::reflector::ObjectRef},
 };
@@ -36,7 +36,9 @@ enum CreateVolumeError {
     #[snafu(display("failed to decode volume context"))]
     DecodeVolumeContext { source: serde::de::value::Error },
     #[snafu(display("{listener} does not specify a listener class"))]
-    NoListenerClass { listener: ObjectRef<Listener> },
+    NoListenerClass {
+        listener: ObjectRef<listener::v1alpha1::Listener>,
+    },
 }
 
 impl From<CreateVolumeError> for Status {
@@ -99,10 +101,10 @@ impl csi::v1::controller_server::Controller for ListenerOperatorController {
             ListenerSelector::Listener(listener_name) => {
                 let listener = self
                     .client
-                    .get::<Listener>(&listener_name, &ns)
+                    .get::<listener::v1alpha1::Listener>(&listener_name, &ns)
                     .await
                     .with_context(|_| GetObjectSnafu {
-                        obj: ObjectRef::<Listener>::new(&listener_name)
+                        obj: ObjectRef::<listener::v1alpha1::Listener>::new(&listener_name)
                             .within(&ns)
                             .erase(),
                     })?;
@@ -118,10 +120,10 @@ impl csi::v1::controller_server::Controller for ListenerOperatorController {
         };
         let listener_class = self
             .client
-            .get::<ListenerClass>(&listener_class_name, &())
+            .get::<listener::v1alpha1::ListenerClass>(&listener_class_name, &())
             .await
             .with_context(|_| GetObjectSnafu {
-                obj: ObjectRef::<ListenerClass>::new(&listener_class_name)
+                obj: ObjectRef::<listener::v1alpha1::ListenerClass>::new(&listener_class_name)
                     .within(&ns)
                     .erase(),
             })?;
@@ -134,15 +136,16 @@ impl csi::v1::controller_server::Controller for ListenerOperatorController {
                 accessible_topology: match listener_class.spec.service_type {
                     // Pick the top node (as selected by the CSI client) and "stick" to that
                     // Since we want clients to have a stable address to connect to
-                    ServiceType::NodePort => request
+                    listener::v1alpha1::ServiceType::NodePort => request
                         .accessibility_requirements
                         .unwrap_or_default()
                         .preferred
                         .into_iter()
                         .take(1)
                         .collect(),
                     // Load balancers and services of type ClusterIP have no relationship to any particular node, so don't try to be sticky
-                    ServiceType::LoadBalancer | ServiceType::ClusterIP => Vec::new(),
+                    listener::v1alpha1::ServiceType::LoadBalancer
+                    | listener::v1alpha1::ServiceType::ClusterIP => Vec::new(),
                 },
             }),
         }))

Cargo.toml

@@ -5,10 +5,7 @@ use serde::{Deserialize, de::IntoDeserializer};
 use snafu::{OptionExt, ResultExt, Snafu};
 use stackable_operator::{
     builder::meta::OwnerReferenceBuilder,
-    commons::listener::{
-        Listener, ListenerClass, ListenerIngress, ListenerPort, ListenerSpec, PodListener,
-        PodListenerScope, PodListeners, PodListenersSpec,
-    },
+    crd::listener,
     k8s_openapi::api::core::v1::{Node, PersistentVolume, PersistentVolumeClaim, Pod, Volume},
     kube::{
         core::{DynamicObject, ObjectMeta},
@@ -63,17 +60,19 @@ enum PublishVolumeError {
     #[snafu(display("failed to generate {listener}'s PersistentVolume selector"))]
     ListenerPvReference {
         source: ListenerPersistentVolumeLabelError,
-        listener: ObjectRef<Listener>,
+        listener: ObjectRef<listener::v1alpha1::Listener>,
     },
 
     #[snafu(display("failed to generate {listener}'s pod selector"))]
     ListenerPodSelector {
         source: ListenerMountedPodLabelError,
-        listener: ObjectRef<Listener>,
+        listener: ObjectRef<listener::v1alpha1::Listener>,
     },
 
     #[snafu(display("{listener} has no associated ListenerClass"))]
-    ListenerHasNoClass { listener: ObjectRef<Listener> },
+    ListenerHasNoClass {
+        listener: ObjectRef<listener::v1alpha1::Listener>,
+    },
 
     #[snafu(display("{pod} has not been scheduled to a node yet"))]
     PodHasNoNode { pod: ObjectRef<Pod> },
@@ -86,7 +85,7 @@ enum PublishVolumeError {
     #[snafu(display("failed to apply {listener}"))]
     ApplyListener {
         source: stackable_operator::client::Error,
-        listener: ObjectRef<Listener>,
+        listener: ObjectRef<listener::v1alpha1::Listener>,
     },
 
     #[snafu(display("failed to add listener label to {pv}"))]
@@ -114,7 +113,7 @@ enum PublishVolumeError {
     WritePodListeners {
         source: stackable_operator::client::Error,
         create_error: stackable_operator::client::Error,
-        pod_listeners: ObjectRef<PodListeners>,
+        pod_listeners: ObjectRef<listener::v1alpha1::PodListeners>,
     },
 
     #[snafu(display("failed to find Pod volume corresponding for {pvc}"))]
@@ -244,17 +243,17 @@ impl csi::v1::node_server::Node for ListenerOperatorNode {
         let listener = match listener_selector {
             ListenerSelector::Listener(listener_name) => self
                 .client
-                .get::<Listener>(&listener_name, &ns)
+                .get::<listener::v1alpha1::Listener>(&listener_name, &ns)
                 .await
                 .with_context(|_| GetObjectSnafu {
                     obj: {
-                        ObjectRef::<Listener>::new(&listener_name)
+                        ObjectRef::<listener::v1alpha1::Listener>::new(&listener_name)
                             .within(&ns)
                             .erase()
                     },
                 })?,
             ListenerSelector::ListenerClass(listener_class_name) => {
-                let listener = Listener {
+                let listener = listener::v1alpha1::Listener {
                     metadata: ObjectMeta {
                         namespace: Some(ns.clone()),
                         name: Some(pvc_name.to_string()),
@@ -269,15 +268,15 @@ impl csi::v1::node_server::Node for ListenerOperatorNode {
                         labels: pvc.metadata.labels,
                         ..Default::default()
                     },
-                    spec: ListenerSpec {
+                    spec: listener::v1alpha1::ListenerSpec {
                         class_name: Some(listener_class_name),
                         ports: Some(
                             pod.spec
                                 .iter()
                                 .flat_map(|ps| &ps.containers)
                                 .flat_map(|ctr| &ctr.ports)
                                 .flatten()
-                                .map(|port| ListenerPort {
+                                .map(|port| listener::v1alpha1::ListenerPort {
                                     name: port
                                         .name
                                         .clone()
@@ -420,9 +419,9 @@ impl csi::v1::node_server::Node for ListenerOperatorNode {
 /// (and so can't be found in `Endpoints`).
 async fn local_listener_addresses_for_pod(
     client: &stackable_operator::client::Client,
-    listener: &Listener,
+    listener: &listener::v1alpha1::Listener,
     pod: &Pod,
-) -> Result<Vec<ListenerIngress>, PublishVolumeError> {
+) -> Result<Vec<listener::v1alpha1::ListenerIngress>, PublishVolumeError> {
     use publish_volume_error::*;
 
     if let Some(node_ports) = listener
@@ -452,20 +451,23 @@ async fn local_listener_addresses_for_pod(
                     listener: ObjectRef::from_obj(listener),
                 })?;
         let listener_class = client
-            .get::<ListenerClass>(listener_class_name, &())
+            .get::<listener::v1alpha1::ListenerClass>(listener_class_name, &())
             .await
             .with_context(|_| GetObjectSnafu {
-                obj: ObjectRef::<ListenerClass>::new(listener_class_name).erase(),
+                obj: ObjectRef::<listener::v1alpha1::ListenerClass>::new(listener_class_name)
+                    .erase(),
             })?;
 
         Ok(node_primary_addresses(&node)
             .pick(listener_class.spec.resolve_preferred_address_type())
-            .map(|(address, address_type)| ListenerIngress {
-                // nodes: Some(vec![node_name.to_string()]),
-                address: address.to_string(),
-                address_type,
-                ports: node_ports,
-            })
+            .map(
+                |(address, address_type)| listener::v1alpha1::ListenerIngress {
+                    // nodes: Some(vec![node_name.to_string()]),
+                    address: address.to_string(),
+                    address_type,
+                    ports: node_ports,
+                },
+            )
             .into_iter()
             .collect())
     } else {
@@ -484,8 +486,8 @@ async fn publish_pod_listener(
     pod: &Pod,
     pod_name: &str,
     pvc_name: &str,
-    listener: &Listener,
-    listener_addresses: &[ListenerIngress],
+    listener: &listener::v1alpha1::Listener,
+    listener_addresses: &[listener::v1alpha1::ListenerIngress],
 ) -> Result<(), PublishVolumeError> {
     use publish_volume_error::*;
     let listener_pod_volume = pod
@@ -508,7 +510,7 @@ async fn publish_pod_listener(
         .with_context(|| FindPodVolumeForPvcSnafu {
             pvc: ObjectRef::<PersistentVolumeClaim>::new(pvc_name),
         })?;
-    let pod_listeners = PodListeners {
+    let pod_listeners = listener::v1alpha1::PodListeners {
         metadata: ObjectMeta {
             name: pod.metadata.uid.as_deref().map(|uid| format!("pod-{uid}")),
             namespace: pod.metadata.namespace.clone(),
@@ -520,20 +522,23 @@ async fn publish_pod_listener(
             ]),
             ..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
+        spec: listener::v1alpha1::PodListenersSpec {
+            listeners: [(
+                listener_pod_volume.name.clone(),
+                listener::v1alpha1::PodListener {
+                    scope: if listener
+                        .status
+                        .as_ref()
+                        .and_then(|s| s.node_ports.as_ref())
+                        .is_some()
+                    {
+                        listener::v1alpha1::PodListenerScope::Node
+                    } else {
+                        listener::v1alpha1::PodListenerScope::Cluster
+                    },
+                    ingress_addresses: Some(listener_addresses.to_vec()),
                 },
-                ingress_addresses: Some(listener_addresses.to_vec()),
-            })]
+            )]
             .into(),
         },
     };
@@ -556,7 +561,7 @@ mod pod_dir {
     use std::path::Path;
 
     use snafu::{OptionExt, ResultExt, Snafu};
-    use stackable_operator::commons::listener::ListenerIngress;
+    use stackable_operator::crd::listener;
 
     #[derive(Snafu, Debug)]
     pub enum Error {
@@ -570,7 +575,7 @@ mod pod_dir {
 
     pub async fn write_listener_info_to_pod_dir(
         target_path: &Path,
-        listener_addrs: &[ListenerIngress],
+        listener_addrs: &[listener::v1alpha1::ListenerIngress],
     ) -> Result<(), Error> {
         let addrs_path = target_path.join("addresses");
         tokio::fs::create_dir_all(&addrs_path).await?;