1 files changed, 33 insertions, 43 deletions

diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodeAllocation.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodeAllocation.java
index ca170d2af6b..e1be5b48e2d 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodeAllocation.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodeAllocation.java
@@ -1,4 +1,4 @@
-// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 package com.yahoo.vespa.hosted.provision.provisioning;
 
 import com.yahoo.config.provision.ApplicationId;
@@ -84,9 +84,10 @@ class NodeAllocation {
 
     private final NodeRepository nodeRepository;
     private final Optional<String> requiredHostFlavor;
+    private final boolean makeExclusive;
 
     NodeAllocation(NodeList allNodes, ApplicationId application, ClusterSpec cluster, NodeSpec requested,
-                   Supplier<Integer> nextIndex, NodeRepository nodeRepository) {
+                   Supplier<Integer> nextIndex, NodeRepository nodeRepository, boolean makeExclusive) {
         this.allNodes = allNodes;
         this.application = application;
         this.cluster = cluster;
@@ -99,6 +100,7 @@ class NodeAllocation {
                                                                         .with(FetchVector.Dimension.CLUSTER_ID, cluster.id().value())
                                                                         .value())
                                           .filter(s -> !s.isBlank());
+        this.makeExclusive = makeExclusive;
     }
 
     /**
@@ -117,21 +119,21 @@ class NodeAllocation {
                 ClusterMembership membership = allocation.membership();
                 if ( ! allocation.owner().equals(application)) continue; // wrong application
                 if ( ! membership.cluster().satisfies(cluster)) continue; // wrong cluster id/type
-                if ( candidate.state() == Node.State.active && allocation.removable()) continue; // don't accept; causes removal
-                if ( candidate.state() == Node.State.active && candidate.wantToFail()) continue; // don't accept; causes failing
-                if ( indexes.contains(membership.index())) continue; // duplicate index (just to be sure)
+                if (candidate.state() == Node.State.active && allocation.removable()) continue; // don't accept; causes removal
+                if (candidate.state() == Node.State.active && candidate.wantToFail()) continue; // don't accept; causes failing
+                if (indexes.contains(membership.index())) continue; // duplicate index (just to be sure)
                 if (nodeRepository.zone().cloud().allowEnclave() && candidate.parent.isPresent() && ! candidate.parent.get().cloudAccount().equals(requested.cloudAccount())) continue; // wrong account
 
                 boolean resizeable = requested.considerRetiring() && candidate.isResizable;
 
-                if ((! saturated() && hasCompatibleResources(candidate) && requested.acceptable(candidate)) || acceptIncompatible(candidate)) {
+                if (( ! saturated() && hasCompatibleResources(candidate) && requested.acceptable(candidate)) || acceptIncompatible(candidate)) {
                     candidate = candidate.withNode();
                     if (candidate.isValid())
                         acceptNode(candidate, shouldRetire(candidate, candidates), resizeable);
                 }
             }
-            else if (! saturated() && hasCompatibleResources(candidate)) {
-                if (! nodeRepository.nodeResourceLimits().isWithinRealLimits(candidate, application, cluster)) {
+            else if ( ! saturated() && hasCompatibleResources(candidate)) {
+                if ( ! nodeRepository.nodeResourceLimits().isWithinRealLimits(candidate, application, cluster)) {
                     ++rejectedDueToInsufficientRealResources;
                     continue;
                 }
@@ -139,9 +141,13 @@ class NodeAllocation {
                     ++rejectedDueToClashingParentHost;
                     continue;
                 }
-                if ( violatesExclusivity(candidate)) {
-                    ++rejectedDueToExclusivity;
-                    continue;
+                switch (violatesExclusivity(candidate)) {
+                    case PARENT_HOST_NOT_EXCLUSIVE -> candidate = candidate.withExclusiveParent(true);
+                    case NONE -> {}
+                    case YES -> {
+                        ++rejectedDueToExclusivity;
+                        continue;
+                    }
                 }
                 if (candidate.wantToRetire()) {
                     continue;
@@ -169,7 +175,7 @@ class NodeAllocation {
         if (candidate.parent.map(node -> node.status().wantToUpgradeFlavor()).orElse(false)) return Retirement.violatesHostFlavorGeneration;
         if (candidate.wantToRetire()) return Retirement.hardRequest;
         if (candidate.preferToRetire() && candidate.replaceableBy(candidates)) return Retirement.softRequest;
-        if (violatesExclusivity(candidate)) return Retirement.violatesExclusivity;
+        if (violatesExclusivity(candidate) != NodeCandidate.ExclusivityViolation.NONE) return Retirement.violatesExclusivity;
         if (requiredHostFlavor.isPresent() && ! candidate.parent.map(node -> node.flavor().name()).equals(requiredHostFlavor)) return Retirement.violatesHostFlavor;
         if (candidate.violatesSpares) return Retirement.violatesSpares;
         return Retirement.none;
@@ -186,39 +192,15 @@ class NodeAllocation {
     }
 
     private boolean offeredNodeHasParentHostnameAlreadyAccepted(NodeCandidate candidate) {
-        for (NodeCandidate acceptedNode : nodes.values()) {
-            if (acceptedNode.parentHostname().isPresent() && candidate.parentHostname().isPresent() &&
-                    acceptedNode.parentHostname().get().equals(candidate.parentHostname().get())) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    private boolean violatesExclusivity(NodeCandidate candidate) {
         if (candidate.parentHostname().isEmpty()) return false;
-        if (requested.type() != NodeType.tenant) return false;
-
-        // In zones which does not allow host sharing, exclusivity is violated if...
-        if ( ! nodeRepository.zone().cloud().allowHostSharing()) {
-            // TODO: Write this in a way that is simple to read
-            // If either the parent is dedicated to a cluster type different from this cluster
-            return  ! candidate.parent.flatMap(Node::exclusiveToClusterType).map(cluster.type()::equals).orElse(true) ||
-                    // or the parent is dedicated to a different application
-                    ! candidate.parent.flatMap(Node::exclusiveToApplicationId).map(application::equals).orElse(true) ||
-                    // or this cluster requires exclusivity, but the host is not exclusive
-                    (nodeRepository.exclusiveAllocation(cluster) && candidate.parent.flatMap(Node::exclusiveToApplicationId).isEmpty());
-        }
+        return nodes.values().stream().anyMatch(acceptedNode -> acceptedNode.parentHostname().equals(candidate.parentHostname()));
+    }
 
-        // In zones with shared hosts we require that if either of the nodes on the host requires exclusivity,
-        // then all the nodes on the host must have the same owner
-        for (Node nodeOnHost : allNodes.childrenOf(candidate.parentHostname().get())) {
-            if (nodeOnHost.allocation().isEmpty()) continue;
-            if (nodeRepository.exclusiveAllocation(cluster) || nodeOnHost.allocation().get().membership().cluster().isExclusive()) {
-                if ( ! nodeOnHost.allocation().get().owner().equals(application)) return true;
-            }
-        }
-        return false;
+    private NodeCandidate.ExclusivityViolation violatesExclusivity(NodeCandidate candidate) {
+        return candidate.violatesExclusivity(cluster, application,
+                                             nodeRepository.exclusiveAllocation(cluster),
+                                             nodeRepository.exclusiveProvisioning(cluster),
+                                             nodeRepository.zone().cloud().allowHostSharing(), allNodes, makeExclusive);
     }
 
     /**
@@ -399,6 +381,14 @@ class NodeAllocation {
         return requested.type();
     }
 
+    List<Node> parentsRequiredToBeExclusive() {
+        return nodes.values()
+                    .stream()
+                    .filter(candidate -> candidate.exclusiveParent)
+                    .map(candidate -> candidate.parent.orElseThrow())
+                    .toList();
+    }
+
     List<Node> finalNodes() {
         GroupAssigner groupAssigner = new GroupAssigner(requested, allNodes, nodeRepository.clock());
         Collection<NodeCandidate> finalNodes = groupAssigner.assignTo(nodes.values());