fix: Delay controller startup to avoid 404 in initial list

Author: Techassi

rust/operator-binary/src/main.rs

@@ -107,35 +107,48 @@ async fn main() -> anyhow::Result<()> {
             .await?;
 
             let (ctx, cm_store_tx, secret_store_tx) = create_context(client.clone());
-            let sts_restart_controller = restart_controller::statefulset::start(
-                ctx.clone(),
-                cm_store_tx,
-                secret_store_tx,
-                &watch_namespace,
-                sigterm_watcher.handle(),
-            )
-            .map(anyhow::Ok);
 
-            let pod_restart_controller =
-                restart_controller::pod::start(&client, &watch_namespace, sigterm_watcher.handle())
-                    .map(anyhow::Ok);
-
-            let webhook_server = create_webhook_server(
-                ctx,
+            let (webhook_server, initial_reconcile_rx) = create_webhook_server(
+                ctx.clone(),
                 &operator_environment,
                 disable_restarter_mutating_webhook,
                 maintenance.disable_crd_maintenance,
                 client.as_kube_client(),
             )
             .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
+            }
+            .map(anyhow::Ok);
+
+            let delayed_pod_restart_controller = async {
+                initial_reconcile_signal.handle().await;
+
+                restart_controller::pod::start(&client, &watch_namespace, sigterm_watcher.handle())
+                    .await
+            }
+            .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!(
-                sts_restart_controller,
-                pod_restart_controller,
+                delayed_sts_restart_controller,
+                delayed_pod_restart_controller,
                 webhook_server,
                 eos_checker,
             )?;

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

@@ -6,10 +6,14 @@ use stackable_operator::{
     kube::Client,
     webhook::webhooks::{ConversionWebhook, ConversionWebhookOptions, Webhook},
 };
+use tokio::sync::oneshot;
 
 use crate::FIELD_MANAGER;
 
-pub fn create_webhook(disable_crd_maintenance: bool, client: Client) -> Box<impl Webhook> {
+pub fn create_webhook(
+    disable_crd_maintenance: bool,
+    client: Client,
+) -> (Box<impl Webhook>, oneshot::Receiver<()>) {
     let crds_and_handlers = vec![
         (
             AuthenticationClass::merged_crd(AuthenticationClassVersion::V1Alpha1).unwrap(),
@@ -30,8 +34,8 @@ pub fn create_webhook(disable_crd_maintenance: bool, client: Client) -> Box<impl
         field_manager: FIELD_MANAGER.to_owned(),
     };
 
-    let (conversion_webhook, _initial_reconcile_rx) =
+    let (conversion_webhook, initial_reconcile_rx) =
         ConversionWebhook::new(crds_and_handlers, client, conversion_webhook_options);
 
-    Box::new(conversion_webhook)
+    (Box::new(conversion_webhook), initial_reconcile_rx)
 }

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

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