Adds nodeExistsWithName method

Author: joshua-adams-1

server/src/internalClusterTest/java/org/elasticsearch/cluster/coordination/NodeJoiningIT.java

@@ -10,16 +10,12 @@
 package org.elasticsearch.cluster.coordination;
 
 import org.elasticsearch.cluster.ClusterState;
-import org.elasticsearch.cluster.node.DiscoveryNode;
 import org.elasticsearch.common.util.CollectionUtils;
 import org.elasticsearch.plugins.Plugin;
 import org.elasticsearch.test.ESIntegTestCase;
 import org.elasticsearch.test.transport.MockTransportService;
 
 import java.util.Collection;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
 
 @ESIntegTestCase.ClusterScope(
     scope = ESIntegTestCase.Scope.TEST,
@@ -52,13 +48,9 @@ public void testNodeJoinsCluster() {
         assertEquals(2, state.nodes().getDataNodes().size());
         assertEquals(1, state.nodes().getMasterNodes().size());
 
-        assertEquals(masterNodeName, state.nodes().getMasterNode().getName());
-        Set<String> allDataNodeNames = state.nodes().getDataNodes().values()
-            .stream()
-            .map(DiscoveryNode::getName)
-            .collect(Collectors.toSet());
-        assertTrue(allDataNodeNames.contains(dataNodeName));
-        assertTrue(allDataNodeNames.contains(newNodeName));
+        assertEquals(masterNodeName, internalCluster().getMasterName());
+        assertTrue(state.nodes().nodeExistsWithName(dataNodeName));
+        assertTrue(state.nodes().nodeExistsWithName(newNodeName));
     }
 
     public void testNodeFailsToJoinClusterWhenMasterNodeCannotPublishState() {
@@ -83,13 +75,9 @@ public void testNodeFailsToJoinClusterWhenMasterNodeCannotPublishState() {
         assertEquals(1, state.nodes().getMasterNodes().size());
 
         // Assert the only nodes in the cluster are the original ones
-        assertEquals(masterNodeName, state.nodes().getMasterNode().getName());
-        List<String> allDataNodeNames = state.nodes().getDataNodes().values()
-            .stream()
-            .map(DiscoveryNode::getName)
-            .toList();
-        assertTrue(allDataNodeNames.contains(dataNodeName));
-        assertFalse(allDataNodeNames.contains(newNodeName));
+        assertEquals(masterNodeName, internalCluster().getMasterName());
+        assertTrue(state.nodes().nodeExistsWithName(dataNodeName));
+        assertFalse(state.nodes().nodeExistsWithName(newNodeName));
 
         masterNodeTransportService.clearAllRules();
     }
@@ -117,13 +105,9 @@ public void testNodeFailsToJoinClusterWhenDataNodeCannotReceiveState() {
         assertEquals(1, state.nodes().getMasterNodes().size());
 
         // Assert the only nodes in the cluster are the original ones
-        assertEquals(masterNodeName, state.nodes().getMasterNode().getName());
-        List<String> allDataNodeNames = state.nodes().getDataNodes().values()
-            .stream()
-            .map(DiscoveryNode::getName)
-            .toList();
-        assertTrue(allDataNodeNames.contains(dataNodeName));
-        assertFalse(allDataNodeNames.contains(newNodeName));
+        assertEquals(masterNodeName, internalCluster().getMasterName());
+        assertTrue(state.nodes().nodeExistsWithName(dataNodeName));
+        assertFalse(state.nodes().nodeExistsWithName(newNodeName));
 
         dataNodeTransportService.clearAllRules();
     }

server/src/main/java/org/elasticsearch/cluster/node/DiscoveryNodes.java

@@ -267,6 +267,22 @@ public boolean nodeExists(DiscoveryNode node) {
         return existing != null && existing.equals(node);
     }
 
+    /**
+     * Determine if a given node exists
+     *
+     * @param name of the node which existence should be verified
+     * @return <code>true</code> if the node exists. Otherwise <code>false</code>
+     */
+    public boolean nodeExistsWithName(String name) {
+        for (DiscoveryNode node : nodes.values()) {
+            if (node.getName().equals(name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+
     /**
      * Determine if the given node exists and has the right roles. Supported roles vary by version, and our local cluster state might
      * have come via an older master, so the roles may differ even if the node is otherwise identical.

server/src/test/java/org/elasticsearch/cluster/node/DiscoveryNodesTests.java

@@ -18,6 +18,7 @@
 import org.elasticsearch.index.IndexVersions;
 import org.elasticsearch.test.ESTestCase;
 import org.elasticsearch.test.VersionUtils;
+import org.junit.Before;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -523,4 +524,40 @@ public void accept(Consumer<DiscoveryNodes.Builder> update, long expectedGenerat
         testHarness.accept(builder -> builder.add(node5).add(node6).add(node7), 1L);
         testHarness.accept(builder -> builder.remove(node5).remove(node6).remove(node7), 2L);
     }
+
+    private final DiscoveryNode node1 = DiscoveryNodeUtils.create("node-1", "NodeOne");
+    private final DiscoveryNode node2 = DiscoveryNodeUtils.create("node-2", "NodeTwo");
+    private final DiscoveryNodes discoveryNodes = DiscoveryNodes.builder()
+        .add(node1)
+        .add(node2)
+        .build();
+
+    public void testNodeExistsById() {
+        assertTrue(discoveryNodes.nodeExists("NodeOne"));
+        assertTrue(discoveryNodes.nodeExists("NodeTwo"));
+        assertFalse(discoveryNodes.nodeExists("NodeThree"));
+    }
+
+    public void testNodeExistsByNode() {
+        // Exact node object
+        assertTrue(discoveryNodes.nodeExists(node1));
+
+        // A different node but with same id and name
+        DiscoveryNode node1Copy = DiscoveryNodeUtils.create("node-1", "NodeOne");
+        assertFalse(discoveryNodes.nodeExists(node1Copy));
+
+        // Node with same id but different name
+        DiscoveryNode node1Different = DiscoveryNodeUtils.create("node-1", "DifferentName");
+        assertFalse(discoveryNodes.nodeExists(node1Different));
+
+        // Node with id not in map
+        DiscoveryNode node3 = DiscoveryNodeUtils.create("node-3", "NodeThree");
+        assertFalse(discoveryNodes.nodeExists(node3));
+    }
+
+    public void testNodeExistsWithName() {
+        assertTrue(discoveryNodes.nodeExistsWithName("node-1"));
+        assertTrue(discoveryNodes.nodeExistsWithName("node-2"));
+        assertFalse(discoveryNodes.nodeExistsWithName("node-3"));
+    }
 }