Replace 'master' terminology with 'cluster manager' in 'qa' directory (#3330) (#3332)

opensearch-trigger-bot[bot] · Tianli Feng · web-flow · commit 85091638b521 · 2022-05-16T11:44:21.000-04:00
* Replace 'master' terminology with 'cluster manager' in 'qa' directory Signed-off-by: Tianli Feng <ftianli@amazon.com> * Replace master_node with cluster_manager_node in cluster.state API test Signed-off-by: Tianli Feng <ftianli@amazon.com> (cherry picked from commit e2ad4ff) Co-authored-by: Tianli Feng <ftianli@amazon.com>
diff --git a/qa/full-cluster-restart/src/test/java/org/opensearch/upgrades/FullClusterRestartIT.java b/qa/full-cluster-restart/src/test/java/org/opensearch/upgrades/FullClusterRestartIT.java
@@ -659,7 +659,7 @@ public void testEmptyShard() throws IOException {
                 .put(IndexMetadata.INDEX_NUMBER_OF_SHARDS_SETTING.getKey(), 1)
                 .put(IndexMetadata.INDEX_NUMBER_OF_REPLICAS_SETTING.getKey(), 1)
                 // if the node with the replica is the first to be restarted, while a replica is still recovering
-                // then delayed allocation will kick in. When the node comes back, the master will search for a copy
+                // then delayed allocation will kick in. When the node comes back, the cluster-manager will search for a copy
                 // but the recovering copy will be seen as invalid and the cluster health won't return to GREEN
                 // before timing out
                 .put(INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING.getKey(), "100ms")
diff --git a/qa/mixed-cluster/src/test/java/org/opensearch/backwards/IndexingIT.java b/qa/mixed-cluster/src/test/java/org/opensearch/backwards/IndexingIT.java
@@ -429,23 +429,23 @@ private Nodes buildNodeAndVersions() throws IOException {
                 HttpHost.create(objectPath.evaluate("nodes." + id + ".http.publish_address"))));
         }
         response = client().performRequest(new Request("GET", "_cluster/state"));
