feat: readyz polling for startup

core/src/main/java/io/javaoperatorsdk/jenvtest/KubeAPIServer.java

@@ -12,7 +12,7 @@ public class KubeAPIServer implements UnexpectedProcessStopHandler {
 
   private static final Logger log = LoggerFactory.getLogger(KubeAPIServer.class);
 
-  public static final int STARTUP_TIMEOUT = 15_000;
+  public static final int STARTUP_TIMEOUT = 10_000;
 
   private final KubeAPIServerConfig config;
   private final BinaryManager binaryManager;

core/src/main/java/io/javaoperatorsdk/jenvtest/process/KubeAPIServerProcess.java

@@ -2,29 +2,45 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.net.Socket;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.time.LocalTime;
+import java.time.temporal.ChronoUnit;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Scanner;
-import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.net.ssl.*;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import io.javaoperatorsdk.jenvtest.*;
 import io.javaoperatorsdk.jenvtest.binary.BinaryManager;
 
+import static io.javaoperatorsdk.jenvtest.KubeAPIServer.STARTUP_TIMEOUT;
+
 public class KubeAPIServerProcess {
 
   private static final Logger log = LoggerFactory.getLogger(KubeAPIServerProcess.class);
   private static final Logger apiLog = LoggerFactory.getLogger(KubeAPIServerProcess.class
       .getName() + ".APIServerProcessLogs");
+  public static final int POLLING_INTERVAL = 150;
 
   private final CertManager certManager;
   private final BinaryManager binaryManager;
   private final KubeAPIServerConfig config;
   private volatile Process apiServerProcess;
   private volatile boolean stopped = false;
   private final UnexpectedProcessStopHandler processStopHandler;
+  private int apiServerPort;
 
   public KubeAPIServerProcess(CertManager certManager, BinaryManager binaryManager,
       UnexpectedProcessStopHandler processStopHandler,
@@ -42,7 +58,7 @@ public int startApiServer(int etcdPort) {
         throw new JenvtestException(
             "Missing binary for API Server on path: " + apiServerBinary.getAbsolutePath());
       }
-      var apiServerPort = Utils.findFreePort();
+      apiServerPort = Utils.findFreePort();
       var command = createCommand(apiServerBinary, apiServerPort, etcdPort);
       apiServerProcess = new ProcessBuilder(command)
           .start();
@@ -85,27 +101,29 @@ private List<String> createCommand(File apiServerBinary, int apiServerPort, int
 
   public void waitUntilDefaultNamespaceCreated() {
     try {
-      AtomicBoolean started = new AtomicBoolean(false);
-      var proc = new ProcessBuilder(binaryManager.binaries().getKubectl().getPath(), "get", "ns",
-          "--watch").start();
-      var procWaiter = new Thread(() -> {
-        log.debug("Starting proc waiter thread.");
-        try (Scanner sc = new Scanner(proc.getInputStream())) {
-          while (sc.hasNextLine()) {
-            String line = sc.nextLine();
-            log.debug("kubectl ns watch: {}", line);
-            if (line.contains("default")) {
-              started.set(true);
-              return;
-            }
-          }
+      var client = getHttpClient();
+      var request = getHttpRequest();
+      var startedAt = LocalTime.now();
+      while (true) {
+        if (ready(client, request)) {
+          return;
         }
-      });
-      procWaiter.start();
-      procWaiter.join(KubeAPIServer.STARTUP_TIMEOUT);
-      if (!started.get()) {
-        throw new JenvtestException("API Server did not start properly");
+        if (LocalTime.now().isAfter(startedAt.plus(STARTUP_TIMEOUT, ChronoUnit.MILLIS))) {
+          throw new JenvtestException("API Server did not start properly");
+        }
+        Thread.sleep(POLLING_INTERVAL);
       }
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+      throw new JenvtestException(e);
+    }
+  }
+
+  private boolean ready(HttpClient client, HttpRequest request) {
+    try {
+      var response = client.send(request, HttpResponse.BodyHandlers.ofString());
+      log.trace("Ready Response message:{} code: {}", response.body(), response.statusCode());
+      return response.statusCode() == 200;
     } catch (IOException e) {
       throw new JenvtestException(e);
     } catch (InterruptedException e) {
@@ -114,6 +132,69 @@ public void waitUntilDefaultNamespaceCreated() {
     }
   }
 
+  private HttpRequest getHttpRequest() {
+    try {
+      return HttpRequest.newBuilder()
+          .uri(new URI("https://127.0.0.1:" + apiServerPort + "/readyz"))
+          .GET()
+          .build();
+    } catch (URISyntaxException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  private static HttpClient getHttpClient() {
+    try {
+      var sslContext = SSLContext.getInstance("TLS");
+      sslContext.init(
+          null,
+          new TrustManager[] {
+              new X509ExtendedTrustManager() {
+                @Override
+                public void checkClientTrusted(X509Certificate[] chain, String authType,
+                    Socket socket) throws CertificateException {
+
+                }
+
+                public X509Certificate[] getAcceptedIssuers() {
+                  return null;
+                }
+
+                public void checkClientTrusted(
+                    final X509Certificate[] a_certificates,
+                    final String a_auth_type) {}
+
+                public void checkServerTrusted(
+                    final X509Certificate[] a_certificates,
+                    final String a_auth_type) {}
+
+
+                public void checkServerTrusted(
+                    final X509Certificate[] a_certificates,
+                    final String a_auth_type,
+                    final Socket a_socket) {}
+
+                @Override
+                public void checkClientTrusted(X509Certificate[] chain, String authType,
+                    SSLEngine engine) throws CertificateException {
+
+                }
+
+                public void checkServerTrusted(
+                    final X509Certificate[] a_certificates,
+                    final String a_auth_type,
+                    final SSLEngine a_engine) {}
+              }
+          },
+          null);
+      return HttpClient.newBuilder()
+          .sslContext(sslContext)
+          .build();
+    } catch (NoSuchAlgorithmException | KeyManagementException e) {
+      throw new JenvtestException(e);
+    }
+  }
+
   public void stopApiServer() {
     if (stopped) {
       return;