chore: Controller startup doesn't need to be delayed

Author: Techassi

CHANGELOG.md

@@ -10,12 +10,11 @@ All notable changes to this project will be documented in this file.
 
 ### Changed
 
-- Bump stackable-operator to 0.106.2, and strum to 0.28 ([#401]).
+- Bump stackable-operator to 0.107.1, and strum to 0.28 ([#401], [#404]).
 - Gracefully shutdown all concurrent tasks by forwarding the SIGTERM signal ([#396]).
 
 ### Fixed
 
-- Fix "404 page not found" error for the initial object list ([#404]).
 - BREAKING: Prevent Pod 0 restart by utilizing a mutating webhook.
   The commons-operator now needs the RBAC permission to `create` and `patch`
   `mutatingwebhookconfigurations`. The webhook can be disabled using

rust/operator-binary/src/main.rs

@@ -108,7 +108,7 @@ async fn main() -> anyhow::Result<()> {
 
             let (ctx, cm_store_tx, secret_store_tx) = create_context(client.clone());
 
-            let (webhook_server, initial_reconcile_rx) = create_webhook_server(
+            let webhook_server = create_webhook_server(
                 ctx.clone(),
                 &operator_environment,
                 disable_restarter_mutating_webhook,
@@ -117,38 +117,26 @@ async fn main() -> anyhow::Result<()> {
             )
             .await?;
 
-            // Multiply initial reconcile signal for the STS and pod restart controllers.
-            let initial_reconcile_signal = SignalWatcher::new(initial_reconcile_rx.map(|_| ()));
-
-            let delayed_sts_restart_controller = async {
-                initial_reconcile_signal.handle().await;
-
-                restart_controller::statefulset::start(
-                    ctx,
-                    cm_store_tx,
-                    secret_store_tx,
-                    &watch_namespace,
-                    sigterm_watcher.handle(),
-                )
-                .await
-            }
+            let sts_restart_controller = restart_controller::statefulset::start(
+                ctx,
+                cm_store_tx,
+                secret_store_tx,
+                &watch_namespace,
+                sigterm_watcher.handle(),
+            )
             .map(anyhow::Ok);
 
-            let delayed_pod_restart_controller = async {
-                initial_reconcile_signal.handle().await;
-
+            let pod_restart_controller =
                 restart_controller::pod::start(&client, &watch_namespace, sigterm_watcher.handle())
-                    .await
-            }
-            .map(anyhow::Ok);
+                    .map(anyhow::Ok);
 
             let webhook_server = webhook_server
                 .run(sigterm_watcher.handle())
                 .map_err(|err| anyhow!(err).context("failed to run webhook"));
 
             futures::try_join!(
-                delayed_sts_restart_controller,
-                delayed_pod_restart_controller,
+                sts_restart_controller,
+                pod_restart_controller,
                 webhook_server,
                 eos_checker,
             )?;

rust/operator-binary/src/webhooks/mod.rs

@@ -6,7 +6,6 @@ use stackable_operator::{
     kube::Client,
     webhook::{WebhookServer, WebhookServerError, WebhookServerOptions, webhooks::Webhook},
 };
-use tokio::sync::oneshot;
 
 use crate::restart_controller::statefulset::Ctx;
 
@@ -25,7 +24,7 @@ pub async fn create_webhook_server(
     disable_restarter_mutating_webhook: bool,
     disable_crd_maintenance: bool,
     client: Client,
-) -> Result<(WebhookServer, oneshot::Receiver<()>), Error> {
+) -> Result<WebhookServer, Error> {
     let mut webhooks: Vec<Box<dyn Webhook>> = vec![];
 
     if let Some(webhook) = restarter_mutate_sts::create_webhook(
@@ -38,7 +37,7 @@ pub async fn create_webhook_server(
 
     // TODO (@Techassi): The conversion webhook should also allow to be disabled, rework the
     // granularity of these options.
-    let (webhook, initial_reconcile_rx) =
+    let (webhook, _initial_reconcile_rx) =
         conversion::create_webhook(disable_crd_maintenance, client);
     webhooks.push(webhook);
 
@@ -48,9 +47,7 @@ pub async fn create_webhook_server(
         webhook_service_name: operator_environment.operator_service_name.to_owned(),
     };
 
-    let webhook_server = WebhookServer::new(webhooks, webhook_options)
+    WebhookServer::new(webhooks, webhook_options)
         .await
-        .context(CreateWebhookServerSnafu)?;
-
-    Ok((webhook_server, initial_reconcile_rx))
+        .context(CreateWebhookServerSnafu)
 }