aboutsummaryrefslogtreecommitdiffstats
path: root/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/HostCapacityMaintainer.java
diff options
context:
space:
mode:
Diffstat (limited to 'node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/HostCapacityMaintainer.java')
-rw-r--r--node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/HostCapacityMaintainer.java92
1 files changed, 51 insertions, 41 deletions
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/HostCapacityMaintainer.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/HostCapacityMaintainer.java
index 156be954c61..108f8d77837 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/HostCapacityMaintainer.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/HostCapacityMaintainer.java
@@ -13,7 +13,10 @@ import com.yahoo.config.provision.NodeType;
import com.yahoo.jdisc.Metric;
import com.yahoo.lang.MutableInteger;
import com.yahoo.transaction.Mutex;
+import com.yahoo.vespa.flags.BooleanFlag;
+import com.yahoo.vespa.flags.FetchVector;
import com.yahoo.vespa.flags.FlagSource;
+import com.yahoo.vespa.flags.Flags;
import com.yahoo.vespa.flags.ListFlag;
import com.yahoo.vespa.flags.PermanentFlags;
import com.yahoo.vespa.flags.custom.ClusterCapacity;
@@ -25,7 +28,6 @@ import com.yahoo.vespa.hosted.provision.NodeRepository;
import com.yahoo.vespa.hosted.provision.node.Agent;
import com.yahoo.vespa.hosted.provision.node.History;
import com.yahoo.vespa.hosted.provision.node.IP;
-import com.yahoo.vespa.hosted.provision.provisioning.AllocationParams;
import com.yahoo.vespa.hosted.provision.provisioning.HostProvisionRequest;
import com.yahoo.vespa.hosted.provision.provisioning.HostProvisioner;
import com.yahoo.vespa.hosted.provision.provisioning.HostProvisioner.HostSharing;
@@ -45,7 +47,6 @@ import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
-import static com.yahoo.vespa.hosted.provision.provisioning.NodeCandidate.ExclusivityViolation.YES;
import static java.util.Comparator.comparing;
import static java.util.Comparator.naturalOrder;
import static java.util.stream.Collectors.groupingBy;
@@ -61,6 +62,7 @@ public class HostCapacityMaintainer extends NodeRepositoryMaintainer {
private final HostProvisioner hostProvisioner;
private final ListFlag<ClusterCapacity> preprovisionCapacityFlag;
+ private final BooleanFlag makeExclusiveFlag;
private final ProvisioningThrottler throttler;
HostCapacityMaintainer(NodeRepository nodeRepository,
@@ -71,6 +73,7 @@ public class HostCapacityMaintainer extends NodeRepositoryMaintainer {
super(nodeRepository, interval, metric);
this.hostProvisioner = hostProvisioner;
this.preprovisionCapacityFlag = PermanentFlags.PREPROVISION_CAPACITY.bindTo(flagSource);
+ this.makeExclusiveFlag = Flags.MAKE_EXCLUSIVE.bindTo(flagSource);
this.throttler = new ProvisioningThrottler(nodeRepository, metric);
}
@@ -156,13 +159,12 @@ public class HostCapacityMaintainer extends NodeRepositoryMaintainer {
}
private List<Node> provision(NodeList nodeList) {
- return provisionUntilNoDeficit(nodeList)
- .stream()
- .sorted(comparing(node -> node.history().events().stream()
- .map(History.Event::at)
- .min(naturalOrder())
- .orElse(Instant.MIN)))
- .toList();
+ return provisionUntilNoDeficit(nodeList).stream()
+ .sorted(comparing(node -> node.history().events().stream()
+ .map(History.Event::at)
+ .min(naturalOrder())
+ .orElse(Instant.MIN)))
+ .toList();
}
private static boolean canRemoveHost(Node host) {
@@ -189,9 +191,12 @@ public class HostCapacityMaintainer extends NodeRepositoryMaintainer {
* should be sufficient (avoid no stack trace).
*/
private List<Node> provisionUntilNoDeficit(NodeList nodeList) {
- // Ensure flags for allocation params are evaluated before provision loop. Use a dummy cluster spec
- var params = AllocationParams.from(nodeRepository(), ApplicationId.defaultId(), asClusterSpec(Optional.empty(), 0), Vtag.currentVersion);
List<ClusterCapacity> preprovisionCapacity = preprovisionCapacityFlag.value();
+ ApplicationId application = ApplicationId.defaultId();
+ boolean makeExclusive = makeExclusiveFlag.with(FetchVector.Dimension.TENANT_ID, application.tenant().value())
+ .with(FetchVector.Dimension.INSTANCE_ID, application.serializedForm())
+ .with(FetchVector.Dimension.VESPA_VERSION, Vtag.currentVersion.toFullString())
+ .value();
// Worst-case each ClusterCapacity in preprovisionCapacity will require an allocation.
int maxProvisions = preprovisionCapacity.size();
@@ -199,7 +204,7 @@ public class HostCapacityMaintainer extends NodeRepositoryMaintainer {
var nodesPlusProvisioned = new ArrayList<>(nodeList.asList());
for (int numProvisions = 0;; ++numProvisions) {
var nodesPlusProvisionedPlusAllocated = new ArrayList<>(nodesPlusProvisioned);
- Optional<ClusterCapacity> deficit = allocatePreprovisionCapacity(params, preprovisionCapacity, nodesPlusProvisionedPlusAllocated);
+ Optional<ClusterCapacity> deficit = allocatePreprovisionCapacity(application, preprovisionCapacity, nodesPlusProvisionedPlusAllocated, makeExclusive);
if (deficit.isEmpty()) {
return nodesPlusProvisionedPlusAllocated;
}
@@ -209,22 +214,21 @@ public class HostCapacityMaintainer extends NodeRepositoryMaintainer {
}
ClusterCapacity clusterCapacityDeficit = deficit.get();
- nodesPlusProvisioned.addAll(provisionHosts(params,
- clusterCapacityDeficit.count(),
+ nodesPlusProvisioned.addAll(provisionHosts(clusterCapacityDeficit.count(),
toNodeResources(clusterCapacityDeficit),
Optional.ofNullable(clusterCapacityDeficit.clusterType()),
nodeList));
}
}
- private List<Node> provisionHosts(AllocationParams params, int count, NodeResources nodeResources, Optional<String> clusterType, NodeList allNodes) {
+ private List<Node> provisionHosts(int count, NodeResources nodeResources, Optional<String> clusterType, NodeList allNodes) {
try {
if (throttler.throttle(allNodes, Agent.HostCapacityMaintainer)) {
throw new NodeAllocationException("Host provisioning is being throttled", true);
}
Version osVersion = nodeRepository().osVersions().targetFor(NodeType.host).orElse(Version.emptyVersion);
List<Integer> provisionIndices = nodeRepository().database().readProvisionIndices(count);
- HostSharing sharingMode = params.exclusiveAllocation() ? HostSharing.exclusive : HostSharing.shared;
+ HostSharing sharingMode = nodeRepository().exclusiveAllocation(asSpec(clusterType, 0)) ? HostSharing.exclusive : HostSharing.shared;
HostProvisionRequest request = new HostProvisionRequest(provisionIndices, NodeType.host, nodeResources,
ApplicationId.defaultId(), osVersion,
sharingMode, clusterType.map(ClusterSpec.Type::valueOf), Optional.empty(),
@@ -232,16 +236,15 @@ public class HostCapacityMaintainer extends NodeRepositoryMaintainer {
List<Node> hosts = new ArrayList<>();
Runnable waiter;
try (var lock = nodeRepository().nodes().lockUnallocated()) {
- waiter = hostProvisioner.provisionHosts(params.sharedHost(),
- request,
- resources -> true,
- provisionedHosts -> {
- hosts.addAll(provisionedHosts.stream()
- .map(host -> host.generateHost(Duration.ZERO))
- .map(host -> host.withExclusiveToApplicationId(null))
- .toList());
- nodeRepository().nodes().addNodes(hosts, Agent.HostCapacityMaintainer);
- });
+ waiter = hostProvisioner.provisionHosts(request,
+ resources -> true,
+ provisionedHosts -> {
+ hosts.addAll(provisionedHosts.stream()
+ .map(host -> host.generateHost(Duration.ZERO))
+ .map(host -> host.withExclusiveToApplicationId(null))
+ .toList());
+ nodeRepository().nodes().addNodes(hosts, Agent.HostCapacityMaintainer);
+ });
}
waiter.run();
return hosts;
@@ -260,18 +263,14 @@ public class HostCapacityMaintainer extends NodeRepositoryMaintainer {
* they are added to {@code mutableNodes}
* @return the part of a cluster capacity it was unable to allocate, if any
*/
- private Optional<ClusterCapacity> allocatePreprovisionCapacity(AllocationParams params,
+ private Optional<ClusterCapacity> allocatePreprovisionCapacity(ApplicationId application,
List<ClusterCapacity> preprovisionCapacity,
- ArrayList<Node> mutableNodes) {
+ ArrayList<Node> mutableNodes,
+ boolean makeExclusive) {
for (int clusterIndex = 0; clusterIndex < preprovisionCapacity.size(); ++clusterIndex) {
ClusterCapacity clusterCapacity = preprovisionCapacity.get(clusterIndex);
-
- params = params.with(asClusterSpec(Optional.ofNullable(clusterCapacity.clusterType()), clusterIndex));
- if (params.exclusiveProvisioning())
- throw new IllegalStateException("Preprovision cluster requires exclusive provisioning: " + clusterCapacity);
-
LockedNodeList allNodes = new LockedNodeList(mutableNodes, () -> {});
- List<Node> candidates = findCandidates(params, clusterCapacity, allNodes);
+ List<Node> candidates = findCandidates(application, clusterCapacity, clusterIndex, allNodes, makeExclusive);
int deficit = Math.max(0, clusterCapacity.count() - candidates.size());
if (deficit > 0) {
return Optional.of(clusterCapacity.withCount(deficit));
@@ -284,34 +283,45 @@ public class HostCapacityMaintainer extends NodeRepositoryMaintainer {
return Optional.empty();
}
- private List<Node> findCandidates(AllocationParams params, ClusterCapacity clusterCapacity, LockedNodeList allNodes) {
+ private List<Node> findCandidates(ApplicationId application, ClusterCapacity clusterCapacity, int clusterIndex, LockedNodeList allNodes, boolean makeExclusive) {
NodeResources nodeResources = toNodeResources(clusterCapacity);
// We'll allocate each ClusterCapacity as a unique cluster in a dummy application
+ ClusterSpec cluster = asSpec(Optional.ofNullable(clusterCapacity.clusterType()), clusterIndex);
NodeSpec nodeSpec = NodeSpec.from(clusterCapacity.count(), 1, nodeResources, false, true,
nodeRepository().zone().cloud().account(), Duration.ZERO);
var allocationContext = IP.Allocation.Context.from(nodeRepository().zone().cloud().name(),
nodeSpec.cloudAccount().isExclave(nodeRepository().zone()),
nodeRepository().nameResolver());
- NodePrioritizer prioritizer = new NodePrioritizer(params, allNodes, nodeSpec, true, false, allocationContext, nodeRepository().nodes(),
- nodeRepository().resourcesCalculator(), nodeRepository().spareCount());
+ NodePrioritizer prioritizer = new NodePrioritizer(allNodes, application, cluster, nodeSpec,
+ true, false, allocationContext, nodeRepository().nodes(),
+ nodeRepository().resourcesCalculator(), nodeRepository().spareCount(),
+ nodeRepository().exclusiveAllocation(cluster), makeExclusive);
List<NodeCandidate> nodeCandidates = prioritizer.collect()
.stream()
- .filter(node -> node.violatesExclusivity(params, allNodes) != YES)
+ .filter(node -> node.violatesExclusivity(cluster,
+ application,
+ nodeRepository().exclusiveClusterType(cluster),
+ nodeRepository().exclusiveAllocation(cluster),
+ false,
+ nodeRepository().zone().cloud().allowHostSharing(),
+ allNodes,
+ makeExclusive)
+ != NodeCandidate.ExclusivityViolation.YES)
.toList();
MutableInteger index = new MutableInteger(0);
return nodeCandidates
.stream()
.limit(clusterCapacity.count())
.map(candidate -> candidate.toNode()
- .allocate(params.application(),
- ClusterMembership.from(params.cluster(), index.next()),
+ .allocate(application,
+ ClusterMembership.from(cluster, index.next()),
nodeResources,
nodeRepository().clock().instant()))
.toList();
}
- private static ClusterSpec asClusterSpec(Optional<String> clusterType, int index) {
+ private static ClusterSpec asSpec(Optional<String> clusterType, int index) {
return ClusterSpec.request(clusterType.map(ClusterSpec.Type::from).orElse(ClusterSpec.Type.content),
ClusterSpec.Id.from(String.valueOf(index)))
.vespaVersion(Vtag.currentVersion) // Needed, but should not be used here.