Apply policies to limits

2 files changed, 32 insertions, 20 deletions

diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/CapacityPolicies.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/CapacityPolicies.java
index 0c2c3c48df1..7b151226956 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/CapacityPolicies.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/CapacityPolicies.java
@@ -3,6 +3,7 @@ package com.yahoo.vespa.hosted.provision.provisioning;
 
 import com.yahoo.config.provision.ApplicationId;
 import com.yahoo.config.provision.Capacity;
+import com.yahoo.config.provision.ClusterResources;
 import com.yahoo.config.provision.ClusterSpec;
 import com.yahoo.config.provision.Environment;
 import com.yahoo.config.provision.NodeResources;
@@ -29,6 +30,21 @@ public class CapacityPolicies {
         this.sharedHosts = type -> PermanentFlags.SHARED_HOST.bindTo(nodeRepository.flagSource()).value().isEnabled(type.name());
     }
 
+    public Capacity applyOn(Capacity capacity, boolean isTester, ClusterSpec cluster) {
+        return capacity.withLimits(applyOn(capacity.minResources(), capacity, isTester, cluster),
+                                   applyOn(capacity.maxResources(), capacity, isTester, cluster));
+    }
+
+    public ClusterResources applyOn(ClusterResources resources, Capacity capacity, boolean isTester, ClusterSpec cluster) {
+        int nodes = decideSize(resources.nodes(), capacity.isRequired(),
+                                                  capacity.canFail(),
+                                                  isTester,
+                                                  cluster);
+        int groups = Math.min(resources.groups(), nodes); // cannot have more groups than nodes
+        var nodeResources = decideNodeResources(resources.nodeResources(), capacity.isRequired(), cluster);
+        return new ClusterResources(nodes, groups, nodeResources);
+    }
+
     public int decideSize(int requested, boolean required, boolean canFail, boolean isTester, ClusterSpec cluster) {
         if (isTester) return 1;
 
@@ -44,9 +60,6 @@ public class CapacityPolicies {
     }
 
     public NodeResources decideNodeResources(NodeResources target, boolean required, ClusterSpec cluster) {
-        if (target.isUnspecified())
-            target = defaultNodeResources(cluster.type());
-
         if (required) return target;
 
         // Dev does not cap the cpu or network of containers since usage is spotty: Allocate just a small amount exclusively
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodeRepositoryProvisioner.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodeRepositoryProvisioner.java
index b35b0a5e301..f1e8ae81547 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodeRepositoryProvisioner.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodeRepositoryProvisioner.java
@@ -84,8 +84,8 @@ public class NodeRepositoryProvisioner implements Provisioner {
     @Override
     public List<HostSpec> prepare(ApplicationId application, ClusterSpec cluster, Capacity requested,
                                   ProvisionLogger logger) {
-        log.log(Level.FINE, () -> "Received deploy prepare request for " + requested +
-                                  " for application " + application + ", cluster " + cluster);
+        log.log(Level.FINE, "Received deploy prepare request for " + requested +
+                            " for application " + application + ", cluster " + cluster);
 
         if (cluster.group().isPresent()) throw new IllegalArgumentException("Node requests cannot specify a group");
 
@@ -96,17 +96,16 @@ public class NodeRepositoryProvisioner implements Provisioner {
         NodeResources resources;
         NodeSpec nodeSpec;
         if (requested.type() == NodeType.tenant) {
-            ClusterResources target = decideTargetResources(application, cluster, requested);
-            int nodeCount = capacityPolicies.decideSize(target.nodes(),
-                                                        requested.isRequired(),
-                                                        requested.canFail(),
-                                                        application.instance().isTester(),
-                                                        cluster);
-            groups = Math.min(target.groups(), nodeCount); // cannot have more groups than nodes
-            resources = capacityPolicies.decideNodeResources(target.nodeResources(), requested.isRequired(), cluster);
-            boolean exclusive = capacityPolicies.decideExclusivity(requested, cluster.isExclusive());
-            nodeSpec = NodeSpec.from(nodeCount, resources, exclusive, requested.canFail());
-            logIfDownscaled(target.nodes(), nodeCount, cluster, logger);
+            var actual = capacityPolicies.applyOn(requested, application.instance().isTester(), cluster);
+            ClusterResources target = decideTargetResources(application, cluster, actual);
+
+            boolean exclusive = capacityPolicies.decideExclusivity(actual, cluster.isExclusive());
+            nodeSpec = NodeSpec.from(target.nodes(), target.nodeResources(), exclusive, actual.canFail());
+            logIfDownscaled(requested.minResources().nodes(), actual.minResources().nodes(), cluster, logger);
+            groups = target.groups();
+            resources = target.nodeResources();
+            if (resources.isUnspecified())
+                resources = capacityPolicies.defaultNodeResources(cluster.type());
         }
         else {
             groups = 1; // type request with multiple groups is not supported
@@ -190,10 +189,10 @@ public class NodeRepositoryProvisioner implements Provisioner {
                                   .advertisedResources();
     }
 
-    private void logIfDownscaled(int targetNodes, int actualNodes, ClusterSpec cluster, ProvisionLogger logger) {
-        if (zone.environment().isManuallyDeployed() && actualNodes < targetNodes)
-            logger.log(Level.INFO, "Requested " + targetNodes + " nodes for " + cluster +
-                                   ", downscaling to " + actualNodes + " nodes in " + zone.environment());
+    private void logIfDownscaled(int requestedMinNodes, int actualMinNodes, ClusterSpec cluster, ProvisionLogger logger) {
+        if (zone.environment().isManuallyDeployed() && actualMinNodes < requestedMinNodes)
+            logger.log(Level.INFO, "Requested " + requestedMinNodes + " nodes for " + cluster +
+                                   ", downscaling to " + actualMinNodes + " nodes in " + zone.environment());
     }
 
     private List<HostSpec> asSortedHosts(List<Node> nodes, NodeResources requestedResources) {