Move enum

Author: sbernauer

crates/stackable-operator/src/builder/pod/volume.rs

@@ -14,6 +14,7 @@ use tracing::warn;
 
 use crate::{
     builder::meta::ObjectMetaBuilder,
+    commons::secret_class::SecretClassVolumeProvisionParts,
     kvp::{Annotation, AnnotationError, Annotations, LabelError, Labels},
 };
 
@@ -281,20 +282,20 @@ pub struct SecretOperatorVolumeSourceBuilder {
     kerberos_service_names: Vec<String>,
     tls_pkcs12_password: Option<String>,
     auto_tls_cert_lifetime: Option<Duration>,
-    provision_parts: SecretOperatorVolumeProvisionParts,
+    provision_parts: SecretClassVolumeProvisionParts,
 }
 
 impl SecretOperatorVolumeSourceBuilder {
     /// Creates a builder for a secret-operator volume that uses the specified SecretClass to
-    /// request the specified [`SecretOperatorVolumeProvisionParts`].
+    /// request the specified [`SecretClassVolumeProvisionParts`].
     ///
     /// This function forces the caller to make an explicit choice if the public parts are
     /// sufficient or if private (e.g. a certificate for the Pod) parts are needed as well.
     /// This is done to avoid accidentally requesting too much parts. For details see
     /// [this issue](https://github.com/stackabletech/issues/issues/547).
     pub fn new(
         secret_class: impl Into<String>,
-        provision_parts: SecretOperatorVolumeProvisionParts,
+        provision_parts: SecretClassVolumeProvisionParts,
     ) -> Self {
         Self {
             secret_class: secret_class.into(),
@@ -433,20 +434,6 @@ pub enum SecretOperatorVolumeScope {
     ListenerVolume { name: String },
 }
 
-/// What parts secret-operator should provision into the requested volume.
-#[derive(Clone, Debug, PartialEq, Eq, strum::AsRefStr)]
-#[strum(serialize_all = "kebab-case")]
-pub enum SecretOperatorVolumeProvisionParts {
-    /// Only provision public parts, such as the CA certificate (either as PEM or truststore) or
-    /// `krb5.conf`.
-    Public,
-
-    /// Provision all parts, which includes all [`Public`](SecretOperatorVolumeProvisionParts::Public)
-    /// ones as well as additional private parts, such as a TLS cert + private key, a keystore or a
-    /// keytab.
-    PublicPrivate,
-}
-
 /// Reference to a listener class or listener name
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ListenerReference {

crates/stackable-operator/src/client.rs

@@ -590,7 +590,7 @@ impl Client {
 pub trait GetApi: Resource + Sized {
     /// The namespace type for `Self`'s scope.
     ///
-    /// This will be [`str`] for namespaced resource, and [`()`] for cluster-scoped resources.
+    /// This will be [`str`] for namespaced resource, and `()` for cluster-scoped resources.
     type Namespace: ?Sized;
     /// Get a [`kube::Api`] for `Self`'s native scope..
     fn get_api(client: kube::Client, ns: &Self::Namespace) -> kube::Api<Self>

crates/stackable-operator/src/commons/secret_class.rs

@@ -4,8 +4,7 @@ use serde::{Deserialize, Serialize};
 use snafu::{ResultExt, Snafu};
 
 use crate::builder::pod::volume::{
-    SecretOperatorVolumeProvisionParts, SecretOperatorVolumeSourceBuilder,
-    SecretOperatorVolumeSourceBuilderError, VolumeBuilder,
+    SecretOperatorVolumeSourceBuilder, SecretOperatorVolumeSourceBuilderError, VolumeBuilder,
 };
 
 #[derive(Debug, PartialEq, Snafu)]
@@ -39,7 +38,7 @@ impl SecretClassVolume {
 
     pub fn to_ephemeral_volume_source(
         &self,
-        provision_parts: SecretOperatorVolumeProvisionParts,
+        provision_parts: SecretClassVolumeProvisionParts,
     ) -> Result<EphemeralVolumeSource, SecretClassVolumeError> {
         let mut secret_operator_volume_builder =
             SecretOperatorVolumeSourceBuilder::new(&self.secret_class, provision_parts);
@@ -67,7 +66,7 @@ impl SecretClassVolume {
     pub fn to_volume(
         &self,
         volume_name: &str,
-        provision_parts: SecretOperatorVolumeProvisionParts,
+        provision_parts: SecretClassVolumeProvisionParts,
     ) -> Result<Volume, SecretClassVolumeError> {
         let ephemeral = self.to_ephemeral_volume_source(provision_parts)?;
         Ok(VolumeBuilder::new(volume_name).ephemeral(ephemeral).build())
@@ -100,6 +99,22 @@ pub struct SecretClassVolumeScope {
     pub listener_volumes: Vec<String>,
 }
 
+/// What parts secret-operator should provision into the requested volume.
+//
+// There intentionally isn't a global [`Default`] impl, as it's secret-ops concern what it chooses
+// as a default.
+#[derive(Clone, Debug, PartialEq, Eq, strum::AsRefStr)]
+#[strum(serialize_all = "kebab-case")]
+pub enum SecretClassVolumeProvisionParts {
+    /// Only provision public parts, such as the CA certificate (either as PEM or truststore) or
+    /// `krb5.conf`.
+    Public,
+
+    /// Provision all parts, which includes all [`Public`](Self::Public) ones as well as additional
+    /// private parts, such as a TLS cert + private key, a keystore or a keytab.
+    PublicPrivate,
+}
+
 #[cfg(test)]
 mod tests {
     use std::collections::BTreeMap;
@@ -118,7 +133,7 @@ mod tests {
             }),
         }
         // Let's assume we need some form of private data (e.g. a certificate or S3 credentials)
-        .to_ephemeral_volume_source(SecretOperatorVolumeProvisionParts::PublicPrivate)
+        .to_ephemeral_volume_source(SecretClassVolumeProvisionParts::PublicPrivate)
         .unwrap();
 
         let expected_volume_attributes = BTreeMap::from([

crates/stackable-operator/src/commons/tls_verification.rs

@@ -6,13 +6,11 @@ use snafu::{ResultExt, Snafu};
 use crate::{
     builder::{
         self,
-        pod::{
-            PodBuilder,
-            container::ContainerBuilder,
-            volume::{SecretOperatorVolumeProvisionParts, VolumeMountBuilder},
-        },
+        pod::{PodBuilder, container::ContainerBuilder, volume::VolumeMountBuilder},
+    },
+    commons::secret_class::{
+        SecretClassVolume, SecretClassVolumeError, SecretClassVolumeProvisionParts,
     },
-    commons::secret_class::{SecretClassVolume, SecretClassVolumeError},
     constants::secret::SECRET_BASE_PATH,
 };
 
@@ -77,7 +75,7 @@ impl TlsClientDetails {
             let secret_class_volume = SecretClassVolume::new(secret_class.clone(), None);
             let volume = secret_class_volume
                 // We only need the public CA cert
-                .to_volume(&volume_name, SecretOperatorVolumeProvisionParts::Public)
+                .to_volume(&volume_name, SecretClassVolumeProvisionParts::Public)
                 .context(SecretClassVolumeSnafu)?;
 
             volumes.push(volume);

crates/stackable-operator/src/crd/authentication/ldap/v1alpha1_impl.rs

@@ -5,13 +5,12 @@ use url::Url;
 use crate::{
     builder::{
         self,
-        pod::{
-            PodBuilder,
-            container::ContainerBuilder,
-            volume::{SecretOperatorVolumeProvisionParts, VolumeMountBuilder},
-        },
+        pod::{PodBuilder, container::ContainerBuilder, volume::VolumeMountBuilder},
+    },
+    commons::{
+        secret_class::{SecretClassVolumeError, SecretClassVolumeProvisionParts},
+        tls_verification::TlsClientDetailsError,
     },
-    commons::{secret_class::SecretClassVolumeError, tls_verification::TlsClientDetailsError},
     constants::secret::SECRET_BASE_PATH,
     crd::authentication::ldap::v1alpha1::{AuthenticationProvider, FieldNames},
 };
@@ -99,7 +98,7 @@ impl AuthenticationProvider {
             let volume_name = format!("{secret_class}-bind-credentials");
             let volume = bind_credentials
                 // We need the private LDAP bind credentials
-                .to_volume(&volume_name, SecretOperatorVolumeProvisionParts::PublicPrivate)
+                .to_volume(&volume_name, SecretClassVolumeProvisionParts::PublicPrivate)
                 .context(BindCredentialsSnafu)?;
 
             volumes.push(volume);
@@ -241,7 +240,7 @@ mod tests {
                 }
                 .to_volume(
                     "ldap-ca-cert-ca-cert",
-                    SecretOperatorVolumeProvisionParts::Public
+                    SecretClassVolumeProvisionParts::Public
                 )
                 .unwrap()
             ]
@@ -273,7 +272,7 @@ mod tests {
                 }
                 .to_volume(
                     "openldap-bind-credentials-bind-credentials",
-                    SecretOperatorVolumeProvisionParts::PublicPrivate
+                    SecretClassVolumeProvisionParts::PublicPrivate
                 )
                 .unwrap(),
                 SecretClassVolume {
@@ -282,7 +281,7 @@ mod tests {
                 }
                 .to_volume(
                     "ldap-ca-cert-ca-cert",
-                    SecretOperatorVolumeProvisionParts::Public
+                    SecretClassVolumeProvisionParts::Public
                 )
                 .unwrap()
             ]

crates/stackable-operator/src/crd/s3/connection/v1alpha1_impl.rs

@@ -3,13 +3,12 @@ use snafu::{ResultExt as _, Snafu};
 use url::Url;
 
 use crate::{
-    builder::pod::{
-        PodBuilder,
-        container::ContainerBuilder,
-        volume::{SecretOperatorVolumeProvisionParts, VolumeMountBuilder},
-    },
+    builder::pod::{PodBuilder, container::ContainerBuilder, volume::VolumeMountBuilder},
     client::Client,
-    commons::{secret_class::SecretClassVolumeError, tls_verification::TlsClientDetailsError},
+    commons::{
+        secret_class::{SecretClassVolumeError, SecretClassVolumeProvisionParts},
+        tls_verification::TlsClientDetailsError,
+    },
     constants::secret::SECRET_BASE_PATH,
     crd::s3::{
         connection::ResolvedConnection,
@@ -115,7 +114,7 @@ impl ConnectionSpec {
             volumes.push(
                 credentials
                     // We need the private S3 credentials
-                    .to_volume(&volume_name, SecretOperatorVolumeProvisionParts::PublicPrivate)
+                    .to_volume(&volume_name, SecretClassVolumeProvisionParts::PublicPrivate)
                     .context(AddS3CredentialVolumesSnafu)?,
             );
             mounts.push(

crates/stackable-operator/src/kvp/annotation/mod.rs

@@ -18,7 +18,8 @@ use std::{
 use delegate::delegate;
 
 use crate::{
-    builder::pod::volume::{SecretOperatorVolumeProvisionParts, SecretOperatorVolumeScope},
+    builder::pod::volume::SecretOperatorVolumeScope,
+    commons::secret_class::SecretClassVolumeProvisionParts,
     iter::TryFromIterator,
     kvp::{Key, KeyValuePair, KeyValuePairError, KeyValuePairs, KeyValuePairsError},
 };
@@ -82,7 +83,7 @@ impl Annotation {
 
     /// Constructs a `secrets.stackable.tech/provision-parts` annotation.
     pub fn secret_provision_parts(
-        provision_parts: &SecretOperatorVolumeProvisionParts,
+        provision_parts: &SecretClassVolumeProvisionParts,
     ) -> Result<Self, AnnotationError> {
         let kvp =
             KeyValuePair::try_from(("secrets.stackable.tech/provision-parts", provision_parts))?;