1 files changed, 74 insertions, 57 deletions
diff --git a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/autoscale/Fixture.java b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/autoscale/Fixture.java
index 896897f45c1..2edd797b78a 100644
--- a/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/autoscale/Fixture.java
+++ b/node-repository/src/test/java/com/yahoo/vespa/hosted/provision/autoscale/Fixture.java
@@ -3,18 +3,24 @@ package com.yahoo.vespa.hosted.provision.autoscale;
 
 import com.yahoo.config.provision.ApplicationId;
 import com.yahoo.config.provision.Capacity;
+import com.yahoo.config.provision.Cloud;
 import com.yahoo.config.provision.ClusterResources;
 import com.yahoo.config.provision.ClusterSpec;
 import com.yahoo.config.provision.Environment;
 import com.yahoo.config.provision.NodeResources;
 import com.yahoo.config.provision.RegionName;
 import com.yahoo.config.provision.Zone;
+import com.yahoo.vespa.hosted.provision.Node;
 import com.yahoo.vespa.hosted.provision.NodeList;
+import com.yahoo.vespa.hosted.provision.applications.Application;
+import com.yahoo.vespa.hosted.provision.applications.Cluster;
 import com.yahoo.vespa.hosted.provision.provisioning.HostResourcesCalculator;
 
 import java.time.Duration;
+import java.util.Arrays;
+import java.util.List;
 import java.util.Optional;
-import java.util.function.IntFunction;
+import java.util.stream.Collectors;
 
 /**
  * Fixture for autoscaling tests.
@@ -24,105 +30,102 @@ import java.util.function.IntFunction;
 public class Fixture {
 
     final AutoscalingTester tester;
-    final ApplicationId application;
-    final ClusterSpec cluster;
+    final ApplicationId applicationId;
+    final ClusterSpec clusterSpec;
     final Capacity capacity;
+    final Loader loader;
 
     public Fixture(Fixture.Builder builder, Optional<ClusterResources> initialResources) {
-        application = builder.application;
-        cluster = builder.cluster;
+        applicationId = builder.application;
+        clusterSpec = builder.cluster;
         capacity = builder.capacity;
-        tester = new AutoscalingTester(builder.zone, builder.hostResources, builder.resourceCalculator);
+        tester = new AutoscalingTester(builder.zone, builder.resourceCalculator, builder.hostResources);
         var deployCapacity = initialResources.isPresent() ? Capacity.from(initialResources.get()) : capacity;
         tester.deploy(builder.application, builder.cluster, deployCapacity);
+        this.loader = new Loader(this);
     }
 
-    public AutoscalingTester  tester() { return tester; }
+    public AutoscalingTester tester() { return tester; }
 
-    /** Autoscale within the deployed capacity of this. */
-    public Autoscaler.Advice autoscale() {
-        return autoscale(capacity);
-    }
+    public ApplicationId applicationId() { return applicationId; }
 
