Add a new node role 'cluster_manager' as the alternative for 'master' role and deprecate 'master' role

benchmarks/src/main/java/org/opensearch/benchmark/routing/allocation/Allocators.java

@@ -111,7 +111,7 @@ public static DiscoveryNode newNode(String nodeId, Map<String, String> attribute
             nodeId,
             new TransportAddress(TransportAddress.META_ADDRESS, portGenerator.incrementAndGet()),
             attributes,
-            Sets.newHashSet(DiscoveryNodeRole.MASTER_ROLE, DiscoveryNodeRole.DATA_ROLE),
+            Sets.newHashSet(DiscoveryNodeRole.CLUSTER_MANAGER_ROLE, DiscoveryNodeRole.DATA_ROLE),
             Version.CURRENT
         );
     }

client/rest/src/main/java/org/opensearch/client/Node.java

@@ -210,21 +210,30 @@ public Roles(final Set<String> roles) {
         }
 
         /**
-         * Teturns whether or not the node <strong>could</strong> be elected master.
+         * Returns whether or not the node <strong>could</strong> be elected master.
+         * @deprecated As of 2.0, because promoting inclusive language, replaced by {@link #isClusterManagerEligible()}
          */
+        @Deprecated
         public boolean isMasterEligible() {
-            return roles.contains("master");
+            return roles.contains("master") || roles.contains("cluster_manager");
         }
 
         /**
-         * Teturns whether or not the node stores data.
+         * Returns whether or not the node <strong>could</strong> be elected cluster manager.
+         */
+        public boolean isClusterManagerEligible() {
+            return roles.contains("master") || roles.contains("cluster_manager");
+        }
+
+        /**
+         * Returns whether or not the node stores data.
          */
         public boolean isData() {
             return roles.contains("data");
         }
 
         /**
-         * Teturns whether or not the node runs ingest pipelines.
+         * Returns whether or not the node runs ingest pipelines.
          */
         public boolean isIngest() {
             return roles.contains("ingest");

rest-api-spec/src/main/resources/rest-api-spec/test/cluster.stats/10_basic.yml

@@ -91,3 +91,22 @@
       cluster.stats: {}
 
   - is_true: nodes.packaging_types
+
+---
+"get cluster stats nodes count with both master and cluster_manager":
+  - skip:
+      version: " - 1.4.99"
+      reason: "node role cluster_manager is added in 2.0.0"
+
+  - do:
+      cluster.stats: {}
+
+  - set:
+      nodes.count.cluster_manager: cluster_manager_count
+
+  - gte: { nodes.count.total: 1}
+  - match: { nodes.count.cluster_manager: $cluster_manager_count }
+  - match: { nodes.count.master: $cluster_manager_count }
+  - gte: { nodes.count.data: 1}
+  - gte: { nodes.count.ingest: 0}
+  - gte: { nodes.count.coordinating_only: 0}

rest-api-spec/src/main/resources/rest-api-spec/test/nodes.info/10_basic.yml

@@ -14,7 +14,7 @@ setup:
 ---
 "node_info role test":
   - skip:
-      version: " - 7.7.99"
+      version: " - 7.7.99 , 2.0.0 - "
       reason: "node roles were not sorted before 7.8.0"
 
   - do:
@@ -28,4 +28,23 @@ setup:
   - match: { nodes.$node_id.roles.1: "ingest" }
   - match: { nodes.$node_id.roles.2: "master" }
   - match: { nodes.$node_id.roles.3: "remote_cluster_client" }
+
+---
+"node_info role test with both master and cluster_manager":
+  - skip:
+      version: " - 1.4.99"
+      reason: "node role cluster_manager is added in 2.0.0"
+
+  - do:
+      nodes.info: {}
+  - set:
+      nodes._arbitrary_key_: node_id
+
+  - is_true: nodes.$node_id.roles
+  # the roles output is sorted
+  - match: { nodes.$node_id.roles.0: "cluster_manager" }
+  - match: { nodes.$node_id.roles.1: "data" }
+  - match: { nodes.$node_id.roles.2: "ingest" }
+  - match: { nodes.$node_id.roles.3: "master" }
+  - match: { nodes.$node_id.roles.4: "remote_cluster_client" }
 

server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/stats/ClusterStatsIT.java

@@ -86,7 +86,7 @@ public void testNodeCounts() {
         internalCluster().startNode();
         Map<String, Integer> expectedCounts = new HashMap<>();
         expectedCounts.put(DiscoveryNodeRole.DATA_ROLE.roleName(), 1);
-        expectedCounts.put(DiscoveryNodeRole.MASTER_ROLE.roleName(), 1);
+        expectedCounts.put(DiscoveryNodeRole.CLUSTER_MANAGER_ROLE.roleName(), 1);
         expectedCounts.put(DiscoveryNodeRole.INGEST_ROLE.roleName(), 1);
         expectedCounts.put(DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName(), 1);
         expectedCounts.put(ClusterStatsNodes.Counts.COORDINATING_ONLY, 0);
@@ -108,7 +108,7 @@ public void testNodeCounts() {
                 roles.add(DiscoveryNodeRole.INGEST_ROLE);
             }
             if (isMasterNode) {
-                roles.add(DiscoveryNodeRole.MASTER_ROLE);
+                roles.add(DiscoveryNodeRole.CLUSTER_MANAGER_ROLE);
             }
             if (isRemoteClusterClientNode) {
                 roles.add(DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE);
@@ -130,7 +130,7 @@ public void testNodeCounts() {
                 incrementCountForRole(DiscoveryNodeRole.INGEST_ROLE.roleName(), expectedCounts);
             }
             if (isMasterNode) {
-                incrementCountForRole(DiscoveryNodeRole.MASTER_ROLE.roleName(), expectedCounts);
+                incrementCountForRole(DiscoveryNodeRole.CLUSTER_MANAGER_ROLE.roleName(), expectedCounts);
             }
             if (isRemoteClusterClientNode) {
                 incrementCountForRole(DiscoveryNodeRole.REMOTE_CLUSTER_CLIENT_ROLE.roleName(), expectedCounts);

server/src/internalClusterTest/java/org/opensearch/env/NodeEnvironmentIT.java

@@ -88,14 +88,14 @@ public void testStartFailureOnDataForNonDataNode() throws Exception {
                 public Settings onNodeStopped(String nodeName) {
                     return NodeRoles.removeRoles(
                         Collections.unmodifiableSet(
-                            new HashSet<>(Arrays.asList(DiscoveryNodeRole.DATA_ROLE, DiscoveryNodeRole.MASTER_ROLE))
+                            new HashSet<>(Arrays.asList(DiscoveryNodeRole.DATA_ROLE, DiscoveryNodeRole.CLUSTER_MANAGER_ROLE))
                         )
                     );
                 }
             })
         );
         if (writeDanglingIndices) {
-            assertThat(ex.getMessage(), startsWith("node does not have the data and master roles but has index metadata"));
+            assertThat(ex.getMessage(), startsWith("node does not have the data and cluster_manager roles but has index metadata"));
         } else {
             assertThat(ex.getMessage(), startsWith("node does not have the data role but has shard data"));
         }

server/src/internalClusterTest/java/org/opensearch/env/NodeRepurposeCommandIT.java

@@ -75,7 +75,7 @@ public void testRepurpose() throws Exception {
         final Settings dataNodeDataPathSettings = internalCluster().dataPathSettings(dataNode);
 
         final Settings noMasterNoDataSettings = NodeRoles.removeRoles(
-            Collections.unmodifiableSet(new HashSet<>(Arrays.asList(DiscoveryNodeRole.DATA_ROLE, DiscoveryNodeRole.MASTER_ROLE)))
+            Collections.unmodifiableSet(new HashSet<>(Arrays.asList(DiscoveryNodeRole.DATA_ROLE, DiscoveryNodeRole.CLUSTER_MANAGER_ROLE)))
         );
 
         final Settings noMasterNoDataSettingsForMasterNode = Settings.builder()

server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java

@@ -94,7 +94,7 @@ public static boolean hasRole(final Settings settings, final DiscoveryNodeRole r
     }
 
     public static boolean isMasterNode(Settings settings) {
-        return hasRole(settings, DiscoveryNodeRole.MASTER_ROLE);
+        return hasRole(settings, DiscoveryNodeRole.MASTER_ROLE) || hasRole(settings, DiscoveryNodeRole.CLUSTER_MANAGER_ROLE);
     }
 
     /**
@@ -343,7 +343,7 @@ public DiscoveryNode(StreamInput in) throws IOException {
                 final LegacyRole legacyRole = in.readEnum(LegacyRole.class);
                 switch (legacyRole) {
                     case MASTER:
-                        roles.add(DiscoveryNodeRole.MASTER_ROLE);
+                        roles.add(DiscoveryNodeRole.CLUSTER_MANAGER_ROLE);
                         break;
                     case DATA:
                         roles.add(DiscoveryNodeRole.DATA_ROLE);
@@ -390,7 +390,7 @@ public void writeTo(StreamOutput out) throws IOException {
                 .collect(Collectors.toList());
             out.writeVInt(rolesToWrite.size());
             for (final DiscoveryNodeRole role : rolesToWrite) {
-                if (role == DiscoveryNodeRole.MASTER_ROLE) {
+                if (role == DiscoveryNodeRole.MASTER_ROLE || role == DiscoveryNodeRole.CLUSTER_MANAGER_ROLE) {
                     out.writeEnum(LegacyRole.MASTER);
                 } else if (role == DiscoveryNodeRole.DATA_ROLE) {
                     out.writeEnum(LegacyRole.DATA);
@@ -456,7 +456,7 @@ public boolean isDataNode() {
      * Can this node become master or not.
      */
     public boolean isMasterNode() {
-        return roles.contains(DiscoveryNodeRole.MASTER_ROLE);
+        return roles.contains(DiscoveryNodeRole.MASTER_ROLE) || roles.contains(DiscoveryNodeRole.CLUSTER_MANAGER_ROLE);
     }
 
     /**
@@ -577,8 +577,10 @@ public static Set<DiscoveryNodeRole> getPossibleRoles() {
 
     public static void setAdditionalRoles(final Set<DiscoveryNodeRole> additionalRoles) {
         assert additionalRoles.stream().allMatch(r -> r.legacySetting() == null || r.legacySetting().isDeprecated()) : additionalRoles;
-        final Map<String, DiscoveryNodeRole> roleNameToPossibleRoles = rolesToMap(
-            Stream.concat(DiscoveryNodeRole.BUILT_IN_ROLES.stream(), additionalRoles.stream())
+        // TODO: Remove 'new HashMap<>()' and only keep 'rolesToMap(...)' after removing DiscoveryNodeRole.MASTER_ROLE
+        // It's used to allow CLUSTER_MANAGER_ROLE that introduced in 2.0, having the same abbreviation name with MASTER_ROLE.
+        final Map<String, DiscoveryNodeRole> roleNameToPossibleRoles = new HashMap<>(
+            rolesToMap(Stream.concat(DiscoveryNodeRole.BUILT_IN_ROLES.stream(), additionalRoles.stream()))
         );
         // collect the abbreviation names into a map to ensure that there are not any duplicate abbreviations
         final Map<String, DiscoveryNodeRole> roleNameAbbreviationToPossibleRoles = Collections.unmodifiableMap(
@@ -591,15 +593,19 @@ public static void setAdditionalRoles(final Set<DiscoveryNodeRole> additionalRol
             + "], roles by name abbreviation ["
             + roleNameAbbreviationToPossibleRoles
             + "]";
-        roleMap = roleNameToPossibleRoles;
+        // TODO: Remove this line after removing DiscoveryNodeRole.MASTER_ROLE
+        roleNameToPossibleRoles.put(DiscoveryNodeRole.MASTER_ROLE.roleName(), DiscoveryNodeRole.MASTER_ROLE);
+        // TODO: Remove 'Collections.unmodifiableMap()', and only keep 'roleNameToPossibleRoles', after removing MASTER_ROLE
+        // because the map roleNameToPossibleRoles is supposed to be immutable.
+        roleMap = Collections.unmodifiableMap(roleNameToPossibleRoles);
     }
 
     public static Set<String> getPossibleRoleNames() {
         return roleMap.keySet();
     }
 
     /**
-     * Enum that holds all the possible roles that that a node can fulfill in a cluster.
+     * Enum that holds all the possible roles that a node can fulfill in a cluster.
      * Each role has its name and a corresponding abbreviation used by cat apis.
      */
     private enum LegacyRole {

server/src/main/java/org/opensearch/cluster/node/DiscoveryNodeRole.java

@@ -193,7 +193,9 @@ public Setting<Boolean> legacySetting() {
 
     /**
      * Represents the role for a master-eligible node.
+     * @deprecated As of 2.0, because promoting inclusive language, replaced by {@link #CLUSTER_MANAGER_ROLE}
      */
+    @Deprecated
     public static final DiscoveryNodeRole MASTER_ROLE = new DiscoveryNodeRole("master", "m") {
 
         @Override
@@ -204,6 +206,19 @@ public Setting<Boolean> legacySetting() {
 
     };
 
+    /**
+     * Represents the role for a cluster_manager-eligible node.
+     */
+    public static final DiscoveryNodeRole CLUSTER_MANAGER_ROLE = new DiscoveryNodeRole("cluster_manager", "m") {
+
+        @Override
+        public Setting<Boolean> legacySetting() {
+            // copy the setting here so we can mark it private in org.opensearch.node.Node
+            return Setting.boolSetting("node.master", true, Property.Deprecated, Property.NodeScope);
+        }
+
+    };
+
     public static final DiscoveryNodeRole REMOTE_CLUSTER_CLIENT_ROLE = new DiscoveryNodeRole("remote_cluster_client", "r") {
 
         @Override
@@ -223,7 +238,7 @@ public Setting<Boolean> legacySetting() {
      * The built-in node roles.
      */
     public static SortedSet<DiscoveryNodeRole> BUILT_IN_ROLES = Collections.unmodifiableSortedSet(
-        new TreeSet<>(Arrays.asList(DATA_ROLE, INGEST_ROLE, MASTER_ROLE, REMOTE_CLUSTER_CLIENT_ROLE))
+        new TreeSet<>(Arrays.asList(DATA_ROLE, INGEST_ROLE, CLUSTER_MANAGER_ROLE, REMOTE_CLUSTER_CLIENT_ROLE))
     );
 
     /**

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

@@ -370,7 +370,7 @@ public DiscoveryNode resolveNode(String node) {
      * Works by tracking the current set of nodes and applying each node specification in sequence. The set starts out empty and each node
      * specification may either add or remove nodes. For instance:
      *
-     * - _local, _master and _all respectively add to the subset the local node, the currently-elected master, and all the nodes
+     * - _local, _cluster_manager (_master) and _all respectively add to the subset the local node, the currently-elected cluster_manager, and all the nodes
      * - node IDs, names, hostnames and IP addresses all add to the subset any nodes which match
      * - a wildcard-based pattern of the form "attr*:value*" adds to the subset all nodes with a matching attribute with a matching value
      * - role:true adds to the subset all nodes with a matching role
@@ -393,7 +393,7 @@ public String[] resolveNodes(String... nodes) {
                     if (localNodeId != null) {
                         resolvedNodesIds.add(localNodeId);
                     }
-                } else if (nodeId.equals("_master")) {
+                } else if (nodeId.equals("_master") || nodeId.equals("_cluster_manager")) {
                     String masterNodeId = getMasterNodeId();
                     if (masterNodeId != null) {
                         resolvedNodesIds.add(masterNodeId);
@@ -419,46 +419,47 @@ public String[] resolveNodes(String... nodes) {
                             } else {
                                 resolvedNodesIds.removeAll(dataNodes.keys());
                             }
-                        } else if (DiscoveryNodeRole.MASTER_ROLE.roleName().equals(matchAttrName)) {
-                            if (Booleans.parseBoolean(matchAttrValue, true)) {
-                                resolvedNodesIds.addAll(masterNodes.keys());
-                            } else {
-                                resolvedNodesIds.removeAll(masterNodes.keys());
-                            }
-                        } else if (DiscoveryNodeRole.INGEST_ROLE.roleName().equals(matchAttrName)) {
-                            if (Booleans.parseBoolean(matchAttrValue, true)) {
-                                resolvedNodesIds.addAll(ingestNodes.keys());
-                            } else {
-                                resolvedNodesIds.removeAll(ingestNodes.keys());
-                            }
-                        } else if (DiscoveryNode.COORDINATING_ONLY.equals(matchAttrName)) {
-                            if (Booleans.parseBoolean(matchAttrValue, true)) {
-                                resolvedNodesIds.addAll(getCoordinatingOnlyNodes().keys());
+                        } else if (DiscoveryNodeRole.MASTER_ROLE.roleName().equals(matchAttrName)
+                            || DiscoveryNodeRole.CLUSTER_MANAGER_ROLE.roleName().equals(matchAttrName)) {
+                                if (Booleans.parseBoolean(matchAttrValue, true)) {
+                                    resolvedNodesIds.addAll(masterNodes.keys());
+                                } else {
+                                    resolvedNodesIds.removeAll(masterNodes.keys());
+                                }
+                            } else if (DiscoveryNodeRole.INGEST_ROLE.roleName().equals(matchAttrName)) {
+                                if (Booleans.parseBoolean(matchAttrValue, true)) {
+                                    resolvedNodesIds.addAll(ingestNodes.keys());
+                                } else {
+                                    resolvedNodesIds.removeAll(ingestNodes.keys());
+                                }
+                            } else if (DiscoveryNode.COORDINATING_ONLY.equals(matchAttrName)) {
+                                if (Booleans.parseBoolean(matchAttrValue, true)) {
+                                    resolvedNodesIds.addAll(getCoordinatingOnlyNodes().keys());
+                                } else {
+                                    resolvedNodesIds.removeAll(getCoordinatingOnlyNodes().keys());
+                                }
                             } else {
-                                resolvedNodesIds.removeAll(getCoordinatingOnlyNodes().keys());
-                            }
-                        } else {
-                            for (DiscoveryNode node : this) {
-                                for (DiscoveryNodeRole role : Sets.difference(node.getRoles(), DiscoveryNodeRole.BUILT_IN_ROLES)) {
-                                    if (role.roleName().equals(matchAttrName)) {
-                                        if (Booleans.parseBoolean(matchAttrValue, true)) {
-                                            resolvedNodesIds.add(node.getId());
-                                        } else {
-                                            resolvedNodesIds.remove(node.getId());
+                                for (DiscoveryNode node : this) {
+                                    for (DiscoveryNodeRole role : Sets.difference(node.getRoles(), DiscoveryNodeRole.BUILT_IN_ROLES)) {
+                                        if (role.roleName().equals(matchAttrName)) {
+                                            if (Booleans.parseBoolean(matchAttrValue, true)) {
+                                                resolvedNodesIds.add(node.getId());
+                                            } else {
+                                                resolvedNodesIds.remove(node.getId());
+                                            }
                                         }
                                     }
                                 }
-                            }
-                            for (DiscoveryNode node : this) {
-                                for (Map.Entry<String, String> entry : node.getAttributes().entrySet()) {
-                                    String attrName = entry.getKey();
-                                    String attrValue = entry.getValue();
-                                    if (Regex.simpleMatch(matchAttrName, attrName) && Regex.simpleMatch(matchAttrValue, attrValue)) {
-                                        resolvedNodesIds.add(node.getId());
+                                for (DiscoveryNode node : this) {
+                                    for (Map.Entry<String, String> entry : node.getAttributes().entrySet()) {
+                                        String attrName = entry.getKey();
+                                        String attrValue = entry.getValue();
+                                        if (Regex.simpleMatch(matchAttrName, attrName) && Regex.simpleMatch(matchAttrValue, attrValue)) {
+                                            resolvedNodesIds.add(node.getId());
+                                        }
                                     }
                                 }
                             }
-                        }
                     }
                 }
             }

server/src/main/java/org/opensearch/env/NodeEnvironment.java

@@ -1138,7 +1138,7 @@ private void ensureNoIndexMetadata(final NodePath[] nodePaths) throws IOExceptio
                 Locale.ROOT,
                 "node does not have the %s and %s roles but has index metadata: %s. Use 'opensearch-node repurpose' tool to clean up",
                 DiscoveryNodeRole.DATA_ROLE.roleName(),
-                DiscoveryNodeRole.MASTER_ROLE.roleName(),
+                DiscoveryNodeRole.CLUSTER_MANAGER_ROLE.roleName(),
                 indexMetadataPaths
             );
             throw new IllegalStateException(message);

server/src/main/java/org/opensearch/node/NodeRoleSettings.java

@@ -49,6 +49,8 @@ public class NodeRoleSettings {
         settings -> DiscoveryNode.getPossibleRoles()
             .stream()
             .filter(role -> role.isEnabledByDefault(settings))
+            // TODO: Remove this line after removing DiscoveryNodeRole.MASTER_ROLE. As of 2.0, MASTER_ROLE isn't needed to be assigned.
+            .filter(role -> !role.equals(DiscoveryNodeRole.MASTER_ROLE))
             .map(DiscoveryNodeRole::roleName)
             .collect(Collectors.toList()),
         roles -> {},