Enumerate possibilities instead of using builder

4 files changed, 51 insertions, 85 deletions

diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/GroupPreparer.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/GroupPreparer.java
index 75f3c892571..51a30e6d638 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/GroupPreparer.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/GroupPreparer.java
@@ -100,10 +100,8 @@ public class GroupPreparer {
 
                     // Offer the nodes on the newly provisioned hosts, this should be enough to cover the deficit
                     List<NodeCandidate> candidates = provisionedHosts.stream()
-                                                                     .map(provisionedHost -> new NodeCandidate.Builder(provisionedHost.generateNode())
-                                                                             .parent(provisionedHost.generateHost())
-                                                                             .newNode(true)
-                                                                             .build())
+                                                                     .map(host -> NodeCandidate.createExclusiveChild(host.generateNode(),
+                                                                                                                     host.generateHost()))
                                                                      .collect(Collectors.toList());
                     allocation.offer(candidates);
                 }
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 c7b6b3876b9..d6fbaee0cb7 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
@@ -107,7 +107,7 @@ 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.isSurplusNode || saturated()) && ! membership.cluster().group().equals(cluster.group())) continue; // wrong group and we can't or have no reason to change it
+                if ((! candidate.isSurplus || saturated()) && ! membership.cluster().group().equals(cluster.group())) continue; // wrong group and we can't or have no reason to change it
                 if ( candidate.state() == Node.State.active && allocation.isRemovable()) continue; // don't accept; causes removal
                 if ( indexes.contains(membership.index())) continue; // duplicate index (just to be sure)
 