-    /** Autoscale within the given capacity. */
-    public Autoscaler.Advice autoscale(Capacity capacity) {
-        return tester().autoscale(application, cluster, capacity);
+    public ClusterSpec.Id clusterId() { return clusterSpec.id(); }
+
+    public Application application() {
+        return tester().nodeRepository().applications().get(applicationId).orElse(Application.empty(applicationId));
     }
 
-    /** Redeploy with the deployed capacity of this. */
-    public void deploy() {
-        deploy(capacity);
+    public Cluster cluster() {
+        return application().cluster(clusterId()).get();
     }
 
-    /** Redeploy with the given capacity. */
-    public void deploy(Capacity capacity) {
-        tester().deploy(application, cluster, capacity);
+    public ClusterModel clusterModel() {
+        return new ClusterModel(application(),
+                                clusterSpec,
+                                cluster(),
+                                nodes(),
+                                tester.nodeRepository().metricsDb(),
+                                tester.nodeRepository().clock());
     }
 
     /** Returns the nodes allocated to the fixture application cluster */
     public NodeList nodes() {
-        return tester().nodeRepository().nodes().list().owner(application).cluster(cluster.id());
+        return tester().nodeRepository().nodes().list(Node.State.active).owner(applicationId).cluster(clusterSpec.id());
     }
 
-    public void deactivateRetired(Capacity capacity) {
-        tester().deactivateRetired(application, cluster, capacity);
-    }
+    public Loader loader() { return loader; }
 
-    public void setScalingDuration(Duration duration) {
-        tester().setScalingDuration(application, cluster.id(), duration);
+    /** Autoscale within the deployed capacity of this. */
+    public Autoscaler.Advice autoscale() {
+        return autoscale(capacity);
     }
 
-    public Duration addCpuMeasurements(double cpuLoad, int measurements) {
-        return tester().addCpuMeasurements((float)cpuLoad, 1.0f, measurements, application);
+    /** Autoscale within the given capacity. */
+    public Autoscaler.Advice autoscale(Capacity capacity) {
+        return tester().autoscale(applicationId, clusterSpec, capacity);
     }
 
-    public Duration addLoadMeasurements(int measurements, IntFunction<Double> queryRate, IntFunction<Double> writeRate) {
-        return tester().addLoadMeasurements(application, cluster.id(), measurements, queryRate, writeRate);
+    /** Compute an autoscaling suggestion for this. */
+    public Autoscaler.Advice suggest() {
+        return tester().suggest(applicationId, clusterSpec.id(), capacity.minResources(), capacity.maxResources());
     }
 
-    public void applyCpuLoad(double cpuLoad, int measurements) {
-        Duration samplingInterval = Duration.ofSeconds(150L); // in addCpuMeasurements
-        tester().addCpuMeasurements((float)cpuLoad, 1.0f, measurements, application);
-        tester().clock().advance(samplingInterval.negated().multipliedBy(measurements));
-        tester().addQueryRateMeasurements(application, cluster.id(), measurements, samplingInterval, t -> t == 0 ? 20.0 : 10.0); // Query traffic only
+    /** Redeploy with the deployed capacity of this. */
+    public void deploy() {
+        deploy(capacity);
     }
 
-    public void applyMemLoad(double memLoad, int measurements) {
-        Duration samplingInterval = Duration.ofSeconds(150L); // in addCpuMeasurements
-        tester().addMemMeasurements((float)memLoad, 1.0f, measurements, application);
-        tester().clock().advance(samplingInterval.negated().multipliedBy(measurements));
-        tester().addQueryRateMeasurements(application, cluster.id(), measurements, samplingInterval, t -> t == 0 ? 20.0 : 10.0); // Query traffic only
+    /** Redeploy with the given capacity. */
+    public void deploy(Capacity capacity) {
+        tester().deploy(applicationId, clusterSpec, capacity);
     }
 
-    public void applyLoad(double cpuLoad, double memoryLoad, double diskLoad, int measurements) {
-        Duration samplingInterval = Duration.ofSeconds(150L); // in addCpuMeasurements
-        tester().addMeasurements((float)cpuLoad, (float)memoryLoad, (float)diskLoad, measurements, application);
-        tester().clock().advance(samplingInterval.negated().multipliedBy(measurements));
-        tester().addQueryRateMeasurements(application, cluster.id(), measurements, samplingInterval, t -> t == 0 ? 20.0 : 10.0); // Query traffic only
+    public void deactivateRetired(Capacity capacity) {
+        tester().deactivateRetired(applicationId, clusterSpec, capacity);
     }
 
-    public void applyLoad(double cpuLoad, double memoryLoad, double diskLoad, int generation, boolean inService, boolean stable, int measurements) {
-        Duration samplingInterval = Duration.ofSeconds(150L); // in addCpuMeasurements
-        tester().addMeasurements((float)cpuLoad, (float)memoryLoad, (float)diskLoad, generation, inService, stable, measurements, application);
-        tester().clock().advance(samplingInterval.negated().multipliedBy(measurements));
-        tester().addQueryRateMeasurements(application, cluster.id(), measurements, samplingInterval, t -> t == 0 ? 20.0 : 10.0); // Query traffic only
+    public void setScalingDuration(Duration duration) {
+        tester().setScalingDuration(applicationId, clusterSpec.id(), duration);
     }
 
     public void storeReadShare(double currentReadShare, double maxReadShare) {
-        tester().storeReadShare(currentReadShare, maxReadShare, application);
+        var application = application();
+        application = application.with(application.status().withCurrentReadShare(currentReadShare)
+                                                  .withMaxReadShare(maxReadShare));
+        tester.nodeRepository().applications().put(application, tester.nodeRepository().nodes().lock(applicationId));
     }
 
     public static class Builder {
 
-        NodeResources hostResources = new NodeResources(100, 100, 100, 1);
+        ApplicationId application = AutoscalingTester.applicationId("application1");
+        ClusterSpec cluster = ClusterSpec.request(ClusterSpec.Type.content, ClusterSpec.Id.from("cluster1")).vespaVersion("7").build();
+        Zone zone = new Zone(Environment.prod, RegionName.from("us-east"));
+        List<NodeResources> hostResources = List.of(new NodeResources(100, 100, 100, 1));
         Optional<ClusterResources> initialResources = Optional.of(new ClusterResources(5, 1, new NodeResources(3, 10, 100, 1)));
         Capacity capacity = Capacity.from(new ClusterResources(2, 1,
                                                                new NodeResources(1, 1, 1, 1, NodeResources.DiskSpeed.any)),
                                           new ClusterResources(20, 1,
                                                                new NodeResources(100, 1000, 1000, 1, NodeResources.DiskSpeed.any)));
-        ApplicationId application = AutoscalingTester.applicationId("application1");
-        ClusterSpec cluster = ClusterSpec.request(ClusterSpec.Type.content, ClusterSpec.Id.from("cluster1")).vespaVersion("7").build();
-        Zone zone = new Zone(Environment.prod, RegionName.from("us-east"));
         HostResourcesCalculator resourceCalculator = new AutoscalingTester.MockHostResourcesCalculator(zone, 0);
 
         public Fixture.Builder zone(Zone zone) {
@@ -130,13 +133,27 @@ public class Fixture {
             return this;
         }
 
+        /**
+         * Set to true to behave as if hosts are provisioned dynamically,
+         * and must therefore be allocated completely to one tenant node.
+         */
+        public Fixture. Builder dynamicProvisioning(boolean dynamic) {
+            this.zone = new Zone(Cloud.builder()
+                                      .dynamicProvisioning(dynamic)
+                                      .build(),
+                                 zone.system(),
+                                 zone.environment(),
+                                 zone.region());
+            return this;
+        }
+
         public Fixture.Builder clusterType(ClusterSpec.Type type) {
             cluster = ClusterSpec.request(type, cluster.id()).vespaVersion("7").build();
             return this;
         }
 
-        public Fixture.Builder hostResources(NodeResources hostResources) {
-            this.hostResources = hostResources;
+        public Fixture.Builder hostResources(NodeResources ... hostResources) {
+            this.hostResources = Arrays.stream(hostResources).collect(Collectors.toList());
             return this;
         }