Move container status.html check as well

1 files changed, 40 insertions, 26 deletions

diff --git a/config-provisioning/src/main/java/com/yahoo/config/provision/EndpointsChecker.java b/config-provisioning/src/main/java/com/yahoo/config/provision/EndpointsChecker.java
index d05e26cf5a5..94988293d07 100644
--- a/config-provisioning/src/main/java/com/yahoo/config/provision/EndpointsChecker.java
+++ b/config-provisioning/src/main/java/com/yahoo/config/provision/EndpointsChecker.java
@@ -1,6 +1,7 @@
 package com.yahoo.config.provision;
 
 import ai.vespa.http.DomainName;
+import ai.vespa.http.HttpURL;
 
 import javax.naming.NamingException;
 import javax.naming.directory.Attribute;
@@ -19,62 +20,75 @@ import java.util.Optional;
 public class EndpointsChecker {
 
     public record Endpoint(ClusterSpec.Id clusterName,
-                    DomainName dnsName,
-                    Optional<InetAddress> ipAddress,
-                    Optional<DomainName> canonicalName,
-                    boolean isPublic) { }
+                           HttpURL url,
+                           Optional<InetAddress> ipAddress,
+                           Optional<DomainName> canonicalName,
+                           boolean isPublic) { }
 
-    public record UnavailabilityCause(String message) { }
+    public enum Status { available, endpointsUnavailable, containersUnhealthy }
+
+    public record Availability(Status status, String message) { }
 
     public interface HostNameResolver { Optional<InetAddress> resolve(DomainName hostName); }
 
     public interface CNameResolver { Optional<DomainName> resolve(DomainName hostName); }
 
+    public interface ContainerHealthChecker { boolean healthy(Endpoint endpoint); }
+
     private EndpointsChecker() { }
 
-    public static Optional<UnavailabilityCause> endpointsAvailable(List<Endpoint> zoneEndpoints) {
-        return endpointsAvailable(zoneEndpoints, EndpointsChecker::resolveHostName, EndpointsChecker::resolveCname);
+    public static Availability endpointsAvailable(List<Endpoint> zoneEndpoints, ContainerHealthChecker containerHealthChecker) {
+        return endpointsAvailable(zoneEndpoints, EndpointsChecker::resolveHostName, EndpointsChecker::resolveCname, containerHealthChecker);
     }
 
-    public static Optional<UnavailabilityCause> endpointsAvailable(List<Endpoint> zoneEndpoints,
-                                                                   HostNameResolver hostNameResolver,
-                                                                   CNameResolver cNameResolver) {
+    public static Availability endpointsAvailable(List<Endpoint> zoneEndpoints,
+                                                  HostNameResolver hostNameResolver,
+                                                  CNameResolver cNameResolver,
+                                                  ContainerHealthChecker containerHealthChecker) {
         if (zoneEndpoints.isEmpty())
-            return Optional.of(new UnavailabilityCause("Endpoints not yet ready."));
+            return new Availability(Status.endpointsUnavailable, "Endpoints not yet ready.");
 
         for (Endpoint endpoint : zoneEndpoints) {
-            Optional<InetAddress> resolvedIpAddress = hostNameResolver.resolve(endpoint.dnsName());
+            Optional<InetAddress> resolvedIpAddress = hostNameResolver.resolve(endpoint.url().domain());
             if (resolvedIpAddress.isEmpty())
-                return Optional.of(new UnavailabilityCause("DNS lookup yielded no IP address for '" + endpoint.dnsName() + "'."));
+                return new Availability(Status.endpointsUnavailable, "DNS lookup yielded no IP address for '" + endpoint.url().domain() + "'.");
 
             if (resolvedIpAddress.equals(endpoint.ipAddress())) // We expect a certain IP address, and that's what we got, so we're good.
                 continue;
 
             if (endpoint.ipAddress().isPresent()) // We expect a certain IP address, but that's not what we got.
-                return Optional.of(new UnavailabilityCause("IP address of '" + endpoint.dnsName() + "' (" +
-                                                           resolvedIpAddress.get().getHostAddress() + ") and load balancer " +
-                                                           "' (" + endpoint.ipAddress().get().getHostAddress() + ") are not equal"));
+                return new Availability(Status.endpointsUnavailable,
+                                        "IP address of '" + endpoint.url().domain() + "' (" +
+                                        resolvedIpAddress.get().getHostAddress() + ") and load balancer " +
+                                        "' (" + endpoint.ipAddress().get().getHostAddress() + ") are not equal");
 
             if (endpoint.canonicalName().isEmpty()) // We have no expected IP address, and no canonical name, so there's nothing more to check.
                 continue;
 
-            Optional<DomainName> cNameValue = cNameResolver.resolve(endpoint.dnsName());
+            Optional<DomainName> cNameValue = cNameResolver.resolve(endpoint.url().domain());
             if (cNameValue.filter(endpoint.canonicalName().get()::equals).isEmpty()) {
-                return Optional.of(new UnavailabilityCause("CNAME '" + endpoint.dnsName() + "' points at " +
-                                                           cNameValue.map(name -> "'" + name + "'").orElse("nothing") +
-                                                           " but should point at load balancer " +
-                                                           endpoint.canonicalName().map(name -> "'" + name + "'").orElse("nothing")));
+                return new Availability(Status.endpointsUnavailable,
+                                        "CNAME '" + endpoint.url().domain() + "' points at " +
+                                        cNameValue.map(name -> "'" + name + "'").orElse("nothing") +
+                                        " but should point at load balancer " +
+                                        endpoint.canonicalName().map(name -> "'" + name + "'").orElse("nothing"));
             }
 
             Optional<InetAddress> loadBalancerAddress = hostNameResolver.resolve(endpoint.canonicalName().get());
             if ( ! loadBalancerAddress.equals(resolvedIpAddress)) {
-                return Optional.of(new UnavailabilityCause("IP address of CNAME '" + endpoint.dnsName() + "' (" +
-                                                           resolvedIpAddress.get().getHostAddress() + ") and load balancer '" +
-                                                           endpoint.canonicalName().get() + "' (" +
-                                                           loadBalancerAddress.map(InetAddress::getHostAddress).orElse("empty") + ") are not equal"));
+                return new Availability(Status.endpointsUnavailable,
+                                        "IP address of CNAME '" + endpoint.url().domain() + "' (" +
+                                        resolvedIpAddress.get().getHostAddress() + ") and load balancer '" +
+                                        endpoint.canonicalName().get() + "' (" +
+                                        loadBalancerAddress.map(InetAddress::getHostAddress).orElse("empty") + ") are not equal");
             }
         }
-        return Optional.empty();
+
+        for (Endpoint endpoint : zoneEndpoints)
+            if ( ! containerHealthChecker.healthy(endpoint))
+                return new Availability(Status.containersUnhealthy, "Failed to get enough healthy responses from " + endpoint.url());
+
+        return new Availability(Status.available, "Endpoints are ready");
     }
 
     /** Returns the IP address of the given host name, if any. */