refactor: Rename traits and structs

Author: sbernauer

crates/stackable-webhook/src/lib.rs

@@ -4,7 +4,7 @@ use ::x509_cert::Certificate;
 use axum::{Router, routing::get};
 use futures_util::{FutureExt as _, TryFutureExt, select};
 use k8s_openapi::ByteString;
-use servers::{WebhookServerImplementation, WebhookServerImplementationError};
+use servers::{Webhook, WebhookError};
 use snafu::{ResultExt, Snafu};
 use stackable_telemetry::AxumTraceLayer;
 use tokio::{
@@ -21,34 +21,32 @@ pub mod servers;
 pub mod tls;
 
 /// A result type alias with the [`WebhookError`] type as the default error type.
-pub type Result<T, E = WebhookError> = std::result::Result<T, E>;
+pub type Result<T, E = WebhookServerError> = std::result::Result<T, E>;
 
 #[derive(Debug, Snafu)]
-pub enum WebhookError {
+pub enum WebhookServerError {
     #[snafu(display("failed to create TLS server"))]
     CreateTlsServer { source: tls::TlsServerError },
 
     #[snafu(display("failed to run TLS server"))]
     RunTlsServer { source: tls::TlsServerError },
 
     #[snafu(display("failed to update certificate"))]
-    UpdateCertificate {
-        source: WebhookServerImplementationError,
-    },
+    UpdateCertificate { source: WebhookError },
 
     #[snafu(display("failed to encode CA certificate as PEM format"))]
     EncodeCertificateAuthorityAsPem { source: x509_cert::der::Error },
 }
 
 pub struct WebhookServer {
-    options: WebhookOptions,
-    webhooks: Vec<Box<dyn WebhookServerImplementation>>,
+    options: WebhookServerOptions,
+    webhooks: Vec<Box<dyn Webhook>>,
     tls_server: TlsServer,
     cert_rx: mpsc::Receiver<Certificate>,
 }
 
 #[derive(Clone, Debug)]
-pub struct WebhookOptions {
+pub struct WebhookServerOptions {
     /// The default HTTPS socket address the [`TcpListener`][tokio::net::TcpListener]
     /// binds to.
     pub socket_addr: SocketAddr,
@@ -75,8 +73,8 @@ impl WebhookServer {
         SocketAddr::new(Self::DEFAULT_LISTEN_ADDRESS, Self::DEFAULT_HTTPS_PORT);
 
     pub async fn new(
-        options: WebhookOptions,
-        webhooks: Vec<Box<dyn WebhookServerImplementation>>,
+        options: WebhookServerOptions,
+        webhooks: Vec<Box<dyn Webhook>>,
     ) -> Result<Self> {
         tracing::trace!("create new webhook server");
 
@@ -170,7 +168,7 @@ impl WebhookServer {
         } = self;
         let tls_server = tls_server
             .run()
-            .map_err(|err| WebhookError::RunTlsServer { source: err });
+            .map_err(|err| WebhookServerError::RunTlsServer { source: err });
 
         let cert_update_loop = async {
             loop {

crates/stackable-webhook/src/servers/conversion_webhook.rs

@@ -22,8 +22,8 @@ use snafu::{ResultExt, Snafu, ensure};
 use tokio::sync::oneshot;
 use x509_cert::Certificate;
 
-use super::{WebhookServerImplementation, WebhookServerImplementationError};
-use crate::WebhookOptions;
+use super::{Webhook, WebhookError};
+use crate::WebhookServerOptions;
 
 #[derive(Debug, Snafu)]
 pub enum ConversionWebhookError {
@@ -37,7 +37,7 @@ pub enum ConversionWebhookError {
     },
 }
 
-pub struct ConversionWebhookServer<H> {
+pub struct ConversionWebhook<H> {
     crds_and_handlers: Vec<(CustomResourceDefinition, H)>,
     disable_crd_maintenance: bool,
     client: Client,
@@ -49,7 +49,7 @@ pub struct ConversionWebhookServer<H> {
     initial_reconcile_tx: Option<oneshot::Sender<()>>,
 }
 
-impl<H> ConversionWebhookServer<H> {
+impl<H> ConversionWebhook<H> {
     pub fn new(
         crds_and_handlers: impl IntoIterator<Item = (CustomResourceDefinition, H)>,
         disable_crd_maintenance: bool,
@@ -72,7 +72,7 @@ impl<H> ConversionWebhookServer<H> {
 }
 
 #[async_trait]
-impl<H> WebhookServerImplementation for ConversionWebhookServer<H>
+impl<H> Webhook for ConversionWebhook<H>
 where
     H: FnOnce(ConversionReview) -> ConversionReview + Clone + Send + Sync + 'static,
 {
@@ -95,8 +95,8 @@ where
         &mut self,
         _new_certificate: &Certificate,
         new_ca_bundle: &ByteString,
-        options: &WebhookOptions,
-    ) -> Result<(), WebhookServerImplementationError> {
+        options: &WebhookServerOptions,
+    ) -> Result<(), WebhookError> {
         if self.disable_crd_maintenance {
             return Ok(());
         }

crates/stackable-webhook/src/servers/mod.rs

@@ -1,18 +1,18 @@
 use async_trait::async_trait;
 use axum::Router;
-pub use conversion_webhook::{ConversionReview, ConversionWebhookError, ConversionWebhookServer};
+pub use conversion_webhook::{ConversionReview, ConversionWebhook, ConversionWebhookError};
 use k8s_openapi::ByteString;
-pub use mutating_webhook::{MutatingWebhookError, MutatingWebhookServer};
+pub use mutating_webhook::{MutatingWebhook, MutatingWebhookError};
 use snafu::Snafu;
 use x509_cert::Certificate;
 
-use crate::WebhookOptions;
+use crate::WebhookServerOptions;
 
 mod conversion_webhook;
 mod mutating_webhook;
 
 #[derive(Snafu, Debug)]
-pub enum WebhookServerImplementationError {
+pub enum WebhookError {
     #[snafu(display("conversion webhook error"), context(false))]
     ConversionWebhookError {
         source: conversion_webhook::ConversionWebhookError,
@@ -27,13 +27,13 @@ pub enum WebhookServerImplementationError {
 // We still need to use the async-trait crate, as Rust 1.91.1 does not support dynamic dispatch
 // in combination with async functions.
 #[async_trait]
-pub trait WebhookServerImplementation {
+pub trait Webhook {
     fn register_routes(&self, router: Router) -> Router;
 
     async fn handle_certificate_rotation(
         &mut self,
         new_certificate: &Certificate,
         new_ca_bundle: &ByteString,
-        options: &WebhookOptions,
-    ) -> Result<(), WebhookServerImplementationError>;
+        options: &WebhookServerOptions,
+    ) -> Result<(), WebhookError>;
 }

crates/stackable-webhook/src/servers/mutating_webhook.rs

@@ -17,15 +17,15 @@ use serde::{Serialize, de::DeserializeOwned};
 use snafu::{ResultExt, Snafu};
 use x509_cert::Certificate;
 
-use super::{WebhookServerImplementation, WebhookServerImplementationError};
-use crate::WebhookOptions;
+use super::{Webhook, WebhookError};
+use crate::WebhookServerOptions;
 
 #[derive(Debug, Snafu)]
 pub enum MutatingWebhookError {
-    #[snafu(display("failed to patch MutatingWebhookConfiguration {vwc_name:?}"))]
+    #[snafu(display("failed to patch MutatingWebhookConfiguration {mwc_name:?}"))]
     PatchMutatingWebhookConfiguration {
         source: kube::Error,
-        vwc_name: String,
+        mwc_name: String,
     },
 }
 
@@ -99,11 +99,11 @@ pub enum MutatingWebhookError {
 ///     AdmissionResponse::from(&request)
 /// }
 /// ```
-pub struct MutatingWebhookServer<H, S, R> {
+pub struct MutatingWebhook<H, S, R> {
     mutating_webhook_configuration: MutatingWebhookConfiguration,
     handler: H,
     handler_state: Arc<S>,
-    resource: PhantomData<R>,
+    _resource: PhantomData<R>,
 
     disable_mutating_webhook_configuration_maintenance: bool,
     client: Client,
@@ -112,7 +112,7 @@ pub struct MutatingWebhookServer<H, S, R> {
     field_manager: String,
 }
 
-impl<H, S, R> MutatingWebhookServer<H, S, R> {
+impl<H, S, R> MutatingWebhook<H, S, R> {
     /// All webhooks need to set the admissionReviewVersions to `["v1"]`, as this mutating webhook
     /// only supports that version! A failure to do so will result in a panic.
     pub fn new(
@@ -135,7 +135,7 @@ impl<H, S, R> MutatingWebhookServer<H, S, R> {
             mutating_webhook_configuration,
             handler,
             handler_state,
-            resource: PhantomData,
+            _resource: PhantomData,
             disable_mutating_webhook_configuration_maintenance,
             client,
             field_manager,
@@ -148,7 +148,7 @@ impl<H, S, R> MutatingWebhookServer<H, S, R> {
 }
 
 #[async_trait]
-impl<H, S, R, Fut> WebhookServerImplementation for MutatingWebhookServer<H, S, R>
+impl<H, S, R, Fut> Webhook for MutatingWebhook<H, S, R>
 where
     H: Fn(Arc<S>, AdmissionRequest<R>) -> Fut + Clone + Send + Sync + 'static,
     Fut: Future<Output = AdmissionResponse> + Send + 'static,
@@ -182,16 +182,16 @@ where
         &mut self,
         _new_certificate: &Certificate,
         new_ca_bundle: &ByteString,
-        options: &WebhookOptions,
-    ) -> Result<(), WebhookServerImplementationError> {
+        options: &WebhookServerOptions,
+    ) -> Result<(), WebhookError> {
         if self.disable_mutating_webhook_configuration_maintenance {
             return Ok(());
         }
 
         let mut mutating_webhook_configuration = self.mutating_webhook_configuration.clone();
-        let vwc_name = mutating_webhook_configuration.name_any();
+        let mwc_name = mutating_webhook_configuration.name_any();
         tracing::info!(
-            k8s.MutatingWebhookConfiguration.name = vwc_name,
+            k8s.mutatingwebhookconfiguration.name = mwc_name,
             "reconciling mutating webhook configurations"
         );
 
@@ -210,15 +210,15 @@ where
             };
         }
 
-        let vwc_api: Api<MutatingWebhookConfiguration> = Api::all(self.client.clone());
+        let mwc_api: Api<MutatingWebhookConfiguration> = Api::all(self.client.clone());
         // Other than with the CRDs we don't need to force-apply the MutatingWebhookConfiguration
         let patch = Patch::Apply(&mutating_webhook_configuration);
         let patch_params = PatchParams::apply(&self.field_manager);
 
-        vwc_api
-            .patch(&vwc_name, &patch_params, &patch)
+        mwc_api
+            .patch(&mwc_name, &patch_params, &patch)
             .await
-            .with_context(|_| PatchMutatingWebhookConfigurationSnafu { vwc_name })?;
+            .with_context(|_| PatchMutatingWebhookConfigurationSnafu { mwc_name })?;
 
         Ok(())
     }

crates/stackable-webhook/src/tls/mod.rs

@@ -31,7 +31,7 @@ use tracing_opentelemetry::OpenTelemetrySpanExt;
 use x509_cert::Certificate;
 
 use crate::{
-    WebhookOptions,
+    WebhookServerOptions,
     tls::cert_resolver::{CertificateResolver, CertificateResolverError},
 };
 
@@ -86,11 +86,11 @@ impl TlsServer {
     #[instrument(name = "create_tls_server", skip(router))]
     pub async fn new(
         router: Router,
-        options: WebhookOptions,
+        options: WebhookServerOptions,
     ) -> Result<(Self, mpsc::Receiver<Certificate>)> {
         let (certificate_tx, certificate_rx) = mpsc::channel(1);
 
-        let WebhookOptions {
+        let WebhookServerOptions {
             socket_addr,
             operator_namespace,
             operator_service_name,