Merge pull request #10038 from vespa-engine/mgimle/host-capacity-explanation-endpoint

Mgimle/host capacity explanation endpoint

11 files changed, 853 insertions, 440 deletions

diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/CapacityChecker.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/CapacityChecker.java
new file mode 100644
index 00000000000..48f846d5e7f
--- /dev/null
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/CapacityChecker.java
@@ -0,0 +1,526 @@
+package com.yahoo.vespa.hosted.provision.maintenance;
+
+import com.yahoo.config.provision.NodeResources;
+import com.yahoo.config.provision.NodeType;
+import com.yahoo.vespa.hosted.provision.Node;
+import com.yahoo.vespa.hosted.provision.NodeRepository;
+import com.yahoo.vespa.hosted.provision.node.Allocation;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class CapacityChecker {
+    private List<Node> hosts;
+    Map<String, Node> nodeMap;
+    private Map<Node, List<Node>> nodeChildren;
+    private Map<Node, AllocationResources> availableResources;
+
+    public AllocationHistory allocationHistory = null;
+
+    public CapacityChecker(NodeRepository nodeRepository) {
+        this.hosts = getHosts(nodeRepository);
+        List<Node> tenants = getTenants(nodeRepository, hosts);
+        nodeMap = constructHostnameToNodeMap(hosts);
+        this.nodeChildren = constructNodeChildrenMap(tenants, hosts, nodeMap);
+        this.availableResources = constructAvailableResourcesMap(hosts, nodeChildren);
+    }
+
+    public List<Node> getHosts() {
+        return hosts;
+    }
+
+    public Optional<HostFailurePath> worstCaseHostLossLeadingToFailure() {
+        Map<Node, Integer> timesNodeCanBeRemoved = computeMaximalRepeatedRemovals(hosts, nodeChildren, availableResources);
+        return greedyHeuristicFindFailurePath(timesNodeCanBeRemoved, hosts, nodeChildren, availableResources);
+    }
+
+    protected List<Node> findOvercommittedHosts() {
+        return findOvercommittedNodes(availableResources);
+    }
+
+    public List<Node> nodesFromHostnames(List<String> hostnames) {
+        List<Node> nodes = hostnames.stream()
+                .filter(h -> nodeMap.containsKey(h))
+                .map(h -> nodeMap.get(h))
+                .collect(Collectors.toList());
+        if (nodes.size() != hostnames.size()) {
+            Set<String> notFoundNodes = new HashSet<>(hostnames);
+            notFoundNodes.removeAll(nodes.stream().map(Node::hostname).collect(Collectors.toList()));
+            throw new IllegalArgumentException(String.format("Host(s) not found: [ %s ]",
+                    String.join(", ", notFoundNodes)));
+        }
+
+        return nodes;
+    }
+
+    public Optional<HostFailurePath> findHostRemovalFailure(List<Node> hostsToRemove) {
+        var removal = findHostRemovalFailure(hostsToRemove, hosts, nodeChildren, availableResources);
+        if (removal.isEmpty()) return Optional.empty();
+        HostFailurePath failurePath = new HostFailurePath();
+        failurePath.hostsCausingFailure = hostsToRemove;
+        failurePath.failureReason = removal.get();
+        return Optional.of(failurePath);
+    }
+
+    // We only care about nodes in one of these states.
+    private static Node.State[] relevantNodeStates = {
+            Node.State.active,
+            Node.State.inactive,
+            Node.State.dirty,
+            Node.State.provisioned,
+            Node.State.ready,
+            Node.State.reserved
+    };
+
+    private List<Node> getHosts(NodeRepository nodeRepository) {
+        return nodeRepository.getNodes(NodeType.host, relevantNodeStates);
+    }
+
+    private List<Node> getTenants(NodeRepository nodeRepository, List<Node> hosts) {
+        var parentNames = hosts.stream().map(Node::hostname).collect(Collectors.toSet());
+        return nodeRepository.getNodes(NodeType.tenant, relevantNodeStates).stream()
+                .filter(t -> parentNames.contains(t.parentHostname().orElse("")))
+                .collect(Collectors.toList());
+    }
+
+    private Optional<HostFailurePath> greedyHeuristicFindFailurePath(Map<Node, Integer> heuristic, List<Node> hosts,
+                                                                     Map<Node, List<Node>> nodeChildren,
+                                                                     Map<Node, AllocationResources> availableResources) {
+        if (hosts.size() == 0) return Optional.empty();
+
+        List<Node> parentRemovalPriorityList = heuristic.entrySet().stream()
+                .sorted(Comparator.comparingInt(Map.Entry::getValue))
+                .map(Map.Entry::getKey)
+                .collect(Collectors.toList());
+
+        for (int i = 1; i <= parentRemovalPriorityList.size(); i++) {
+            List<Node> hostsToRemove = parentRemovalPriorityList.subList(0, i);
+            var hostRemovalFailure = findHostRemovalFailure(hostsToRemove, hosts, nodeChildren, availableResources);
+            if (hostRemovalFailure.isPresent()) {
+                HostFailurePath failurePath = new HostFailurePath();
+                failurePath.hostsCausingFailure = hostsToRemove;
+                failurePath.failureReason = hostRemovalFailure.get();
+                return Optional.of(failurePath);
+            }
+        }
+
+        throw new IllegalStateException("No path to failure found. This should be impossible!");
+    }
+
+    private Map<String, Node> constructHostnameToNodeMap(List<Node> nodes) {
+        return nodes.stream().collect(Collectors.toMap(Node::hostname, n -> n));
+    }
+
+    private Map<Node, List<Node>> constructNodeChildrenMap(List<Node> tenants, List<Node> hosts, Map<String, Node> hostnameToNode) {
+        Map<Node, List<Node>> nodeChildren = tenants.stream()
+                .filter(n -> n.parentHostname().isPresent())
+                .filter(n -> hostnameToNode.containsKey(n.parentHostname().get()))
+                .collect(Collectors.groupingBy(
+                        n -> hostnameToNode.get(n.parentHostname().orElseThrow())));
+
+        for (var host : hosts) nodeChildren.putIfAbsent(host, List.of());
+
+        return nodeChildren;
+    }
+
+    private Map<Node, AllocationResources> constructAvailableResourcesMap(List<Node> hosts, Map<Node, List<Node>> nodeChildren) {
+        Map<Node, AllocationResources> availableResources = new HashMap<>();
+        for (var host : hosts) {
+            NodeResources hostResources = host.flavor().resources();
+            int occupiedIps = 0;
+            Set<String> ipPool = host.ipAddressPool().asSet();
+            for (var child : nodeChildren.get(host)) {
+                hostResources = hostResources.subtract(child.flavor().resources().withDiskSpeed(NodeResources.DiskSpeed.any));
+                occupiedIps += child.ipAddresses().stream().filter(ipPool::contains).count();
+            }
+            availableResources.put(host, new AllocationResources(hostResources, host.ipAddressPool().asSet().size() - occupiedIps));
+        }
+
+        return availableResources;
+    }
+
+    /**
+     * Computes a heuristic for each host, with a lower score indicating a higher perceived likelihood that removing
+     * the host causes an unrecoverable state
+     */
+    private Map<Node, Integer> computeMaximalRepeatedRemovals(List<Node> hosts, Map<Node, List<Node>> nodeChildren,
+                                                              Map<Node, AllocationResources> availableResources) {
+        Map<Node, Integer> timesNodeCanBeRemoved = hosts.stream().collect(Collectors.toMap(
+                Function.identity(),
+                _x -> Integer.MAX_VALUE
+        ));
+        for (Node host : hosts) {
+            List<Node> children = nodeChildren.get(host);
+            if (children.size() == 0) continue;
+            Map<Node, AllocationResources> resourceMap = new HashMap<>(availableResources);
+            Map<Node, List<Allocation>> containedAllocations = collateAllocations(nodeChildren);
+
+            int timesHostCanBeRemoved = 0;
+            Optional<Node> unallocatedNode;
+            while (timesHostCanBeRemoved < 1000) { // Arbritrary upper bound
+                unallocatedNode = tryAllocateNodes(nodeChildren.get(host), hosts, resourceMap, containedAllocations);
+                if (unallocatedNode.isEmpty()) {
+                    timesHostCanBeRemoved++;
+                } else break;
+            }
+            timesNodeCanBeRemoved.put(host, timesHostCanBeRemoved);
+        }
+
+        return timesNodeCanBeRemoved;
+    }
+
+    private List<Node> findOvercommittedNodes(Map<Node, AllocationResources> availableResources) {
+        List<Node> overcommittedNodes = new ArrayList<>();
+        for (var entry : availableResources.entrySet()) {
+            var resources = entry.getValue().nodeResources;
+            if (resources.vcpu() < 0 || resources.memoryGb() < 0 || resources.diskGb() < 0) {
+                overcommittedNodes.add(entry.getKey());
+            }
+        }
+        return overcommittedNodes;
+    }
+
+    private Map<Node, List<Allocation>> collateAllocations(Map<Node, List<Node>> nodeChildren) {
+        return nodeChildren.entrySet().stream().collect(Collectors.toMap(
+                Map.Entry::getKey,
+                e -> e.getValue().stream()
+                        .map(Node::allocation).flatMap(Optional::stream)
+                        .collect(Collectors.toList())
+        ));
+    }
+
+    /**
+     * Tests whether it's possible to remove the provided hosts.
+     * Does not mutate any input variable.
+     * @return Empty optional if removal is possible, information on what caused the failure otherwise
+     */
+    private Optional<HostRemovalFailure> findHostRemovalFailure(List<Node> hostsToRemove, List<Node> allHosts,
+                                                                Map<Node, List<Node>> nodechildren,
+                                                                Map<Node, AllocationResources> availableResources) {
+        var containedAllocations = collateAllocations(nodechildren);
+        var resourceMap = new HashMap<>(availableResources);
+        List<Node> validAllocationTargets = allHosts.stream()
+                .filter(h -> !hostsToRemove.contains(h))
+                .collect(Collectors.toList());
+        if (validAllocationTargets.size() == 0) {
+            return Optional.of(HostRemovalFailure.none());
+        }
+
+        allocationHistory = new AllocationHistory();
+        for (var host : hostsToRemove) {
+            Optional<Node> unallocatedNode = tryAllocateNodes(nodechildren.get(host),
+                    validAllocationTargets, resourceMap, containedAllocations, true);
+
+            if (unallocatedNode.isPresent()) {
+                AllocationFailureReasonList failures = collateAllocationFailures(unallocatedNode.get(),
+                        validAllocationTargets, resourceMap, containedAllocations);
+                return Optional.of(HostRemovalFailure.create(host, unallocatedNode.get(), failures));
+            }
+        }
+        return Optional.empty();
+    }
+
+    /**
+     * Attempts to allocate the listed nodes to a new host, mutating availableResources and containedAllocations,
+     * optionally returning the first node to fail, if one does.
+     * */
+    private Optional<Node> tryAllocateNodes(List<Node> nodes, List<Node> hosts,
+                                            Map<Node, AllocationResources> availableResources,
+                                            Map<Node, List<Allocation>> containedAllocations) {
+        return tryAllocateNodes(nodes, hosts, availableResources, containedAllocations, false);
+    }
+    private Optional<Node> tryAllocateNodes(List<Node> nodes, List<Node> hosts,
+                                            Map<Node, AllocationResources> availableResources,
+                                            Map<Node, List<Allocation>> containedAllocations, boolean withHistory) {
+        for (var node : nodes) {
+            var newParent = tryAllocateNode(node, hosts, availableResources, containedAllocations);
+            if (newParent.isEmpty()) {
+                if (withHistory) allocationHistory.addEntry(node, null, 0);
+                return Optional.of(node);
+            }
+            if (withHistory) {
+                long eligibleParents =
+                    hosts.stream().filter(h ->
+                            !violatesParentHostPolicy(node, h, containedAllocations)
+                                && availableResources.get(h).satisfies(AllocationResources.from(node.flavor().resources()))).count();
+                allocationHistory.addEntry(node, newParent.get(), eligibleParents + 1);
+            }
+        }
+        return Optional.empty();
+    }
+
+    /**
+     * @return The parent to which the node was allocated, if it was successfully allocated.
+     */
+    private Optional<Node> tryAllocateNode(Node node, List<Node> hosts,
+                                    Map<Node, AllocationResources> availableResources,
+                                    Map<Node, List<Allocation>> containedAllocations) {
+        AllocationResources requiredNodeResources = AllocationResources.from(node.flavor().resources());
+        for (var host : hosts) {
+            var availableHostResources = availableResources.get(host);
+            if (violatesParentHostPolicy(node, host, containedAllocations)) {
+                continue;
+            }
+            if (availableHostResources.satisfies(requiredNodeResources)) {
+                availableResources.put(host, availableHostResources.subtract(requiredNodeResources));
+                if (node.allocation().isPresent()) {
+                    containedAllocations.get(host).add(node.allocation().get());
+                }
+                return Optional.of(host);
+            }
+        }
+
+        return Optional.empty();
+    }
+
+    private static boolean violatesParentHostPolicy(Node node, Node host, Map<Node, List<Allocation>> containedAllocations) {
+        if (node.allocation().isEmpty()) return false;
+        Allocation nodeAllocation = node.allocation().get();
+        for (var allocation : containedAllocations.get(host)) {
+            if (allocation.membership().cluster().equalsIgnoringGroupAndVespaVersion(nodeAllocation.membership().cluster())
+                    && allocation.owner().equals(nodeAllocation.owner())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private AllocationFailureReasonList collateAllocationFailures(Node node, List<Node> hosts,
+                                                                  Map<Node, AllocationResources> availableResources,
+                                                                  Map<Node, List<Allocation>> containedAllocations) {
+        List<AllocationFailureReason> allocationFailureReasons = new ArrayList<>();
+        for (var host : hosts) {
+            AllocationFailureReason reason = new AllocationFailureReason(host);
+            var availableHostResources = availableResources.get(host);
+            reason.violatesParentHostPolicy = violatesParentHostPolicy(node, host, containedAllocations);
+
+            NodeResources l = availableHostResources.nodeResources;
+            NodeResources r = node.flavor().resources();
+            if (l.vcpu()      < r.vcpu())                   { reason.insufficientVcpu = true;         }
+            if (l.memoryGb()  < r.memoryGb())               { reason.insufficientMemoryGb = true;     }
+            if (l.diskGb()    < r.diskGb())                 { reason.insufficientDiskGb = true;       }
+            if (r.diskSpeed() != NodeResources.DiskSpeed.any && r.diskSpeed() != l.diskSpeed())
+            { reason.incompatibleDiskSpeed = true;    }
+            if (availableHostResources.availableIPs < 1)    { reason.insufficientAvailableIPs = true; }
+
+            allocationFailureReasons.add(reason);
+        }
+
+        return new AllocationFailureReasonList(allocationFailureReasons);
+    }
+
+    /**
+     * Contains the list of hosts that, upon being removed, caused an unrecoverable state,
+     * as well as the specific host and tenant which caused it.
+     */
+    public static class HostFailurePath {
+        public List<Node> hostsCausingFailure;
+        public HostRemovalFailure failureReason;
+    }
+
+    /**
+     * Data class used for detailing why removing the given tenant from the given host was unsuccessful.
+     * A failure might not be caused by failing to allocate a specific tenant, in which case the fields
+     * will be empty.
+     */
+    public static class HostRemovalFailure {
+        public Optional<Node> host;
+        public Optional<Node> tenant;
+        public AllocationFailureReasonList allocationFailures;
+
+        public static HostRemovalFailure none() {
+            return new HostRemovalFailure(
+                    Optional.empty(),
+                    Optional.empty(),
+                    new AllocationFailureReasonList(List.of()));
+        }
+
+        public static HostRemovalFailure create(Node host, Node tenant, AllocationFailureReasonList failureReasons) {
+            return new HostRemovalFailure(
+                    Optional.of(host),
+                    Optional.of(tenant),
+                    failureReasons);
+        }
+
+        private HostRemovalFailure(Optional<Node> host, Optional<Node> tenant, AllocationFailureReasonList allocationFailures) {
+            this.host = host;
+            this.tenant = tenant;
+            this.allocationFailures = allocationFailures;
+        }
+
+        @Override
+        public String toString() {
+            if (host.isEmpty() || tenant.isEmpty()) return "No removal candidates exists.";
+            return String.format(
+                    "Failure to remove host %s" +
+                    "\n\tNo new host found for tenant %s:" +
+                    "\n\t\tSingular Reasons: %s" +
+                    "\n\t\tTotal Reasons:    %s",
+                    this.host.get().hostname(),
+                    this.tenant.get().hostname(),
+                    this.allocationFailures.singularReasonFailures().toString(),
+                    this.allocationFailures.toString()
+            );
+        }
+    }
+
+    /**
+     * Used to describe the resources required for a tenant, and available to a host.
+     */
+    private static class AllocationResources {
+        NodeResources nodeResources;
+        int availableIPs;
+
+        public static AllocationResources from(NodeResources nodeResources) {
+            return new AllocationResources(nodeResources, 1);
+        }
+
+        public AllocationResources(NodeResources nodeResources, int availableIPs) {
+            this.nodeResources = nodeResources;
+            this.availableIPs = availableIPs;
+        }
+
+        public boolean satisfies(AllocationResources other) {
+            if (!this.nodeResources.satisfies(other.nodeResources)) return false;
+            return this.availableIPs >= other.availableIPs;
+        }
+
+        public AllocationResources subtract(AllocationResources other) {
+            return new AllocationResources(this.nodeResources.subtract(other.nodeResources), this.availableIPs - other.availableIPs);
+        }
+    }
+
+    /**
+     * Keeps track of the reason why a host rejected an allocation.
+     */
+    private static class AllocationFailureReason {
+        Node host;
+        public AllocationFailureReason (Node host) {
+            this.host = host;
+        }
+        public boolean insufficientVcpu = false;
+        public boolean insufficientMemoryGb = false;
+        public boolean insufficientDiskGb = false;
+        public boolean incompatibleDiskSpeed = false;
+        public boolean insufficientAvailableIPs = false;
+        public boolean violatesParentHostPolicy = false;
+
+        public int numberOfReasons() {
+            int n = 0;
+            if (insufficientVcpu) n++;
+            if (insufficientMemoryGb) n++;
+            if (insufficientDiskGb) n++;
+            if (incompatibleDiskSpeed) n++;
+            if (insufficientAvailableIPs) n++;
+            if (violatesParentHostPolicy) n++;
+            return n;
+        }
+
+        @Override
+        public String toString() {
+            List<String> reasons = new ArrayList<>();
+            if (insufficientVcpu) reasons.add("insufficientVcpu");
+            if (insufficientMemoryGb) reasons.add("insufficientMemoryGb");
+            if (insufficientDiskGb) reasons.add("insufficientDiskGb");
+            if (incompatibleDiskSpeed) reasons.add("incompatibleDiskSpeed");
+            if (insufficientAvailableIPs) reasons.add("insufficientAvailableIPs");
+            if (violatesParentHostPolicy) reasons.add("violatesParentHostPolicy");
+
+            return String.format("[%s]", String.join(", ", reasons));
+        }
+    }
+
+    /**
+     * Provides convenient methods for tallying failures.
+     */
+    public static class AllocationFailureReasonList {
+        private List<AllocationFailureReason> allocationFailureReasons;
+        public AllocationFailureReasonList(List<AllocationFailureReason> allocationFailureReasons) {
+            this.allocationFailureReasons = allocationFailureReasons;
+        }
+
+        public long insufficientVcpu()         { return allocationFailureReasons.stream().filter(r -> r.insufficientVcpu).count(); }
+        public long insufficientMemoryGb()     { return allocationFailureReasons.stream().filter(r -> r.insufficientMemoryGb).count(); }
+        public long insufficientDiskGb()       { return allocationFailureReasons.stream().filter(r -> r.insufficientDiskGb).count(); }
+        public long incompatibleDiskSpeed()    { return allocationFailureReasons.stream().filter(r -> r.incompatibleDiskSpeed).count(); }
+        public long insufficientAvailableIps() { return allocationFailureReasons.stream().filter(r -> r.insufficientAvailableIPs).count(); }
+        public long violatesParentHostPolicy() { return allocationFailureReasons.stream().filter(r -> r.violatesParentHostPolicy).count(); }
+
+        public AllocationFailureReasonList singularReasonFailures() {
+            return new AllocationFailureReasonList(allocationFailureReasons.stream()
+                    .filter(reason -> reason.numberOfReasons() == 1).collect(Collectors.toList()));
+        }
+        public AllocationFailureReasonList multipleReasonFailures() {
+            return new AllocationFailureReasonList(allocationFailureReasons.stream()
+                    .filter(reason -> reason.numberOfReasons() > 1).collect(Collectors.toList()));
+        }
+        public long size() {
+            return allocationFailureReasons.size();
+        }
+        @Override
+        public String toString() {
+            return String.format("CPU (%3d), Memory (%3d), Disk size (%3d), Disk speed (%3d), IP (%3d), Parent-Host Policy (%3d)",
+                    insufficientVcpu(), insufficientMemoryGb(), insufficientDiskGb(),
+                    incompatibleDiskSpeed(), insufficientAvailableIps(), violatesParentHostPolicy());
+        }
+    }
+
+    public static class AllocationHistory {
+        public static class Entry {
+            public Node tenant;
+            public Node newParent;
+            public long eligibleParents;
+
+            public Entry(Node tenant, Node newParent, long eligibleParents) {
+                this.tenant = tenant;
+                this.newParent = newParent;
+                this.eligibleParents = eligibleParents;
+            }
+
+            @Override
+            public String toString() {
+                return String.format("%-20s %-65s -> %15s [%3d valid]",
+                        tenant.hostname().replaceFirst("\\..+", ""),
+                        tenant.flavor().resources(),
+                        newParent == null ? "x" : newParent.hostname().replaceFirst("\\..+", ""),
+                        this.eligibleParents
+                );
+            }
+        }
+
+        public List<Entry> historyEntries;
+
+        public AllocationHistory() {
+            this.historyEntries = new ArrayList<>();
+        }
+
+        public void addEntry(Node tenant, Node newParent, long eligibleParents) {
+            this.historyEntries.add(new Entry(tenant, newParent, eligibleParents));
+        }
+
+        public Set<String> oldParents() {
+            Set<String> oldParents = new HashSet<>();
+            for (var entry : historyEntries)
+                entry.tenant.parentHostname().ifPresent(oldParents::add);
+            return oldParents;
+        }
+
+        @Override
+        public String toString() {
+            StringBuilder out = new StringBuilder();
+
+            String currentParent = "";
+            for (var entry : historyEntries) {
+                String parentName = entry.tenant.parentHostname().orElseThrow();
+                if (!parentName.equals(currentParent)) {
+                    currentParent = parentName;
+                    out.append(parentName).append("\n");
+                }
+                out.append(entry.toString()).append("\n");
+            }
+
+            return out.toString();
+        }
+    }
+}
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/CapacityReportMaintainer.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/CapacityReportMaintainer.java
index 44d43081ef2..3c47e418b94 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/CapacityReportMaintainer.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/CapacityReportMaintainer.java
@@ -1,23 +1,15 @@
 package com.yahoo.vespa.hosted.provision.maintenance;
 
-import com.yahoo.config.provision.NodeResources;
-import com.yahoo.config.provision.NodeType;
 import com.yahoo.jdisc.Metric;
 import com.yahoo.log.LogLevel;
 import com.yahoo.vespa.hosted.provision.Node;
 import com.yahoo.vespa.hosted.provision.NodeRepository;
 
 import java.time.Duration;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
 import java.util.logging.Logger;
 import java.util.stream.Collectors;
 
-import com.yahoo.vespa.hosted.provision.node.Allocation;
-
 import java.util.*;
-import java.util.function.Function;
 
 /**
  * Performs analysis on the node repository to produce metrics that pertain to the capacity of the node repository.
@@ -29,7 +21,6 @@ import java.util.function.Function;
  * @author mgimle
  */
 public class CapacityReportMaintainer extends Maintainer {
-
     private final Metric metric;
     private final NodeRepository nodeRepository;
     private static final Logger log = Logger.getLogger(CapacityReportMaintainer.class.getName());
@@ -44,403 +35,20 @@ public class CapacityReportMaintainer extends Maintainer {
 
     @Override
     protected void maintain() {
-        metric.set("overcommittedHosts", countOvercommittedHosts(), null);
-
-        Optional<HostFailurePath> failurePath = worstCaseHostLossLeadingToFailure();
-        if (failurePath.isPresent()) {
-            int worstCaseHostLoss = failurePath.get().hostsCausingFailure.size();
-            metric.set("spareHostCapacity", worstCaseHostLoss - 1, null);
-        }
-    }
-
-    protected Optional<HostFailurePath> worstCaseHostLossLeadingToFailure() {
-        List<Node> hosts = getHosts();
-        List<Node> tenants = getTenants(hosts);
-        Map<String, Node> nodeMap = constructHostnameToNodeMap(hosts);
-        Map<Node, List<Node>> nodeChildren = constructNodeChildrenMap(tenants, hosts, nodeMap);
-        Map<Node, AllocationResources> availableResources = constructAvailableResourcesMap(hosts, nodeChildren);
-
-        Map<Node, Integer> timesNodeCanBeRemoved = computeMaximalRepeatedRemovals(hosts, nodeChildren, availableResources);
-        return greedyHeuristicFindFailurePath(timesNodeCanBeRemoved, hosts, nodeChildren, availableResources);
-    }
-
-    // We only care about nodes in one of these states.
-    private Node.State[] relevantNodeStates = {
-            Node.State.active,
-            Node.State.inactive,
-            Node.State.dirty,
-            Node.State.provisioned,
-            Node.State.ready,
-            Node.State.reserved
-    };
-
-    private List<Node> getHosts() {
-        return nodeRepository.getNodes(NodeType.host, relevantNodeStates);
-    }
-
-    private List<Node> getTenants(List<Node> hosts) {
-        var parentNames = hosts.stream().map(Node::hostname).collect(Collectors.toSet());
-        return nodeRepository.getNodes(NodeType.tenant, relevantNodeStates).stream()
-                .filter(t -> parentNames.contains(t.parentHostname().orElse("")))
-                .collect(Collectors.toList());
-    }
-
-    private Optional<HostFailurePath> greedyHeuristicFindFailurePath(Map<Node, Integer> heuristic, List<Node> hosts,
-                                                   Map<Node, List<Node>> nodeChildren,
-                                                   Map<Node, AllocationResources> availableResources) {
-        if (hosts.size() == 0) return Optional.empty();
-        List<Node> parentRemovalPriorityList = heuristic.entrySet().stream()
-                .sorted(Comparator.comparingInt(Map.Entry::getValue))
-                .map(Map.Entry::getKey)
-                .collect(Collectors.toList());
-        for (int i = 1; i <= parentRemovalPriorityList.size(); i++) {
-            List<Node> hostsToRemove = parentRemovalPriorityList.subList(0, i);
-            var hostRemovalFailure = findHostRemovalFailure(hostsToRemove, hosts, nodeChildren, availableResources);
-            if (hostRemovalFailure.isPresent()) {
-                HostFailurePath failurePath = new HostFailurePath();
-                failurePath.hostsCausingFailure = hostsToRemove;
-                failurePath.failureReason = hostRemovalFailure.get();
-                return Optional.of(failurePath);
+        if (!nodeRepository.zone().cloud().value().equals("aws")) {
+            CapacityChecker capacityChecker = new CapacityChecker(this.nodeRepository);
+            List<Node> overcommittedHosts = capacityChecker.findOvercommittedHosts();
+            if (overcommittedHosts.size() != 0) {
+                log.log(LogLevel.WARNING, String.format("%d nodes are overcommitted! [ %s ]", overcommittedHosts.size(),
+                        overcommittedHosts.stream().map(Node::hostname).collect(Collectors.joining(", "))));
             }
-        }
-
-        throw new IllegalStateException("No path to failure found. This should be impossible!");
-    }
-
-    protected int countOvercommittedHosts() {
-        List<Node> hosts = getHosts();
-        List<Node> tenants = getTenants(hosts);
-        var nodeMap = constructHostnameToNodeMap(hosts);
-        var nodeChildren = constructNodeChildrenMap(tenants, hosts, nodeMap);
-        var availableResources = constructAvailableResourcesMap(hosts, nodeChildren);
-
-        List<Node> overcommittedNodes = findOvercommittedNodes(availableResources);
-        if (overcommittedNodes.size() != 0) {
-            log.log(LogLevel.WARNING, String.format("%d nodes are overcommitted! [ %s ]", overcommittedNodes.size(),
-                    overcommittedNodes.stream().map(Node::hostname).collect(Collectors.joining(", "))));
-        }
-        return overcommittedNodes.size();
-    }
-
-    private Map<String, Node> constructHostnameToNodeMap(List<Node> nodes) {
-        return nodes.stream().collect(Collectors.toMap(Node::hostname, n -> n));
-    }
-
-    private Map<Node, List<Node>> constructNodeChildrenMap(List<Node> tenants, List<Node> hosts, Map<String, Node> hostnameToNode) {
-        Map<Node, List<Node>> nodeChildren = tenants.stream()
-                .filter(n -> n.parentHostname().isPresent())
-                .filter(n -> hostnameToNode.containsKey(n.parentHostname().get()))
-                .collect(Collectors.groupingBy(
-                        n -> hostnameToNode.get(n.parentHostname().orElseThrow())));
-
-        for (var host : hosts) nodeChildren.putIfAbsent(host, List.of());
-
-        return nodeChildren;
-    }
-
-    private Map<Node, AllocationResources> constructAvailableResourcesMap(List<Node> hosts, Map<Node, List<Node>> nodeChildren) {
-        Map<Node, AllocationResources> availableResources = new HashMap<>();
-        for (var host : hosts) {
-            NodeResources hostResources = host.flavor().resources();
-            int occupiedIps = 0;
-            Set<String> ipPool = host.ipAddressPool().asSet();
-            for (var child : nodeChildren.get(host)) {
-                hostResources = hostResources.subtract(child.flavor().resources());
-                occupiedIps += child.ipAddresses().stream().filter(ipPool::contains).count();
-            }
-            availableResources.put(host, new AllocationResources(hostResources, host.ipAddressPool().asSet().size() - occupiedIps));
-        }
-
-        return availableResources;
-    }
-
-    /**
-     * Computes a heuristic for each host, with a lower score indicating a higher perceived likelihood that removing
-     * the host causes an unrecoverable state
-     */
-    private Map<Node, Integer> computeMaximalRepeatedRemovals(List<Node> hosts, Map<Node, List<Node>> nodeChildren,
-                                                      Map<Node, AllocationResources> availableResources) {
-        Map<Node, Integer> timesNodeCanBeRemoved = hosts.stream().collect(Collectors.toMap(
-                Function.identity(),
-                _x -> Integer.MAX_VALUE
-        ));
-        for (Node host : hosts) {
-            List<Node> children = nodeChildren.get(host);
-            if (children.size() == 0) continue;
-            Map<Node, AllocationResources> resourceMap = new HashMap<>(availableResources);
-            Map<Node, List<Allocation>> containedAllocations = collateAllocations(nodeChildren);
-
-            int timesHostCanBeRemoved = 0;
-            Optional<Node> unallocatedTenant;
-            while (timesHostCanBeRemoved < 1000) { // Arbritrary upper bound
-                unallocatedTenant = tryAllocateNodes(nodeChildren.get(host), hosts, resourceMap, containedAllocations);
-                if (unallocatedTenant.isEmpty()) {
-                    timesHostCanBeRemoved++;
-                } else break;
-            }
-            timesNodeCanBeRemoved.put(host, timesHostCanBeRemoved);
-        }
-
-        return timesNodeCanBeRemoved;
-    }
-
-    private List<Node> findOvercommittedNodes(Map<Node, AllocationResources> availableResources) {
-        List<Node> overcommittedNodes = new ArrayList<>();
-        for (var entry : availableResources.entrySet()) {
-            var resources = entry.getValue().nodeResources;
-            if (resources.vcpu() < 0 || resources.memoryGb() < 0 || resources.diskGb() < 0) {
-                overcommittedNodes.add(entry.getKey());
-            }
-        }
-        return overcommittedNodes;
-    }
-
-    private Map<Node, List<Allocation>> collateAllocations(Map<Node, List<Node>> nodeChildren) {
-        return nodeChildren.entrySet().stream().collect(Collectors.toMap(
-                Map.Entry::getKey,
-                e -> e.getValue().stream()
-                        .map(Node::allocation).flatMap(Optional::stream)
-                        .collect(Collectors.toList())
-        ));
-    }
-
-    /**
-     * Tests whether it's possible to remove the provided hosts.
-     * Does not mutate any input variable.
-     * @return Empty optional if removal is possible, information on what caused the failure otherwise
-     */
-    private Optional<HostRemovalFailure> findHostRemovalFailure(List<Node> hostsToRemove, List<Node> allHosts,
-                                                        Map<Node, List<Node>> nodechildren,
-                                                        Map<Node, AllocationResources> availableResources) {
-        var containedAllocations = collateAllocations(nodechildren);
-        var resourceMap = new HashMap<>(availableResources);
-        List<Node> validAllocationTargets = allHosts.stream()
-                .filter(h -> !hostsToRemove.contains(h))
-                .collect(Collectors.toList());
-        if (validAllocationTargets.size() == 0) {
-            return Optional.of(HostRemovalFailure.none());
-        }
-
-        for (var host : hostsToRemove) {
-            Optional<Node> unallocatedNode = tryAllocateNodes(nodechildren.get(host),
-                    validAllocationTargets, resourceMap, containedAllocations);
-
-            if (unallocatedNode.isPresent()) {
-                AllocationFailureReasonList failures = collateAllocationFailures(unallocatedNode.get(),
-                        validAllocationTargets, resourceMap, containedAllocations);
-                return Optional.of(HostRemovalFailure.create(host, unallocatedNode.get(), failures));
-            }
-        }
-        return Optional.empty();
-    }
+            metric.set("overcommittedHosts", overcommittedHosts.size(), null);
 
-    /**
-     * Attempts to allocate the listed nodes to a new host, mutating availableResources and containedAllocations,
-     * optionally returning the first node to fail, if one does.
-     * */
-    private Optional<Node> tryAllocateNodes(List<Node> nodes, List<Node> hosts,
-                                    Map<Node, AllocationResources> availableResources,
-                                    Map<Node, List<Allocation>> containedAllocations) {
-        for (var node : nodes) {
-            if (!tryAllocateNode(node, hosts, availableResources, containedAllocations)) {
-                return Optional.of(node);
+            Optional<CapacityChecker.HostFailurePath> failurePath = capacityChecker.worstCaseHostLossLeadingToFailure();
+            if (failurePath.isPresent()) {
+                int worstCaseHostLoss = failurePath.get().hostsCausingFailure.size();
+                metric.set("spareHostCapacity", worstCaseHostLoss - 1, null);
             }
         }
-        return Optional.empty();
-    }
-
-    private boolean tryAllocateNode(Node node, List<Node> hosts,
-                            Map<Node, AllocationResources> availableResources,
-                            Map<Node, List<Allocation>> containedAllocations) {
-        AllocationResources requiredNodeResources = AllocationResources.from(node.flavor().resources());
-        for (var host : hosts) {
-            var availableHostResources = availableResources.get(host);
-            if (violatesParentHostPolicy(node, host, containedAllocations)) {
-                continue;
-            }
-            if (availableHostResources.satisfies(requiredNodeResources)) {
-                availableResources.put(host, availableHostResources.subtract(requiredNodeResources));
-                if (node.allocation().isPresent()) {
-                    containedAllocations.get(host).add(node.allocation().get());
-                }
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    private boolean violatesParentHostPolicy(Node node, Node host, Map<Node, List<Allocation>> containedAllocations) {
-        if (node.allocation().isEmpty()) return false;
-        Allocation nodeAllocation = node.allocation().get();
-        for (var allocation : containedAllocations.get(host)) {
-            if (allocation.membership().cluster().equalsIgnoringGroupAndVespaVersion(nodeAllocation.membership().cluster())
-                    && allocation.owner().equals(nodeAllocation.owner())) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    private AllocationFailureReasonList collateAllocationFailures(Node node, List<Node> hosts,
-                                                          Map<Node, AllocationResources> availableResources,
-                                                          Map<Node, List<Allocation>> containedAllocations) {
-        List<AllocationFailureReason> allocationFailureReasons = new ArrayList<>();
-        for (var host : hosts) {
-            AllocationFailureReason reason = new AllocationFailureReason(host);
-            var availableHostResources = availableResources.get(host);
-            reason.violatesParentHostPolicy = violatesParentHostPolicy(node, host, containedAllocations);
-
-            NodeResources l = availableHostResources.nodeResources;
-            NodeResources r = node.flavor().resources();
-            if (l.vcpu()      < r.vcpu())                   { reason.insufficientVcpu = true;         }
-            if (l.memoryGb()  < r.memoryGb())               { reason.insufficientMemoryGb = true;     }
-            if (l.diskGb()    < r.diskGb())                 { reason.insufficientDiskGb = true;       }
-            if (r.diskSpeed() != NodeResources.DiskSpeed.any && r.diskSpeed() != l.diskSpeed())
-                                                            { reason.incompatibleDiskSpeed = true;    }
-            if (availableHostResources.availableIPs < 1)    { reason.insufficientAvailableIPs = true; }
-
-            allocationFailureReasons.add(reason);
-        }
-
-        return new AllocationFailureReasonList(allocationFailureReasons);
-    }
-
-    /**
-     * Contains the list of hosts that, upon being removed, caused an unrecoverable state,
-     * as well as the specific host and tenant which caused it.
-     */
-    public static class HostFailurePath {
-        List<Node> hostsCausingFailure;
-        HostRemovalFailure failureReason;
-    }
-
-    /**
-     * Data class used for detailing why removing the given tenant from the given host was unsuccessful.
-     * A failure might not be caused by failing to allocate a specific tenant, in which case the fields
-     * will be empty.
-     */
-    public static class HostRemovalFailure {
-        Optional<Node> host;
-        Optional<Node> tenant;
-        AllocationFailureReasonList failureReasons;
-        public static HostRemovalFailure none() {
-            return new HostRemovalFailure(
-                    Optional.empty(),
-                    Optional.empty(),
-                    new AllocationFailureReasonList(List.of()));
-        }
-        public static HostRemovalFailure create(Node host, Node tenant, AllocationFailureReasonList failureReasons) {
-            return new HostRemovalFailure(
-                    Optional.of(host),
-                    Optional.of(tenant),
-                    failureReasons);
-        }
-        private HostRemovalFailure(Optional<Node> host, Optional<Node> tenant, AllocationFailureReasonList failureReasons) {
-            this.host = host;
-            this.tenant = tenant;
-            this.failureReasons = failureReasons;
-        }
-    }
-
-    /**
-     * Used to describe the resources required for a tenant, and available to a host.
-     */
-    private static class AllocationResources {
-        NodeResources nodeResources;
-        int availableIPs;
-
-        public static AllocationResources from(NodeResources nodeResources) {
-            return new AllocationResources(nodeResources, 1);
-        }
-
-        public AllocationResources(NodeResources nodeResources, int availableIPs) {
-            this.nodeResources = nodeResources;
-            this.availableIPs = availableIPs;
-        }
-
-        public boolean satisfies(AllocationResources other) {
-            if (!this.nodeResources.satisfies(other.nodeResources)) return false;
-            return this.availableIPs >= other.availableIPs;
-        }
-
-        public AllocationResources subtract(AllocationResources other) {
-            return new AllocationResources(this.nodeResources.subtract(other.nodeResources), this.availableIPs - other.availableIPs);
-        }
-    }
-
-    /**
-     * Keeps track of the reason why a host rejected an allocation.
-     */
-    private class AllocationFailureReason {
-        Node host;
-        public AllocationFailureReason (Node host) {
-            this.host = host;
-        }
-        public boolean insufficientVcpu = false;
-        public boolean insufficientMemoryGb = false;
-        public boolean insufficientDiskGb = false;
-        public boolean incompatibleDiskSpeed = false;
-        public boolean insufficientAvailableIPs = false;
-        public boolean violatesParentHostPolicy = false;
-
-        public int numberOfReasons() {
-            int n = 0;
-            if (insufficientVcpu) n++;
-            if (insufficientMemoryGb) n++;
-            if (insufficientDiskGb) n++;
-            if (incompatibleDiskSpeed) n++;
-            if (insufficientAvailableIPs) n++;
-            if (violatesParentHostPolicy) n++;
-            return n;
-        }
-
-        @Override
-        public String toString() {
-            List<String> reasons = new ArrayList<>();
-            if (insufficientVcpu) reasons.add("insufficientVcpu");
-            if (insufficientMemoryGb) reasons.add("insufficientMemoryGb");
-            if (insufficientDiskGb) reasons.add("insufficientDiskGb");
-            if (incompatibleDiskSpeed) reasons.add("incompatibleDiskSpeed");
-            if (insufficientAvailableIPs) reasons.add("insufficientAvailableIPs");
-            if (violatesParentHostPolicy) reasons.add("violatesParentHostPolicy");
-
-            return String.format("[%s]", String.join(", ", reasons));
-        }
-    }
-
-    /**
-     * Provides convenient methods for tallying failures.
-     */
-    public static class AllocationFailureReasonList {
-        private List<AllocationFailureReason> allocationFailureReasons;
-        public AllocationFailureReasonList(List<AllocationFailureReason> allocationFailureReasons) {
-            this.allocationFailureReasons = allocationFailureReasons;
-        }
-
-        long insufficientVcpu()         { return allocationFailureReasons.stream().filter(r -> r.insufficientVcpu).count(); }
-        long insufficientMemoryGb()     { return allocationFailureReasons.stream().filter(r -> r.insufficientMemoryGb).count(); }
-        long insufficientDiskGb()       { return allocationFailureReasons.stream().filter(r -> r.insufficientDiskGb).count(); }
-        long incompatibleDiskSpeed()    { return allocationFailureReasons.stream().filter(r -> r.incompatibleDiskSpeed).count(); }
-        long insufficientAvailableIps() { return allocationFailureReasons.stream().filter(r -> r.insufficientAvailableIPs).count(); }
-        long violatesParentHostPolicy() { return allocationFailureReasons.stream().filter(r -> r.violatesParentHostPolicy).count(); }
-
-        public AllocationFailureReasonList singularReasonFailures() {
-            return new AllocationFailureReasonList(allocationFailureReasons.stream()
-                    .filter(reason -> reason.numberOfReasons() == 1).collect(Collectors.toList()));
-        }
-        public AllocationFailureReasonList multipleReasonFailures() {
-            return new AllocationFailureReasonList(allocationFailureReasons.stream()
-                    .filter(reason -> reason.numberOfReasons() > 1).collect(Collectors.toList()));
-        }
-        public long size() {
-            return allocationFailureReasons.size();
-        }
-        @Override
-        public String toString() {
-            return String.format("CPU (%3d), Memory (%3d), Disk size (%3d), Disk speed (%3d), IP (%3d), Parent-Host Policy (%3d)",
-                    insufficientVcpu(), insufficientMemoryGb(), insufficientDiskGb(),
-                    incompatibleDiskSpeed(), insufficientAvailableIps(), violatesParentHostPolicy());
-        }
     }
 }
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/NodeRepositoryMaintenance.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/NodeRepositoryMaintenance.java
index f661977d933..bb1ff637f08 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/NodeRepositoryMaintenance.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/NodeRepositoryMaintenance.java
@@ -82,7 +82,7 @@ public class NodeRepositoryMaintenance extends AbstractComponent {
                 new HostProvisionMaintainer(nodeRepository, durationFromEnv("host_provisioner_interval").orElse(defaults.hostProvisionerInterval), hostProvisioner, flagSource));
         hostDeprovisionMaintainer = provisionServiceProvider.getHostProvisioner().map(hostProvisioner ->
                 new HostDeprovisionMaintainer(nodeRepository, durationFromEnv("host_deprovisioner_interval").orElse(defaults.hostDeprovisionerInterval), hostProvisioner, flagSource));
-        capacityReportMaintainer = new CapacityReportMaintainer(nodeRepository, metric, durationFromEnv("alert_interval").orElse(defaults.nodeAlerterInterval));
+        capacityReportMaintainer = new CapacityReportMaintainer(nodeRepository, metric, durationFromEnv("capacity_report_interval").orElse(defaults.capacityReportInterval));
 
         // The DuperModel is filled with infrastructure applications by the infrastructure provisioner, so explicitly run that now
         infrastructureProvisioner.maintain();
@@ -143,7 +143,7 @@ public class NodeRepositoryMaintenance extends AbstractComponent {
         private final Duration dirtyExpiry;
         private final Duration provisionedExpiry;
         private final Duration rebootInterval;
-        private final Duration nodeAlerterInterval;
+        private final Duration capacityReportInterval;
         private final Duration metricsInterval;
         private final Duration retiredInterval;
         private final Duration infrastructureProvisionInterval;
@@ -162,7 +162,7 @@ public class NodeRepositoryMaintenance extends AbstractComponent {
             failedExpirerInterval = Duration.ofMinutes(10);
             provisionedExpiry = Duration.ofHours(4);
             rebootInterval = Duration.ofDays(30);
-            nodeAlerterInterval = Duration.ofHours(1);
+            capacityReportInterval = Duration.ofHours(1);
             metricsInterval = Duration.ofMinutes(1);
             infrastructureProvisionInterval = Duration.ofMinutes(1);
             throttlePolicy = NodeFailer.ThrottlePolicy.hosted;
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/restapi/v2/HostCapacityResponse.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/restapi/v2/HostCapacityResponse.java
new file mode 100644
index 00000000000..9f5af52cc08
--- /dev/null
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/restapi/v2/HostCapacityResponse.java
@@ -0,0 +1,168 @@
+package com.yahoo.vespa.hosted.provision.restapi.v2;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.yahoo.container.jdisc.HttpRequest;
+import com.yahoo.container.jdisc.HttpResponse;
+import com.yahoo.slime.Cursor;
+import com.yahoo.slime.JsonFormat;
+import com.yahoo.slime.Slime;
+import com.yahoo.vespa.hosted.provision.Node;
+import com.yahoo.vespa.hosted.provision.NodeRepository;
+import com.yahoo.vespa.hosted.provision.maintenance.CapacityChecker;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+public class HostCapacityResponse extends HttpResponse {
+    private final StringBuilder text;
+    private final Slime slime;
+    private final CapacityChecker capacityChecker;
+    private final boolean json;
+
+    public HostCapacityResponse(NodeRepository nodeRepository, HttpRequest request) {
+        super(200);
+        capacityChecker = new CapacityChecker(nodeRepository);
+
+        json = request.getBooleanProperty("json");
+        String hostsJson = request.getProperty("hosts");
+
+        text = new StringBuilder();
+        slime = new Slime();
+        Cursor root = slime.setObject();
+
+        if (hostsJson != null) {
+            List<Node> hosts = parseHostList(hostsJson);
+            hostRemovalResponse(root, hosts);
+        } else {
+            zoneFailureReponse(root);
+        }
+    }
+
+    private List<Node> parseHostList(String hosts) {
+        ObjectMapper om = new ObjectMapper();
+        String[] hostsArray;
+        try {
+            hostsArray = om.readValue(hosts, String[].class);
+        } catch (Exception e) {
+            throw new IllegalArgumentException(e.getMessage());
+        }
+        List<String> hostNames = Arrays.asList(hostsArray);
+        try {
+            return capacityChecker.nodesFromHostnames(hostNames);
+        } catch (IllegalArgumentException e) {
+            throw new NotFoundException(e.getMessage());
+        }
+    }
+
+    private void hostRemovalResponse(Cursor root, List<Node> hosts) {
+        var failure = capacityChecker.findHostRemovalFailure(hosts);
+        if (failure.isPresent() && failure.get().failureReason.allocationFailures.size() == 0) {
+            root.setBool("removalPossible", false);
+            error(root, "Removing all hosts is trivially impossible.");
+        } else {
+            if (json) hostLossPossibleToSlime(root, failure, hosts);
+            else      hostLossPossibleToText(failure, hosts);
+        }
+    }
+
+    private void zoneFailureReponse(Cursor root) {
+        var failurePath = capacityChecker.worstCaseHostLossLeadingToFailure();
+        if (failurePath.isPresent()) {
+            if (json) zoneFailurePathToSlime(root, failurePath.get());
+            else      zoneFailurePathToText(failurePath.get());
+        } else {
+            error(root, "Node repository contained no hosts.");
+        }
+    }
+
+    private void error(Cursor root, String errorMessage) {
+        if (json) root.setString("error", errorMessage);
+        else text.append(errorMessage);
+    }
+
+    private void hostLossPossibleToText(Optional<CapacityChecker.HostFailurePath> failure, List<Node> hostsToRemove) {
+        text.append(String.format("Attempting to remove %d hosts: ", hostsToRemove.size()));
+        CapacityChecker.AllocationHistory history = capacityChecker.allocationHistory;
+        if (failure.isEmpty()) {
+            text.append("OK\n\n");
+            text.append(history);
+            if (history.oldParents().size() != hostsToRemove.size()) {
+                long emptyHostCount = hostsToRemove.size() - history.oldParents().size();
+                text.append(String.format("\nTrivially removed %d empty host%s.", emptyHostCount, emptyHostCount > 1 ? "s" : ""));
+            }
+        } else {
+            text.append("FAILURE\n\n");
+            text.append(history).append("\n");
+            text.append(failure.get().failureReason).append("\n\n");
+       }
+    }
+
+    private void zoneFailurePathToText(CapacityChecker.HostFailurePath failurePath) {
+        text.append(String.format("Found %d hosts. Failure upon trying to remove %d hosts:\n\n",
+                capacityChecker.getHosts().size(),
+                failurePath.hostsCausingFailure.size()));
+        text.append(capacityChecker.allocationHistory).append("\n");
+        text.append(failurePath.failureReason);
+    }
+
+    private void hostLossPossibleToSlime(Cursor root, Optional<CapacityChecker.HostFailurePath> failure, List<Node> hostsToRemove) {
+        var hosts = root.setArray("hostsToRemove");
+        hostsToRemove.forEach(h -> hosts.addString(h.hostname()));
+        CapacityChecker.AllocationHistory history = capacityChecker.allocationHistory;
+        root.setBool("removalPossible", failure.isEmpty());
+        var arr = root.setArray("history");
+        for (var entry : history.historyEntries) {
+            var object = arr.addObject();
+            object.setString("tenant", entry.tenant.hostname());
+            if (entry.newParent != null) {
+                object.setString("newParent", entry.newParent.hostname());
+            }
+            object.setLong("eligibleParents", entry.eligibleParents);
+        }
+    }
+
+    private void zoneFailurePathToSlime(Cursor object, CapacityChecker.HostFailurePath failurePath) {
+        object.setLong("totalHosts", capacityChecker.getHosts().size());
+        object.setLong("couldLoseHosts", failurePath.hostsCausingFailure.size());
+        failurePath.failureReason.host.ifPresent(host ->
+                object.setString("failedTenantParent", host.hostname())
+        );
+        failurePath.failureReason.tenant.ifPresent(tenant -> {
+            object.setString("failedTenant", tenant.hostname());
+            object.setString("failedTenantResources", tenant.flavor().resources().toString());
+            tenant.allocation().ifPresent(allocation ->
+                    object.setString("failedTenantAllocation", allocation.toString())
+            );
+            var explanation = object.setObject("hostCandidateRejectionReasons");
+            allocationFailureReasonListToSlime(explanation.setObject("singularReasonFailures"),
+                    failurePath.failureReason.allocationFailures.singularReasonFailures());
+            allocationFailureReasonListToSlime(explanation.setObject("totalFailures"),
+                    failurePath.failureReason.allocationFailures);
+        });
+        var details = object.setObject("details");
+        hostLossPossibleToSlime(details, Optional.of(failurePath), failurePath.hostsCausingFailure);
+    }
+
+    private void allocationFailureReasonListToSlime(Cursor root, CapacityChecker.AllocationFailureReasonList allocationFailureReasonList) {
+        root.setLong("insufficientVcpu", allocationFailureReasonList.insufficientVcpu());
+        root.setLong("insufficientMemoryGb", allocationFailureReasonList.insufficientMemoryGb());
+        root.setLong("insufficientDiskGb", allocationFailureReasonList.insufficientDiskGb());
+        root.setLong("incompatibleDiskSpeed", allocationFailureReasonList.incompatibleDiskSpeed());
+        root.setLong("insufficientAvailableIps", allocationFailureReasonList.insufficientAvailableIps());
+        root.setLong("violatesParentHostPolicy", allocationFailureReasonList.violatesParentHostPolicy());
+    }
+
+    @Override
+    public void render(OutputStream stream) throws IOException {
+        if (json) new JsonFormat(true).encode(stream, slime);
+        else stream.write(text.toString().getBytes());
+    }
+
+    @Override
+    public String getContentType() {
+        return json ? "application/json" : "text/plain";
+    }
+}
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/restapi/v2/NodesApiHandler.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/restapi/v2/NodesApiHandler.java
index 22318f1ddb4..e036124e489 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/restapi/v2/NodesApiHandler.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/restapi/v2/NodesApiHandler.java
@@ -102,6 +102,7 @@ public class NodesApiHandler extends LoggingRequestHandler {
         if (path.equals(    "/nodes/v2/command/")) return ResourcesResponse.fromStrings(request.getUri(), "restart", "reboot");
         if (path.equals(    "/nodes/v2/maintenance/")) return new JobsResponse(nodeRepository.jobControl());
         if (path.equals(    "/nodes/v2/upgrade/")) return new UpgradeResponse(nodeRepository.infrastructureVersions(), nodeRepository.osVersions(), nodeRepository.dockerImages());
+        if (path.startsWith("/nodes/v2/capacity/")) return new HostCapacityResponse(nodeRepository, request);
         throw new NotFoundException("Nothing at path '" + path + "'");
     }
 
diff --git a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/maintenance/CapacityReportMaintainerTest.java b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/maintenance/CapacityCheckerTest.java
index a486f8619c5..1f2112673d1 100644
--- a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/maintenance/CapacityReportMaintainerTest.java
+++ b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/maintenance/CapacityCheckerTest.java
@@ -8,20 +8,19 @@ import org.junit.Test;
 import java.io.IOException;
 import java.nio.file.Paths;
 import java.util.*;
+
 import static org.junit.Assert.fail;
 import static org.junit.Assert.*;
 
 /**
  * @author mgimle
  */
-public class CapacityReportMaintainerTest {
-    private CapacityReportMaintainerTester tester;
-    private CapacityReportMaintainer capacityReporter;
+public class CapacityCheckerTest {
+    private CapacityCheckerTester tester;
 
     @Before
     public void setup() {
-        tester = new CapacityReportMaintainerTester();
-        capacityReporter = tester.makeCapacityReportMaintainer();
+        tester = new CapacityCheckerTester();
     }
 
     @Test
@@ -30,10 +29,9 @@ public class CapacityReportMaintainerTest {
 
         tester.cleanRepository();
         tester.restoreNodeRepositoryFromJsonFile(Paths.get(path));
-        var failurePath = capacityReporter.worstCaseHostLossLeadingToFailure();
-        if (failurePath.isPresent()) {
-            assertTrue(tester.nodeRepository.getNodes(NodeType.host).containsAll(failurePath.get().hostsCausingFailure));
-        } else fail();
+        var failurePath = tester.capacityChecker.worstCaseHostLossLeadingToFailure();
+        assertTrue(failurePath.isPresent());
+        assertTrue(tester.nodeRepository.getNodes(NodeType.host).containsAll(failurePath.get().hostsCausingFailure));
     }
 
     @Test
@@ -41,7 +39,7 @@ public class CapacityReportMaintainerTest {
         tester.createNodes(7, 4,
                10, new NodeResources(-1, 10, 100), 10,
                 0, new NodeResources(1, 10, 100), 10);
-        int overcommittedHosts = capacityReporter.countOvercommittedHosts();
+        int overcommittedHosts = tester.capacityChecker.findOvercommittedHosts().size();
         assertEquals(tester.nodeRepository.getNodes(NodeType.host).size(), overcommittedHosts);
     }
 
@@ -50,14 +48,14 @@ public class CapacityReportMaintainerTest {
         tester.createNodes(1, 1,
                 0, new NodeResources(1, 10, 100), 10,
                 0, new NodeResources(1, 10, 100), 10);
-        var failurePath = capacityReporter.worstCaseHostLossLeadingToFailure();
+        var failurePath = tester.capacityChecker.worstCaseHostLossLeadingToFailure();
         assertFalse("Computing worst case host loss with no hosts should return an empty optional.", failurePath.isPresent());
 
         // Odd edge case that should never be able to occur in prod
         tester.createNodes(1, 10,
                 10, new NodeResources(10, 1000, 10000), 100,
                 1, new NodeResources(10, 1000, 10000), 100);
-        failurePath = capacityReporter.worstCaseHostLossLeadingToFailure();
+        failurePath = tester.capacityChecker.worstCaseHostLossLeadingToFailure();
         assertTrue(failurePath.isPresent());
         assertTrue("Computing worst case host loss if all hosts have to be removed should result in an non-empty failureReason with empty nodes.",
                 failurePath.get().failureReason.tenant.isEmpty() && failurePath.get().failureReason.host.isEmpty());
@@ -66,10 +64,10 @@ public class CapacityReportMaintainerTest {
         tester.createNodes(3, 30,
                 10, new NodeResources(0, 0, 10000), 1000,
                 0, new NodeResources(0, 0, 0), 0);
-        failurePath = capacityReporter.worstCaseHostLossLeadingToFailure();
+        failurePath = tester.capacityChecker.worstCaseHostLossLeadingToFailure();
         assertTrue(failurePath.isPresent());
         if (failurePath.get().failureReason.tenant.isPresent()) {
-            var failureReasons = failurePath.get().failureReason.failureReasons;
+            var failureReasons = failurePath.get().failureReason.allocationFailures;
             assertEquals("When there are multiple lacking resources, all failures are multipleReasonFailures",
                     failureReasons.size(), failureReasons.multipleReasonFailures().size());
             assertEquals(0, failureReasons.singularReasonFailures().size());
@@ -81,10 +79,10 @@ public class CapacityReportMaintainerTest {
         tester.createNodes(1, 10,
                 10, new NodeResources(10, 1000, 10000), 1,
                 10, new NodeResources(10, 1000, 10000), 1);
-        var failurePath = capacityReporter.worstCaseHostLossLeadingToFailure();
+        var failurePath = tester.capacityChecker.worstCaseHostLossLeadingToFailure();
         assertTrue(failurePath.isPresent());
         if (failurePath.get().failureReason.tenant.isPresent()) {
-            var failureReasons = failurePath.get().failureReason.failureReasons;
+            var failureReasons = failurePath.get().failureReason.allocationFailures;
             assertEquals("All failures should be due to hosts having a lack of available ip addresses.",
                     failureReasons.singularReasonFailures().insufficientAvailableIps(), failureReasons.size());
         } else fail();
@@ -96,10 +94,10 @@ public class CapacityReportMaintainerTest {
         tester.createNodes(1, 10,
                 10, new NodeResources(1, 100, 1000), 100,
                 10, new NodeResources(0, 100, 1000), 100);
-        var failurePath = capacityReporter.worstCaseHostLossLeadingToFailure();
+        var failurePath = tester.capacityChecker.worstCaseHostLossLeadingToFailure();
         assertTrue(failurePath.isPresent());
         if (failurePath.get().failureReason.tenant.isPresent()) {
-            var failureReasons = failurePath.get().failureReason.failureReasons;
+            var failureReasons = failurePath.get().failureReason.allocationFailures;
             assertEquals("All failures should be due to hosts lacking cpu cores.",
                     failureReasons.singularReasonFailures().insufficientVcpu(), failureReasons.size());
         } else fail();
@@ -107,10 +105,10 @@ public class CapacityReportMaintainerTest {
         tester.createNodes(1, 10,
                 10, new NodeResources(10, 1, 1000), 100,
                 10, new NodeResources(10, 0, 1000), 100);
-        failurePath = capacityReporter.worstCaseHostLossLeadingToFailure();
+        failurePath = tester.capacityChecker.worstCaseHostLossLeadingToFailure();
         assertTrue(failurePath.isPresent());
         if (failurePath.get().failureReason.tenant.isPresent()) {
-            var failureReasons = failurePath.get().failureReason.failureReasons;
+            var failureReasons = failurePath.get().failureReason.allocationFailures;
             assertEquals("All failures should be due to hosts lacking memory.",
                     failureReasons.singularReasonFailures().insufficientMemoryGb(), failureReasons.size());
         } else fail();
@@ -118,10 +116,10 @@ public class CapacityReportMaintainerTest {
         tester.createNodes(1, 10,
                 10, new NodeResources(10, 100, 10), 100,
                 10, new NodeResources(10, 100, 0), 100);
-        failurePath = capacityReporter.worstCaseHostLossLeadingToFailure();
+        failurePath = tester.capacityChecker.worstCaseHostLossLeadingToFailure();
         assertTrue(failurePath.isPresent());
         if (failurePath.get().failureReason.tenant.isPresent()) {
-            var failureReasons = failurePath.get().failureReason.failureReasons;
+            var failureReasons = failurePath.get().failureReason.allocationFailures;
             assertEquals("All failures should be due to hosts lacking disk space.",
                     failureReasons.singularReasonFailures().insufficientDiskGb(), failureReasons.size());
         } else fail();
@@ -130,10 +128,10 @@ public class CapacityReportMaintainerTest {
         tester.createNodes(1, 10, List.of(new NodeResources(1, 10, 100)),
                 10, new NodeResources(0, 0, 0), 100,
                 10, new NodeResources(10, 1000, 10000, NodeResources.DiskSpeed.slow), 100);
-        failurePath = capacityReporter.worstCaseHostLossLeadingToFailure();
+        failurePath = tester.capacityChecker.worstCaseHostLossLeadingToFailure();
         assertTrue(failurePath.isPresent());
         if (failurePath.get().failureReason.tenant.isPresent()) {
-            var failureReasons = failurePath.get().failureReason.failureReasons;
+            var failureReasons = failurePath.get().failureReason.allocationFailures;
             assertEquals("All empty hosts should be invalid due to having incompatible disk speed.",
                     failureReasons.singularReasonFailures().incompatibleDiskSpeed(), emptyHostsWithSlowDisk);
         } else fail();
@@ -146,10 +144,10 @@ public class CapacityReportMaintainerTest {
         tester.createNodes(1, 1,
                 10, new NodeResources(1, 100, 1000), 100,
                 10, new NodeResources(10, 1000, 10000), 100);
-        var failurePath = capacityReporter.worstCaseHostLossLeadingToFailure();
+        var failurePath = tester.capacityChecker.worstCaseHostLossLeadingToFailure();
         assertTrue(failurePath.isPresent());
         if (failurePath.get().failureReason.tenant.isPresent()) {
-            var failureReasons = failurePath.get().failureReason.failureReasons;
+            var failureReasons = failurePath.get().failureReason.allocationFailures;
             assertEquals("With only one type of tenant, all failures should be due to violation of the parent host policy.",
                     failureReasons.singularReasonFailures().violatesParentHostPolicy(), failureReasons.size());
         } else fail();
@@ -157,10 +155,10 @@ public class CapacityReportMaintainerTest {
         tester.createNodes(1, 2,
                 10, new NodeResources(10, 100, 1000), 1,
                 0, new NodeResources(0, 0, 0), 0);
-        failurePath = capacityReporter.worstCaseHostLossLeadingToFailure();
+        failurePath = tester.capacityChecker.worstCaseHostLossLeadingToFailure();
         assertTrue(failurePath.isPresent());
         if (failurePath.get().failureReason.tenant.isPresent()) {
-            var failureReasons = failurePath.get().failureReason.failureReasons;
+            var failureReasons = failurePath.get().failureReason.allocationFailures;
             assertNotEquals("Fewer distinct children than hosts should result in some parent host policy violations.",
                     failureReasons.size(), failureReasons.singularReasonFailures().violatesParentHostPolicy());
             assertNotEquals(0, failureReasons.singularReasonFailures().violatesParentHostPolicy());
diff --git a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/maintenance/CapacityReportMaintainerTester.java b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/maintenance/CapacityCheckerTester.java
index ccea4691f10..f5fd0e0526d 100644
--- a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/maintenance/CapacityReportMaintainerTester.java
+++ b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/maintenance/CapacityCheckerTester.java
@@ -20,7 +20,6 @@ import com.yahoo.vespa.hosted.provision.testutils.MockNameResolver;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.time.Duration;
 import java.time.Instant;
 import java.util.*;
 import java.util.stream.Collectors;
@@ -29,22 +28,23 @@ import java.util.stream.IntStream;
 /**
  * @author mgimle
  */
-public class CapacityReportMaintainerTester {
+public class CapacityCheckerTester {
     public static final Zone zone = new Zone(Environment.prod, RegionName.from("us-east"));
 
     // Components with state
     public final ManualClock clock = new ManualClock();
     public final NodeRepository nodeRepository;
+    public CapacityChecker capacityChecker;
 
-    CapacityReportMaintainerTester() {
+    CapacityCheckerTester() {
         Curator curator = new MockCurator();
         NodeFlavors f = new NodeFlavors(new FlavorConfigBuilder().build());
         nodeRepository = new NodeRepository(f, curator, clock, zone, new MockNameResolver().mockAnyLookup(),
                                             DockerImage.fromString("docker-registry.domain.tld:8080/dist/vespa"), true);
     }
 
-    CapacityReportMaintainer makeCapacityReportMaintainer() {
-        return new CapacityReportMaintainer(nodeRepository, new MetricsReporterTest.TestMetric(), Duration.ofDays(1));
+    private void updateCapacityChecker() {
+        this.capacityChecker = new CapacityChecker(this.nodeRepository);
     }
 
     List<NodeModel> createDistinctChildren(int amount, List<NodeResources> childResources) {
@@ -167,9 +167,9 @@ public class CapacityReportMaintainerTester {
         nodes.addAll(createEmptyHosts(numHosts, numEmptyHosts, emptyHostExcessCapacity, emptyHostExcessIps));
 
         nodeRepository.addNodes(nodes);
+        updateCapacityChecker();
     }
 
-
     NodeResources containingNodeResources(List<NodeResources> resources, NodeResources excessCapacity) {
         NodeResources usedByChildren = resources.stream()
                 .reduce(new NodeResources(0, 0, 0), NodeResources::add);
@@ -278,6 +278,7 @@ public class CapacityReportMaintainerTester {
         }
 
         nodeRepository.addNodes(nodes);
+        updateCapacityChecker();
     }
 
     void cleanRepository() {
diff --git a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/restapi/v2/RestApiTest.java b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/restapi/v2/RestApiTest.java
index bfb24d30284..35fa5adaeff 100644
--- a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/restapi/v2/RestApiTest.java
+++ b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/restapi/v2/RestApiTest.java
@@ -21,6 +21,7 @@ import java.io.IOException;
 import java.nio.charset.CharacterCodingException;
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
+import java.util.List;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
@@ -819,6 +820,30 @@ public class RestApiTest {
                        "{\"message\":\"Cancelled outstanding requests for firmware checks\"}");
     }
 
+    @Test
+    public void test_capacity() throws Exception {
+        assertFile(new Request("http://localhost:8080/nodes/v2/capacity/?json=true"), "capacity-zone.json");
+
+        List<String> hostsToRemove = List.of(
+                "%22dockerhost1.yahoo.com%22",
+                "%22dockerhost2.yahoo.com%22",
+                "%22dockerhost3.yahoo.com%22",
+                "%22dockerhost4.yahoo.com%22"
+        );
+        String requestUriTemplate =
+                "http://localhost:8080/nodes/v2/capacity/?json=true&hosts=[%s]"
+                        .replaceAll("\\[", "%%5B")
+                        .replaceAll("]", "%%5D");
+
+        assertFile(new Request(String.format(requestUriTemplate,
+                String.join(",", hostsToRemove.subList(0, 3)))),
+                "capacity-hostremoval-possible.json");
+        assertFile(new Request(String.format(requestUriTemplate,
+                String.join(",", hostsToRemove))),
+                "capacity-hostremoval-impossible.json");
+    }
+
+
     /** Tests the rendering of each node separately to make it easier to find errors */
     @Test
     public void test_single_node_rendering() throws Exception {
diff --git a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/restapi/v2/responses/capacity-hostremoval-impossible.json b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/restapi/v2/responses/capacity-hostremoval-impossible.json
new file mode 100644
index 00000000000..f3c73e61c91
--- /dev/null
+++ b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/restapi/v2/responses/capacity-hostremoval-impossible.json
@@ -0,0 +1,20 @@
+{
+  "hostsToRemove": [
+    "dockerhost1.yahoo.com",
+    "dockerhost2.yahoo.com",
+    "dockerhost3.yahoo.com",
+    "dockerhost4.yahoo.com"
+  ],
+  "removalPossible": false,
+  "history": [
+    {
+      "tenant": "host4.yahoo.com",
+      "newParent": "dockerhost5.yahoo.com",
+      "eligibleParents": 1
+    },
+    {
+      "tenant": "test-node-pool-101-2",
+      "eligibleParents": 0
+    }
+  ]
+}
\ No newline at end of file
diff --git a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/restapi/v2/responses/capacity-hostremoval-possible.json b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/restapi/v2/responses/capacity-hostremoval-possible.json
new file mode 100644
index 00000000000..b896fd9d63a
--- /dev/null
+++ b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/restapi/v2/responses/capacity-hostremoval-possible.json
@@ -0,0 +1,20 @@
+{
+  "hostsToRemove": [
+    "dockerhost1.yahoo.com",
+    "dockerhost2.yahoo.com",
+    "dockerhost3.yahoo.com"
+  ],
+  "removalPossible": true,
+  "history": [
+    {
+      "tenant": "host4.yahoo.com",
+      "newParent": "dockerhost4.yahoo.com",
+      "eligibleParents": 2
+    },
+    {
+      "tenant": "test-node-pool-101-2",
+      "newParent": "dockerhost5.yahoo.com",
+      "eligibleParents": 1
+    }
+  ]
+}
\ No newline at end of file
diff --git a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/restapi/v2/responses/capacity-zone.json b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/restapi/v2/responses/capacity-zone.json
new file mode 100644
index 00000000000..9895948e69d
--- /dev/null
+++ b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/restapi/v2/responses/capacity-zone.json
@@ -0,0 +1,46 @@
+{
+  "totalHosts": 5,
+  "couldLoseHosts": 4,
+  "failedTenantParent": "dockerhost1.yahoo.com",
+  "failedTenant": "host4.yahoo.com",
+  "failedTenantResources": "[vcpu: 1.0, memory: 1.0 Gb, disk 100.0 Gb]",
+  "failedTenantAllocation": "allocated to tenant3.application3.instance3 as 'content/id3/0/0'",
+  "hostCandidateRejectionReasons": {
+    "singularReasonFailures": {
+      "insufficientVcpu": 0,
+      "insufficientMemoryGb": 0,
+      "insufficientDiskGb": 0,
+      "incompatibleDiskSpeed": 0,
+      "insufficientAvailableIps": 0,
+      "violatesParentHostPolicy": 1
+    },
+    "totalFailures": {
+      "insufficientVcpu": 0,
+      "insufficientMemoryGb": 0,
+      "insufficientDiskGb": 0,
+      "incompatibleDiskSpeed": 0,
+      "insufficientAvailableIps": 0,
+      "violatesParentHostPolicy": 1
+    }
+  },
+  "details": {
+    "hostsToRemove": [
+      "dockerhost2.yahoo.com",
+      "dockerhost1.yahoo.com",
+      "dockerhost4.yahoo.com",
+      "dockerhost3.yahoo.com"
+    ],
+    "removalPossible": false,
+    "history": [
+      {
+        "tenant": "test-node-pool-101-2",
+        "newParent": "dockerhost5.yahoo.com",
+        "eligibleParents": 1
+      },
+      {
+        "tenant": "host4.yahoo.com",
+        "eligibleParents": 0
+      }
+    ]
+  }
+}
\ No newline at end of file