Merge pull request kroxylicious#1953 from k-wall/log-if-operand-preload-fails

Operator ITs - log pod status if operand image preload fails

Author: robobario

kroxylicious-operator/src/test/java/io/kroxylicious/kubernetes/operator/OperatorTestUtils.java

@@ -6,14 +6,28 @@
 
 package io.kroxylicious.kubernetes.operator;
 
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import io.fabric8.kubernetes.api.model.ContainerStatus;
 import io.fabric8.kubernetes.client.KubernetesClient;
 import io.fabric8.kubernetes.client.KubernetesClientBuilder;
 import io.fabric8.kubernetes.client.KubernetesClientException;
+import io.fabric8.kubernetes.client.readiness.Readiness;
 
+import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class OperatorTestUtils {
 
+    private static final Logger LOGGER = LoggerFactory.getLogger(OperatorTestUtils.class);
+
     /**
      * The timeouts etc of this client build are tuned to handle the case where Kubernetes isn't present.
      * As might be the case on a developer's machine where minikube isn't running.
@@ -28,6 +42,12 @@ public class OperatorTestUtils {
         return kubeClientIfAvailable(new KubernetesClientBuilder());
     }
 
+    static @NonNull KubernetesClient kubeClient() {
+        KubernetesClient kubernetesClient = kubeClientIfAvailable(new KubernetesClientBuilder());
+        assertThat(kubernetesClient).isNotNull();
+        return kubernetesClient;
+    }
+
     static @Nullable KubernetesClient kubeClientIfAvailable(KubernetesClientBuilder kubernetesClientBuilder) {
         var client = kubernetesClientBuilder.build();
         try {
@@ -45,4 +65,27 @@ static boolean isKubeClientAvailable() {
             return client != null;
         }
     }
+
+    public static void preloadOperandImage() {
+        try (var client = kubeClient()) {
+            String operandImage = ProxyDeployment.getOperandImage();
+            var pod = client.run().withName("preload-operand-image")
+                    .withNewRunConfig()
+                    .withImage(operandImage)
+                    .withRestartPolicy("Never")
+                    .withCommand("ls").done();
+            try {
+                client.resource(pod).waitUntilCondition(Readiness::isPodSucceeded, 2, TimeUnit.MINUTES);
+            }
+            finally {
+                var reread = client.resource(pod).get();
+                if (!Readiness.isPodSucceeded(reread)) {
+                    var reasons = reread.getStatus().getContainerStatuses().stream().map(ContainerStatus::getState).map(Objects::toString)
+                            .collect(Collectors.joining(","));
+                    LOGGER.error("Preloading operand image failed, phase: {}, container state: {}", reread.getStatus().getPhase(), reasons);
+                }
+                client.resource(pod).delete();
+            }
+        }
+    }
 }

kroxylicious-operator/src/test/java/io/kroxylicious/kubernetes/operator/ProxyReconcilerIT.java

@@ -9,21 +9,20 @@
 import java.time.Duration;
 import java.util.List;
 import java.util.Set;
-import java.util.concurrent.TimeUnit;
 
 import org.assertj.core.api.AbstractStringAssert;
-import org.assertj.core.api.Assumptions;
 import org.assertj.core.api.InstanceOfAssertFactories;
 import org.awaitility.core.ConditionFactory;
 import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledIf;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import io.fabric8.kubernetes.api.model.ConfigMap;
-import io.fabric8.kubernetes.api.model.Pod;
 import io.fabric8.kubernetes.api.model.Service;
 import io.fabric8.kubernetes.api.model.Volume;
 import io.fabric8.kubernetes.api.model.apps.Deployment;
@@ -49,6 +48,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.awaitility.Awaitility.await;
 
+@EnabledIf(value = "io.kroxylicious.kubernetes.operator.OperatorTestUtils#isKubeClientAvailable", disabledReason = "no viable kube client available")
 class ProxyReconcilerIT {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(ProxyReconcilerIT.class);
@@ -68,23 +68,15 @@ class ProxyReconcilerIT {
     private KubernetesClient client;
     private final ConditionFactory AWAIT = await().timeout(Duration.ofSeconds(60));
 
-    @BeforeEach
-    void checkKubeAvailable() {
-        client = OperatorTestUtils.kubeClientIfAvailable();
-        Assumptions.assumeThat(client).describedAs("Test requires a viable kube client").isNotNull();
-        preloadOperatorImage();
+    // the initial operator image pull can take a long time and interfere with the tests
+    @BeforeAll
+    public static void preloadOperandImage() {
+        OperatorTestUtils.preloadOperandImage();
     }
 
-    // the initial operator image pull can take a long time and interfere with the tests
-    private void preloadOperatorImage() {
-        String operandImage = ProxyDeployment.getOperandImage();
-        Pod pod = client.run().withName("preload-operator-image")
-                .withNewRunConfig()
-                .withImage(operandImage)
-                .withRestartPolicy("Never")
-                .withCommand("ls").done();
-        client.resource(pod).waitUntilCondition(it -> it.getStatus().getPhase().equals("Succeeded"), 2, TimeUnit.MINUTES);
-        client.resource(pod).delete();
+    @BeforeEach
+    void beforeEach() {
+        client = OperatorTestUtils.kubeClient();
     }
 
     @RegisterExtension