Cleanup

9 files changed, 58 insertions, 57 deletions

diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/NodeList.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/NodeList.java
index d647c53f935..acf62ae91b9 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/NodeList.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/NodeList.java
@@ -67,22 +67,24 @@ public class NodeList {
     }
 
     /** Returns the parent nodes of the given child nodes */
-    public NodeList parentNodes(Collection<Node> childNodes) {
-        return childNodes.stream()
-                .map(Node::parentHostname)
-                .filter(Optional::isPresent)
-                .map(Optional::get)
-                .map(hostName -> nodes.stream().filter(node -> node.hostname().equals(hostName)).findFirst())
-                .filter(Optional::isPresent)
-                .map(Optional::get)
-                .collect(collectingAndThen(Collectors.toList(), NodeList::new));
+    public NodeList parentsOf(Collection<Node> children) {
+        return children.stream()
+                       .map(Node::parentHostname)
+                       .filter(Optional::isPresent)
+                       .map(Optional::get)
+                       .map(hostName -> nodes.stream().filter(node -> node.hostname().equals(hostName)).findFirst())
+                       .filter(Optional::isPresent)
+                       .map(Optional::get)
+                       .collect(collectingAndThen(Collectors.toList(), NodeList::new));
     }
 
     /** Returns the child nodes of the given parent node */
-    public NodeList childNodes(Node parentNode) {
+    public NodeList childrenOf(Node parent) {
         return nodes.stream()
-                .filter(n -> n.parentHostname().map(hostName -> hostName.equals(parentNode.hostname())).orElse(false))
-                .collect(collectingAndThen(Collectors.toList(), NodeList::new));
+                    .filter(n -> n.parentHostname()
+                                  .map(hostName -> hostName.equals(parent.hostname()))
+                                  .orElse(false))
+                    .collect(collectingAndThen(Collectors.toList(), NodeList::new));
     }
 
     public int size() { return nodes.size(); }
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/NodeRepository.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/NodeRepository.java
index 830eb249ecb..764cd97a817 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/NodeRepository.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/NodeRepository.java
@@ -185,7 +185,7 @@ public class NodeRepository extends AbstractComponent {
                 // - proxy nodes
                 // - parent (Docker) hosts of already trusted nodes. This is needed in a transition period, while
                 //   we migrate away from IPv4-only nodes
-                trustedNodes.addAll(candidates.parentNodes(trustedNodes).asList()); // TODO: Remove when we no longer have IPv4-only nodes
+                trustedNodes.addAll(candidates.parentsOf(trustedNodes).asList()); // TODO: Remove when we no longer have IPv4-only nodes
                 trustedNodes.addAll(candidates.nodeType(NodeType.proxy).asList());
                 if (node.state() == Node.State.ready) {
                     // Tenant nodes in state ready, trust:
@@ -229,9 +229,9 @@ public class NodeRepository extends AbstractComponent {
     public List<NodeAcl> getNodeAcls(Node node, boolean children) {
         NodeList candidates = new NodeList(getNodes());
         if (children) {
-            return candidates.childNodes(node).asList().stream()
-                    .map(childNode -> getNodeAcl(childNode, candidates))
-                    .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
+            return candidates.childrenOf(node).asList().stream()
+                             .map(childNode -> getNodeAcl(childNode, candidates))
+                             .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
         } else {
             return Collections.singletonList(getNodeAcl(node, candidates));
         }
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/ReservationExpirer.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/ReservationExpirer.java
index 6ba42c6db48..ad3222a965a 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/ReservationExpirer.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/maintenance/ReservationExpirer.java
@@ -16,7 +16,6 @@ import java.util.List;
  * For this reason, all reserved nodes go through the dirty state before going back to ready.
  *
  * @author bratseth
- * @version $Id$
  */
 public class ReservationExpirer extends Expirer {
 
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/DockerHostCapacity.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/DockerHostCapacity.java
index 78ea258107b..6dd281ce4a0 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/DockerHostCapacity.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/DockerHostCapacity.java
@@ -126,7 +126,7 @@ public class DockerHostCapacity {
         if (!dockerHost.type().equals(NodeType.host)) return new ResourceCapacity();
 
         ResourceCapacity hostCapacity = new ResourceCapacity(dockerHost);
-        for (Node container : allNodes.childNodes(dockerHost).asList()) {
+        for (Node container : allNodes.childrenOf(dockerHost).asList()) {
             boolean isUsedCapacity = !(treatInactiveOrRetiredAsUnusedCapacity && isInactiveOrRetired(container));
             if (isUsedCapacity) {
                 hostCapacity.subtract(container);
@@ -151,7 +151,7 @@ public class DockerHostCapacity {
      */
     static Set<String> findFreeIps(Node dockerHost, List<Node> allNodes) {
         Set<String> freeIPAddresses = new HashSet<>(dockerHost.additionalIpAddresses());
-        for (Node child : new NodeList(allNodes).childNodes(dockerHost).asList()) {
+        for (Node child : new NodeList(allNodes).childrenOf(dockerHost).asList()) {
             freeIPAddresses.removeAll(child.ipAddresses());
         }
         return freeIPAddresses;
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 b157f3d154f..a809fd88d97 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
@@ -11,14 +11,13 @@ import com.yahoo.vespa.hosted.provision.NodeRepository;
 
 import java.time.Clock;
 import java.util.List;
-import java.util.function.BiConsumer;
 
 /**
  * Performs preparation of node activation changes for a single host group in an application.
  *
  * @author bratseth
  */
-class GroupPreparer {
+public class GroupPreparer {
 
     private final NodeRepository nodeRepository;
     private final Clock clock;
@@ -38,15 +37,14 @@ class GroupPreparer {
      *                           This method will remove from this list if it finds it needs additional nodes
      * @param highestIndex       the current highest node index among all active nodes in this cluster.
      *                           This method will increase this number when it allocates new nodes to the cluster.
-     * @param nofSpares          The number of spare docker hosts we want when dynamically allocate docker containers
-     * @param debugRecorder      Debug facility to step through the allocation process after the fact
+     * @param spareCount         The number of spare docker hosts we want when dynamically allocate docker containers
      * @return the list of nodes this cluster group will have allocated if activated
      */
     // Note: This operation may make persisted changes to the set of reserved and inactive nodes,
     // but it may not change the set of active nodes, as the active nodes must stay in sync with the
     // active config model which is changed on activate
     public List<Node> prepare(ApplicationId application, ClusterSpec cluster, NodeSpec requestedNodes,
-                              List<Node> surplusActiveNodes, MutableInteger highestIndex, int nofSpares, BiConsumer<List<Node>, String> debugRecorder) {
+                              List<Node> surplusActiveNodes, MutableInteger highestIndex, int spareCount) {
         try (Mutex lock = nodeRepository.lock(application)) {
 
             // Lock ready pool to ensure that ready nodes are not simultaneously grabbed by others
@@ -58,7 +56,7 @@ class GroupPreparer {
                                                                   cluster,
                                                                   requestedNodes,
                                                                   nodeRepository.getAvailableFlavors(),
-                                                                  nofSpares,
+                                                                  spareCount,
                                                                   nodeRepository.nameResolver());
 
                 prioritizer.addApplicationNodes();
@@ -74,9 +72,9 @@ class GroupPreparer {
                                                      outOfCapacityDetails(allocation));
 
                 // Carry out and return allocation
-                nodeRepository.reserve(allocation.acceptedInactiveAndReadyNodes());
-                nodeRepository.addDockerNodes(allocation.acceptedNewNodes());
-                surplusActiveNodes.removeAll(allocation.acceptedSurplusNodes());
+                nodeRepository.reserve(allocation.reservableNodes());
+                nodeRepository.addDockerNodes(allocation.newNodes());
+                surplusActiveNodes.removeAll(allocation.surplusNodes());
                 return allocation.finalNodes(surplusActiveNodes);
             }
         }
@@ -90,4 +88,4 @@ class GroupPreparer {
         else
             return ".";
     }
-}
\ No newline at end of file
+}
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 2a140945f43..21ed0d983f3 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
@@ -243,24 +243,25 @@ class NodeAllocation {
         return nodes.stream().map(n -> n.node).collect(Collectors.toList());
     }
 
-    List<Node> acceptedInactiveAndReadyNodes() {
+    List<Node> reservableNodes() {
         return nodes.stream().map(n -> n.node)
-                .filter(n -> n.state().equals(Node.State.inactive) || n.state().equals(Node.State.ready))
-                .collect(Collectors.toList());
+                    .filter(n -> n.state() == Node.State.inactive ||
+                                 n.state() == Node.State.ready)
+                    .collect(Collectors.toList());
     }
 
-    List<Node> acceptedSurplusNodes() {
+    List<Node> surplusNodes() {
         return nodes.stream()
-                .filter(n -> n.isSurplusNode)
-                .map(n -> n.node)
-                .collect(Collectors.toList());
+                    .filter(n -> n.isSurplusNode)
+                    .map(n -> n.node)
+                    .collect(Collectors.toList());
     }
 
-    List<Node> acceptedNewNodes() {
+    List<Node> newNodes() {
         return nodes.stream()
-                .filter(n -> n.isNewNode)
-                .map(n -> n.node)
-                .collect(Collectors.toList());
+                    .filter(n -> n.isNewNode)
+                    .map(n -> n.node)
+                    .collect(Collectors.toList());
     }
 
     private List<PrioritizableNode> byDecreasingIndex(Set<PrioritizableNode> nodes) {
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 63593a2644f..35ae6ecc690 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
@@ -43,7 +43,8 @@ public class NodePrioritizer {
     private final Set<Node> spareHosts;
     private final Map<Node, ResourceCapacity> headroomHosts;
 
-    NodePrioritizer(List<Node> allNodes, ApplicationId appId, ClusterSpec clusterSpec, NodeSpec nodeSpec, NodeFlavors nodeFlavors, int spares, NameResolver nameResolver) {
+    NodePrioritizer(List<Node> allNodes, ApplicationId appId, ClusterSpec clusterSpec, NodeSpec nodeSpec,
+                    NodeFlavors nodeFlavors, int spares, NameResolver nameResolver) {
         this.allNodes = Collections.unmodifiableList(allNodes);
         this.requestedNodes = nodeSpec;
         this.clusterSpec = clusterSpec;
@@ -181,8 +182,8 @@ public class NodePrioritizer {
             if (node.status().wantToRetire()) continue;
 
             boolean hostHasCapacityForWantedFlavor = capacity.hasCapacity(node, wantedResourceCapacity);
-            boolean conflictingCluster = list.childNodes(node).owner(appId).asList().stream()
-                    .anyMatch(child -> child.allocation().get().membership().cluster().id().equals(clusterSpec.id()));
+            boolean conflictingCluster = list.childrenOf(node).owner(appId).asList().stream()
+                                             .anyMatch(child -> child.allocation().get().membership().cluster().id().equals(clusterSpec.id()));
 
             if (!hostHasCapacityForWantedFlavor || conflictingCluster) continue;
 
@@ -265,11 +266,11 @@ public class NodePrioritizer {
 
     static boolean isPreferredNodeToBeReloacted(List<Node> nodes, Node node, Node parent) {
         NodeList list = new NodeList(nodes);
-        return list.childNodes(parent).asList().stream()
-                .sorted(NodePrioritizer::compareForRelocation)
-                .findFirst()
-                .filter(n -> n.equals(node))
-                .isPresent();
+        return list.childrenOf(parent).asList().stream()
+                   .sorted(NodePrioritizer::compareForRelocation)
+                   .findFirst()
+                   .filter(n -> n.equals(node))
+                   .isPresent();
     }
 
     private boolean isReplacement(long nofNodesInCluster, long nodeFailedNodes) {
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 8e16d540a96..f45c10f97f1 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
@@ -103,7 +103,7 @@ public class NodeRepositoryProvisioner implements Provisioner {
             effectiveGroups = 1; // type request with multiple groups is not supported
         }
 
-        return asSortedHosts(preparer.prepare(application, cluster, requestedNodes, effectiveGroups, debugRecorder));
+        return asSortedHosts(preparer.prepare(application, cluster, requestedNodes, effectiveGroups));
     }
 
     @Override
diff --git a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/Preparer.java b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/Preparer.java
index a0f9452ef9f..e7a6014816e 100644
--- a/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/Preparer.java
+++ b/node-repository/src/main/java/com/yahoo/vespa/hosted/provision/provisioning/Preparer.java
@@ -14,7 +14,6 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Optional;
-import java.util.function.BiConsumer;
 
 /**
  * Performs preparation of node activation changes for an application.
@@ -26,13 +25,13 @@ class Preparer {
     private final NodeRepository nodeRepository;
     private final Clock clock;
     private final GroupPreparer groupPreparer;
-    private final int nofSpares;
+    private final int spareCount;
 
-    public Preparer(NodeRepository nodeRepository, Clock clock, int nofSpares) {
+    public Preparer(NodeRepository nodeRepository, Clock clock, int spareCount) {
         this.nodeRepository = nodeRepository;
         this.clock = clock;
-        this.nofSpares = nofSpares;
-        groupPreparer = new GroupPreparer(nodeRepository, clock);
+        this.spareCount = spareCount;
+        this.groupPreparer = new GroupPreparer(nodeRepository, clock);
     }
 
     /**
@@ -43,15 +42,16 @@ class Preparer {
      // Note: This operation may make persisted changes to the set of reserved and inactive nodes,
      // but it may not change the set of active nodes, as the active nodes must stay in sync with the
      // active config model which is changed on activate
-    public List<Node> prepare(ApplicationId application, ClusterSpec cluster, NodeSpec requestedNodes, int wantedGroups, BiConsumer<List<Node>, String> debugRecorder) {
+    public List<Node> prepare(ApplicationId application, ClusterSpec cluster, NodeSpec requestedNodes, int wantedGroups) {
         List<Node> surplusNodes = findNodesInRemovableGroups(application, cluster, wantedGroups);
 
         MutableInteger highestIndex = new MutableInteger(findHighestIndex(application, cluster));
         List<Node> acceptedNodes = new ArrayList<>();
         for (int groupIndex = 0; groupIndex < wantedGroups; groupIndex++) {
             ClusterSpec clusterGroup = cluster.changeGroup(Optional.of(ClusterSpec.Group.from(groupIndex)));
-            List<Node> accepted = groupPreparer.prepare(application, clusterGroup, 
-                                                        requestedNodes.fraction(wantedGroups), surplusNodes, highestIndex, nofSpares, debugRecorder);
+            List<Node> accepted = groupPreparer.prepare(application, clusterGroup,
+                                                        requestedNodes.fraction(wantedGroups), surplusNodes,
+                                                        highestIndex, spareCount);
             replace(acceptedNodes, accepted);
         }
         moveToActiveGroup(surplusNodes, wantedGroups, cluster.group());