@@ -364,11 +364,11 @@ class NodeAllocation {
     List<Node> reservableNodes() {
         // Include already reserved nodes to extend reservation period and to potentially update their cluster spec.
         EnumSet<Node.State> reservableStates = EnumSet.of(Node.State.inactive, Node.State.ready, Node.State.reserved);
-        return nodesFilter(n -> ! n.isNewNode && reservableStates.contains(n.state()));
+        return nodesFilter(n -> ! n.isNew && reservableStates.contains(n.state()));
     }
 
     List<Node> newNodes() {
-        return nodesFilter(n -> n.isNewNode);
+        return nodesFilter(n -> n.isNew);
     }
 
     private List<Node> nodesFilter(Predicate<NodeCandidate> predicate) {
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodeCandidate.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodeCandidate.java
index dcf5ea470ad..46f1dd2d206 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodeCandidate.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodeCandidate.java
@@ -39,23 +39,23 @@ abstract class NodeCandidate implements Nodelike, Comparable<NodeCandidate> {
     final boolean violatesSpares;
 
     /** True if this node belongs to a group which will not be needed after this deployment */
-    final boolean isSurplusNode;
+    final boolean isSurplus;
 
     /** This node does not exist in the node repository yet */
-    final boolean isNewNode;
+    final boolean isNew;
 
     /** This node can be resized to the new NodeResources */
     final boolean isResizable;
 
-    private NodeCandidate(NodeResources freeParentCapacity, Optional<Node> parent, boolean violatesSpares, boolean isSurplusNode, boolean isNewNode, boolean isResizeable) {
-        if (isResizeable && isNewNode)
+    private NodeCandidate(NodeResources freeParentCapacity, Optional<Node> parent, boolean violatesSpares, boolean isSurplus, boolean isNew, boolean isResizeable) {
+        if (isResizeable && isNew)
             throw new IllegalArgumentException("A new node cannot be resizable");
 
         this.freeParentCapacity = freeParentCapacity;
         this.parent = parent;
         this.violatesSpares = violatesSpares;
-        this.isSurplusNode = isSurplusNode;
-        this.isNewNode = isNewNode;
+        this.isSurplus = isSurplus;
+        this.isNew = isNew;
         this.isResizable = isResizeable;
     }
 
@@ -91,8 +91,8 @@ abstract class NodeCandidate implements Nodelike, Comparable<NodeCandidate> {
         if (other.state() == Node.State.active && this.state() != Node.State.active) return 1;
 
         // Choose active node that is not retired first (surplus is active but retired)
-        if (!this.isSurplusNode && other.isSurplusNode) return -1;
-        if (!other.isSurplusNode && this.isSurplusNode) return 1;
+        if (!this.isSurplus && other.isSurplus) return -1;
+        if (!other.isSurplus && this.isSurplus) return 1;
 
         // Choose reserved nodes from a previous allocation attempt (the exist in node repo)
         if (this.isInNodeRepoAndReserved() && ! other.isInNodeRepoAndReserved()) return -1;
@@ -159,7 +159,7 @@ abstract class NodeCandidate implements Nodelike, Comparable<NodeCandidate> {
 
     /** Returns a copy of this with node set to given value */
     NodeCandidate withNode(Node node) {
-        return new ConcreteNodeCandidate(node, freeParentCapacity, parent, violatesSpares, isSurplusNode, isNewNode, isResizable);
+        return new ConcreteNodeCandidate(node, freeParentCapacity, parent, violatesSpares, isSurplus, isNew, isResizable);
     }
 
     private boolean lessThanHalfTheHost(NodeCandidate node) {
@@ -179,63 +179,30 @@ abstract class NodeCandidate implements Nodelike, Comparable<NodeCandidate> {
     }
 
     private boolean isInNodeRepoAndReserved() {
-        if (isNewNode) return false;
+        if (isNew) return false;
         return state().equals(Node.State.reserved);
     }
 
-    public static NodeCandidate create(Node node, NodeResources freeParentCapacity, Optional<Node> parent, boolean violatesSpares, boolean isSurplusNode, boolean isNewNode, boolean isResizeable) {
-        return new ConcreteNodeCandidate(node, freeParentCapacity, parent, violatesSpares, isSurplusNode, isNewNode, isResizeable);
+    public static NodeCandidate create(Node node, NodeResources freeParentCapacity, Optional<Node> parent, boolean violatesSpares, boolean isSurplus, boolean isNew, boolean isResizeable) {
+        return new ConcreteNodeCandidate(node, freeParentCapacity, parent, violatesSpares, isSurplus, isNew, isResizeable);
     }
 
-    static class Builder {
-
-        public final Node node;
-        private NodeResources freeParentCapacity;
-        private Optional<Node> parent = Optional.empty();
-        private boolean violatesSpares;
-        private boolean isSurplusNode;
-        private boolean isNewNode;
-        private boolean isResizable;
-
-        Builder(Node node) {
-            this.node = node;
-            this.freeParentCapacity = node.flavor().resources();
-        }
-
-        /** The free capacity of the parent, before adding this node to it */
-        Builder freeParentCapacity(NodeResources freeParentCapacity) {
-            this.freeParentCapacity = freeParentCapacity;
-            return this;
-        }
-
-        Builder parent(Node parent) {
-            this.parent = Optional.of(parent);
-            return this;
-        }
-
-        Builder violatesSpares(boolean violatesSpares) {
-            this.violatesSpares = violatesSpares;
-            return this;
-        }
-
-        Builder surplusNode(boolean surplusNode) {
-            isSurplusNode = surplusNode;
-            return this;
-        }
-
-        Builder newNode(boolean newNode) {
-            isNewNode = newNode;
-            return this;
-        }
+    public static NodeCandidate createExclusiveChild(Node node, Node parent) {
+        return new ConcreteNodeCandidate(node, node.resources(), Optional.of(parent), false, false, true, false);
+    }
 
-        Builder resizable(boolean resizable) {
-            isResizable = resizable;
-            return this;
-        }
+    public static NodeCandidate createChild(Node node,
+                                            NodeResources freeParentCapacity,
+                                            Node parent,
+                                            boolean violatesSpares,
+                                            boolean isSurplus,
+                                            boolean isNew,
+                                            boolean isResizeable) {
+        return new ConcreteNodeCandidate(node, freeParentCapacity, Optional.of(parent), violatesSpares, isSurplus, isNew, isResizeable);
+    }
 
-        NodeCandidate build() {
-            return NodeCandidate.create(node, freeParentCapacity, parent, violatesSpares, isSurplusNode, isNewNode, isResizable);
-        }
+    public static NodeCandidate createStandalone(Node node, boolean isSurplus, boolean isNew) {
+        return new ConcreteNodeCandidate(node, node.resources(), Optional.empty(), false, isSurplus, isNew, false);
     }
 
     /** A candidate backed by a node */
@@ -267,7 +234,7 @@ abstract class NodeCandidate implements Nodelike, Comparable<NodeCandidate> {
 
         public NodeCandidate allocate(ApplicationId owner, ClusterMembership membership, NodeResources requestedResources, Instant at) {
             return new ConcreteNodeCandidate(node.allocate(owner, membership, requestedResources, at),
-                                             freeParentCapacity, parent, violatesSpares, isSurplusNode, isNewNode, isResizable);
+                                             freeParentCapacity, parent, violatesSpares, isSurplus, isNew, isResizable);
         }
 
         /** Called when the node described by this candidate must be created */
@@ -326,7 +293,7 @@ abstract class NodeCandidate implements Nodelike, Comparable<NodeCandidate> {
 
         public NodeCandidate allocate(ApplicationId owner, ClusterMembership membership, NodeResources requestedResources, Instant at) {
             return new VirtualNodeCandidate(node.allocate(owner, membership, requestedResources, at),
-                                            freeParentCapacity, parent, violatesSpares, isSurplusNode, isNewNode, isResizable);
+                                            freeParentCapacity, parent, violatesSpares, isSurplus, isNew, isResizable);
         }
 
         /** Called when the node described by this candidate must be created */
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodePrioritizer.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodePrioritizer.java
index 9bef0b79051..92f9fb6efd9 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodePrioritizer.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/NodePrioritizer.java
@@ -176,23 +176,24 @@ public class NodePrioritizer {
     }
 
     /** Create a candidate from given node */
-    private NodeCandidate candidateFrom(Node node, boolean isSurplusNode, boolean isNewNode) {
-        NodeCandidate.Builder builder = new NodeCandidate.Builder(node).surplusNode(isSurplusNode)
-                                                                       .newNode(isNewNode);
-
-        allNodes.parentOf(node).ifPresent(parent -> {
-            NodeResources parentCapacity = capacity.freeCapacityOf(parent, false);
-            builder.parent(parent).freeParentCapacity(parentCapacity);
-
-            if (!isNewNode)
-                builder.resizable(! allocateFully
-                                  && requestedNodes.canResize(node.resources(), parentCapacity, isTopologyChange, currentClusterSize));
-
-            if (spareHosts.contains(parent))
-                builder.violatesSpares(true);
-        });
-
-        return builder.build();
+    private NodeCandidate candidateFrom(Node node, boolean isSurplus, boolean isNew) {
+        Optional<Node> parent = allNodes.parentOf(node);
+        if (parent.isPresent()) {
+            return NodeCandidate.createChild(node,
+                                             capacity.freeCapacityOf(parent.get(), false),
+                                             parent.get(),
+                                             spareHosts.contains(parent.get()),
+                                             isSurplus,
+                                             isNew,
+                                             !isNew && !allocateFully
+                                             && requestedNodes.canResize(node.resources(),
+                                                                         capacity.freeCapacityOf(parent.get(), false),
+                                                                         isTopologyChange,
+                                                                         currentClusterSize));
+        }
+        else {
+            return NodeCandidate.createStandalone(node, isSurplus, isNew);
+        }
     }
 
     private boolean isReplacement(int nofNodesInCluster, int nodeFailedNodes) {