feat(stackable-webhook): Add shutdown signal handler (#767)

* feat(stackable-webhook): add shutdown signal handler

* chore(stackable-webhook): update changelog

* chore(stackable-webhook): update changelog with missing entry

* fix(stackable-webhook): changelog link

* docs(stackable-webhook): add explanation about the position of the healh route

Author: NickLarsenNZ

crates/stackable-webhook/CHANGELOG.md

@@ -4,11 +4,18 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+### Added
+
+- Instrument `WebhookServer` with `AxumTraceLayer`, add static healthcheck without instrumentation ([#758]).
+- Add shutdown signal hander for the `WebhookServer` ([#767]).
+
 ### Changed
 
 - Bump kube to 0.89.0 and update all dependencies ([#762]).
 
+[#758]: https://github.com/stackabletech/operator-rs/pull/758
 [#762]: https://github.com/stackabletech/operator-rs/pull/762
+[#767]: https://github.com/stackabletech/operator-rs/pull/767
 
 ## [0.2.0] - 2024-03-26
 

crates/stackable-webhook/src/lib.rs

@@ -24,8 +24,10 @@
 //!
 //! [1]: crate::servers::ConversionWebhookServer
 use axum::{routing::get, Router};
+use futures_util::{pin_mut, select, FutureExt as _};
 use snafu::{ResultExt, Snafu};
 use stackable_telemetry::AxumTraceLayer;
+use tokio::signal::unix::{signal, SignalKind};
 use tower::ServiceBuilder;
 // use tower_http::trace::TraceLayer;
 use tracing::{debug, instrument};
@@ -131,10 +133,44 @@ impl WebhookServer {
         Self { options, router }
     }
 
+    /// Runs the Webhook server and sets up signal handlers for shutting down.
+    ///
+    /// This does not implement graceful shutdown of the underlying server.
+    pub async fn run(self) -> Result<()> {
+        let future_server = self.run_server();
+        let future_signal = async {
+            let mut sigint = signal(SignalKind::interrupt()).expect("create SIGINT listener");
+            let mut sigterm = signal(SignalKind::terminate()).expect("create SIGTERM listener");
+
+            debug!("created unix signal handlers");
+
+            select! {
+                signal = sigint.recv().fuse() => {
+                    if signal.is_some() {
+                        debug!( "received SIGINT");
+                    }
+                },
+                signal = sigterm.recv().fuse() => {
+                    if signal.is_some() {
+                        debug!( "received SIGTERM");
+                    }
+                },
+            };
+        };
+
+        // select requires Future + Unpin
+        pin_mut!(future_server);
+        pin_mut!(future_signal);
+
+        futures_util::future::select(future_server, future_signal).await;
+
+        Ok(())
+    }
+
     /// Runs the webhook server by creating a TCP listener and binding it to
     /// the specified socket address.
     #[instrument(name = "run_webhook_server", skip(self), fields(self.options))]
-    pub async fn run(self) -> Result<()> {
+    async fn run_server(self) -> Result<()> {
         debug!("run webhook server");
 
         // Create an OpenTelemetry tracing layer
@@ -152,6 +188,7 @@ impl WebhookServer {
         let router = self
             .router
             .layer(service_builder)
+            // The health route is below the AxumTraceLayer so as not to be instrumented
             .route("/health", get(|| async { "ok" }));
 
         // Create server for TLS termination