-        nodes.setMasterNodeId(ObjectPath.createFromResponse(response).evaluate("master_node"));
+        nodes.setClusterManagerNodeId(ObjectPath.createFromResponse(response).evaluate("master_node"));
         return nodes;
     }
 
     final class Nodes extends HashMap<String, Node> {
 
-        private String masterNodeId = null;
+        private String clusterManagerNodeId = null;
 
-        public Node getMaster() {
-            return get(masterNodeId);
+        public Node getClusterManager() {
+            return get(clusterManagerNodeId);
         }
 
-        public void setMasterNodeId(String id) {
+        public void setClusterManagerNodeId(String id) {
             if (get(id) == null) {
                 throw new IllegalArgumentException("node with id [" + id + "] not found. got:" + toString());
             }
-            masterNodeId = id;
+            clusterManagerNodeId = id;
         }
 
         public void add(Node node) {
@@ -480,7 +480,7 @@ public Node getSafe(String id) {
         @Override
         public String toString() {
             return "Nodes{" +
-                "masterNodeId='" + masterNodeId + "'\n" +
+                "masterNodeId='" + clusterManagerNodeId + "'\n" +
                 values().stream().map(Node::toString).collect(Collectors.joining("\n")) +
                 '}';
         }
diff --git a/qa/multi-cluster-search/build.gradle b/qa/multi-cluster-search/build.gradle
@@ -45,7 +45,7 @@ task 'remote-cluster'(type: RestIntegTestTask) {
 
 testClusters.'remote-cluster' {
   numberOfNodes = 2
-  setting 'node.roles', '[data,ingest,master]'
+  setting 'node.roles', '[data,ingest,cluster_manager]'
 }
 
 task mixedClusterTest(type: RestIntegTestTask) {
diff --git a/qa/rolling-upgrade/src/test/java/org/opensearch/upgrades/RecoveryIT.java b/qa/rolling-upgrade/src/test/java/org/opensearch/upgrades/RecoveryIT.java
@@ -90,7 +90,7 @@ public void testHistoryUUIDIsGenerated() throws Exception {
                 .put(IndexMetadata.INDEX_NUMBER_OF_SHARDS_SETTING.getKey(), 1)
                 .put(IndexMetadata.INDEX_NUMBER_OF_REPLICAS_SETTING.getKey(), 1)
                 // if the node with the replica is the first to be restarted, while a replica is still recovering
-                // then delayed allocation will kick in. When the node comes back, the master will search for a copy
+                // then delayed allocation will kick in. When the node comes back, the cluster-manager will search for a copy
                 // but the recovering copy will be seen as invalid and the cluster health won't return to GREEN
                 // before timing out
                 .put(INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING.getKey(), "100ms");
@@ -158,7 +158,7 @@ public void testRecoveryWithConcurrentIndexing() throws Exception {
                     .put(IndexMetadata.INDEX_NUMBER_OF_SHARDS_SETTING.getKey(), 1)
                     .put(IndexMetadata.INDEX_NUMBER_OF_REPLICAS_SETTING.getKey(), 2)
                     // if the node with the replica is the first to be restarted, while a replica is still recovering
-                    // then delayed allocation will kick in. When the node comes back, the master will search for a copy
+                    // then delayed allocation will kick in. When the node comes back, the cluster-manager will search for a copy
                     // but the recovering copy will be seen as invalid and the cluster health won't return to GREEN
                     // before timing out
                     .put(INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING.getKey(), "100ms")
@@ -256,7 +256,7 @@ public void testRelocationWithConcurrentIndexing() throws Exception {
                     .put(IndexMetadata.INDEX_NUMBER_OF_SHARDS_SETTING.getKey(), 1)
                     .put(IndexMetadata.INDEX_NUMBER_OF_REPLICAS_SETTING.getKey(), 2)
                     // if the node with the replica is the first to be restarted, while a replica is still recovering
-                    // then delayed allocation will kick in. When the node comes back, the master will search for a copy
+                    // then delayed allocation will kick in. When the node comes back, the cluster-manager will search for a copy
                     // but the recovering copy will be seen as invalid and the cluster health won't return to GREEN
                     // before timing out
                     .put(INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING.getKey(), "100ms")
@@ -266,7 +266,7 @@ public void testRelocationWithConcurrentIndexing() throws Exception {
                 indexDocs(index, 0, 10);
                 ensureGreen(index);
                 // make sure that no shards are allocated, so we can make sure the primary stays on the old node (when one
-                // node stops, we lose the master too, so a replica will not be promoted)
+                // node stops, we lose the cluster-manager too, so a replica will not be promoted)
                 updateIndexSettings(index, Settings.builder().put(INDEX_ROUTING_ALLOCATION_ENABLE_SETTING.getKey(), "none"));
                 break;
             case MIXED:
@@ -330,7 +330,7 @@ public void testRecovery() throws Exception {
                 .put(IndexMetadata.INDEX_NUMBER_OF_SHARDS_SETTING.getKey(), 1)
                 .put(IndexMetadata.INDEX_NUMBER_OF_REPLICAS_SETTING.getKey(), 1)
                 // if the node with the replica is the first to be restarted, while a replica is still recovering
-                // then delayed allocation will kick in. When the node comes back, the master will search for a copy
+                // then delayed allocation will kick in. When the node comes back, the cluster-manager will search for a copy
                 // but the recovering copy will be seen as invalid and the cluster health won't return to GREEN
                 // before timing out
                 .put(INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING.getKey(), "100ms")
@@ -448,7 +448,7 @@ public void testRecoveryClosedIndex() throws Exception {
                 .put(IndexMetadata.INDEX_NUMBER_OF_SHARDS_SETTING.getKey(), 1)
                 .put(IndexMetadata.INDEX_NUMBER_OF_REPLICAS_SETTING.getKey(), 1)
                 // if the node with the replica is the first to be restarted, while a replica is still recovering
-                // then delayed allocation will kick in. When the node comes back, the master will search for a copy
+                // then delayed allocation will kick in. When the node comes back, the cluster-manager will search for a copy
                 // but the recovering copy will be seen as invalid and the cluster health won't return to GREEN
                 // before timing out
                 .put(INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING.getKey(), "100ms")
diff --git a/qa/smoke-test-ingest-disabled/build.gradle b/qa/smoke-test-ingest-disabled/build.gradle
@@ -38,5 +38,5 @@ dependencies {
 }
 
 testClusters.integTest {
-  setting 'node.roles', '[data,master,remote_cluster_client]'
+  setting 'node.roles', '[data,cluster_manager,remote_cluster_client]'
 }
diff --git a/qa/smoke-test-plugins/src/test/resources/rest-api-spec/test/smoke_test_plugins/10_basic.yml b/qa/smoke-test-plugins/src/test/resources/rest-api-spec/test/smoke_test_plugins/10_basic.yml
@@ -4,10 +4,10 @@
     - do:
         cluster.state: {}
 
-    # Get master node id
-    - set: { master_node: master }
+    # Get cluster-manager node id
+    - set: { cluster_manager_node: cluster_manager }
 
     - do:
         nodes.info: {}
 
-    - length:  { nodes.$master.plugins: ${expected.plugins.count}  }
+    - length:  { nodes.$cluster_manager.plugins: ${expected.plugins.count}  }

Original file line number	Diff line number	Diff line change
`@@ -429,23 +429,23 @@ private Nodes buildNodeAndVersions() throws IOException {`
`429`	`429`	`HttpHost.create(objectPath.evaluate("nodes." + id + ".http.publish_address"))));`
`430`	`430`	`}`
`431`	`431`	`response = client().performRequest(new Request("GET", "_cluster/state"));`
`432`		`- nodes.setMasterNodeId(ObjectPath.createFromResponse(response).evaluate("master_node"));`
	`432`	`+ nodes.setClusterManagerNodeId(ObjectPath.createFromResponse(response).evaluate("master_node"));`
`433`	`433`	`return nodes;`
`434`	`434`	`}`
`435`	`435`
`436`	`436`	`final class Nodes extends HashMap<String, Node> {`
`437`	`437`
`438`		`- private String masterNodeId = null;`
	`438`	`+ private String clusterManagerNodeId = null;`
`439`	`439`
`440`		`- public Node getMaster() {`
`441`		`- return get(masterNodeId);`
	`440`	`+ public Node getClusterManager() {`
	`441`	`+ return get(clusterManagerNodeId);`
`442`	`442`	`}`
`443`	`443`
`444`		`- public void setMasterNodeId(String id) {`
	`444`	`+ public void setClusterManagerNodeId(String id) {`
`445`	`445`	`if (get(id) == null) {`
`446`	`446`	`throw new IllegalArgumentException("node with id [" + id + "] not found. got:" + toString());`
`447`	`447`	`}`
`448`		`- masterNodeId = id;`
	`448`	`+ clusterManagerNodeId = id;`
`449`	`449`	`}`
`450`	`450`
`451`	`451`	`public void add(Node node) {`
`@@ -480,7 +480,7 @@ public Node getSafe(String id) {`
`480`	`480`	`@Override`
`481`	`481`	`public String toString() {`
`482`	`482`	`return "Nodes{" +`
`483`		`- "masterNodeId='" + masterNodeId + "'\n" +`
	`483`	`+ "masterNodeId='" + clusterManagerNodeId + "'\n" +`
`484`	`484`	`values().stream().map(Node::toString).collect(Collectors.joining("\n")) +`
`485`	`485`	`'}';`
`486`	`486`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ task 'remote-cluster'(type: RestIntegTestTask) {`
`45`	`45`
`46`	`46`	`testClusters.'remote-cluster' {`
`47`	`47`	`numberOfNodes = 2`
`48`		`- setting 'node.roles', '[data,ingest,master]'`
	`48`	`+ setting 'node.roles', '[data,ingest,cluster_manager]'`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`task mixedClusterTest(type: RestIntegTestTask) {`
Original file line number	Diff line number	Diff line change
`@@ -38,5 +38,5 @@ dependencies {`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`testClusters.integTest {`
`41`		`- setting 'node.roles', '[data,master,remote_cluster_client]'`
	`41`	`+ setting 'node.roles', '[data,cluster_manager,remote_cluster_client]'`
`42`	`42`	`}`