diff --git a/modules/rank-eval/src/test/java/org/opensearch/index/rankeval/RankEvalResponseTests.java b/modules/rank-eval/src/test/java/org/opensearch/index/rankeval/RankEvalResponseTests.java
index 3d883b373d705..463df690be763 100644
--- a/modules/rank-eval/src/test/java/org/opensearch/index/rankeval/RankEvalResponseTests.java
+++ b/modules/rank-eval/src/test/java/org/opensearch/index/rankeval/RankEvalResponseTests.java
@@ -37,7 +37,7 @@
 import org.opensearch.action.search.SearchPhaseExecutionException;
 import org.opensearch.action.search.ShardSearchFailure;
 import org.opensearch.cluster.block.ClusterBlockException;
-import org.opensearch.cluster.coordination.NoMasterBlockService;
+import org.opensearch.cluster.coordination.NoClusterManagerBlockService;
 import org.opensearch.common.ParsingException;
 import org.opensearch.common.breaker.CircuitBreaker;
 import org.opensearch.common.breaker.CircuitBreakingException;
@@ -76,7 +76,7 @@
 public class RankEvalResponseTests extends OpenSearchTestCase {
 
     private static final Exception[] RANDOM_EXCEPTIONS = new Exception[] {
-        new ClusterBlockException(singleton(NoMasterBlockService.NO_MASTER_BLOCK_WRITES)),
+        new ClusterBlockException(singleton(NoClusterManagerBlockService.NO_MASTER_BLOCK_WRITES)),
         new CircuitBreakingException("Data too large", 123, 456, CircuitBreaker.Durability.PERMANENT),
         new SearchParseException(SHARD_TARGET, "Parse failure", new XContentLocation(12, 98)),
         new IllegalArgumentException("Closed resource", new RuntimeException("Resource")),
diff --git a/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/state/TransportClusterStateActionDisruptionIT.java b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/state/TransportClusterStateActionDisruptionIT.java
index 8720de848bf14..2dfe784e47350 100644
--- a/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/state/TransportClusterStateActionDisruptionIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/state/TransportClusterStateActionDisruptionIT.java
@@ -40,7 +40,7 @@
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
-import org.opensearch.discovery.MasterNotDiscoveredException;
+import org.opensearch.discovery.ClusterManagerNotDiscoveredException;
 import org.opensearch.plugins.Plugin;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.transport.MockTransportService;
@@ -79,7 +79,7 @@ public void testNonLocalRequestAlwaysFindsClusterManager() throws Exception {
             final ClusterStateResponse clusterStateResponse;
             try {
                 clusterStateResponse = clusterStateRequestBuilder.get();
-            } catch (MasterNotDiscoveredException e) {
+            } catch (ClusterManagerNotDiscoveredException e) {
                 return; // ok, we hit the disconnected node
             }
             assertNotNull("should always contain a cluster-manager node", clusterStateResponse.getState().nodes().getMasterNodeId());
@@ -129,7 +129,7 @@ public void testNonLocalRequestAlwaysFindsClusterManagerAndWaitsForMetadata() th
             final ClusterStateResponse clusterStateResponse;
             try {
                 clusterStateResponse = clusterStateRequestBuilder.get();
-            } catch (MasterNotDiscoveredException e) {
+            } catch (ClusterManagerNotDiscoveredException e) {
                 return; // ok, we hit the disconnected node
             }
             if (clusterStateResponse.isWaitForTimedOut() == false) {
diff --git a/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/exists/IndicesExistsIT.java b/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/exists/IndicesExistsIT.java
index 7aade84fdef7f..f2db023a2ac01 100644
--- a/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/exists/IndicesExistsIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/exists/IndicesExistsIT.java
@@ -34,7 +34,7 @@
 
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
-import org.opensearch.discovery.MasterNotDiscoveredException;
+import org.opensearch.discovery.ClusterManagerNotDiscoveredException;
 import org.opensearch.gateway.GatewayService;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.OpenSearchIntegTestCase.ClusterScope;
@@ -54,7 +54,7 @@ public void testIndexExistsWithBlocksInPlace() throws IOException {
 
         assertRequestBuilderThrows(
             client(node).admin().indices().prepareExists("test").setClusterManagerNodeTimeout(TimeValue.timeValueSeconds(0)),
-            MasterNotDiscoveredException.class
+            ClusterManagerNotDiscoveredException.class
         );
 
         internalCluster().stopRandomNode(InternalTestCluster.nameFilter(node)); // shut down node so that test properly cleans up
diff --git a/server/src/internalClusterTest/java/org/opensearch/cluster/ClusterStateDiffIT.java b/server/src/internalClusterTest/java/org/opensearch/cluster/ClusterStateDiffIT.java
index 8b510c6a13829..52c2cf9bfdcd0 100644
--- a/server/src/internalClusterTest/java/org/opensearch/cluster/ClusterStateDiffIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/cluster/ClusterStateDiffIT.java
@@ -37,7 +37,7 @@
 import org.opensearch.cluster.block.ClusterBlocks;
 import org.opensearch.cluster.coordination.CoordinationMetadata;
 import org.opensearch.cluster.coordination.CoordinationMetadata.VotingConfigExclusion;
-import org.opensearch.cluster.coordination.NoMasterBlockService;
+import org.opensearch.cluster.coordination.NoClusterManagerBlockService;
 import org.opensearch.cluster.metadata.AliasMetadata;
 import org.opensearch.cluster.metadata.IndexGraveyard;
 import org.opensearch.cluster.metadata.IndexGraveyardTests;
@@ -396,9 +396,9 @@ private ClusterState.Builder randomBlocks(ClusterState clusterState) {
     private ClusterBlock randomGlobalBlock() {
         switch (randomInt(2)) {
             case 0:
-                return NoMasterBlockService.NO_MASTER_BLOCK_ALL;
+                return NoClusterManagerBlockService.NO_MASTER_BLOCK_ALL;
             case 1:
-                return NoMasterBlockService.NO_MASTER_BLOCK_WRITES;
+                return NoClusterManagerBlockService.NO_MASTER_BLOCK_WRITES;
             default:
                 return GatewayService.STATE_NOT_RECOVERED_BLOCK;
         }
diff --git a/server/src/internalClusterTest/java/org/opensearch/cluster/MinimumClusterManagerNodesIT.java b/server/src/internalClusterTest/java/org/opensearch/cluster/MinimumClusterManagerNodesIT.java
index 8f512ade7465f..8da6040b6f996 100644
--- a/server/src/internalClusterTest/java/org/opensearch/cluster/MinimumClusterManagerNodesIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/cluster/MinimumClusterManagerNodesIT.java
@@ -39,7 +39,7 @@
 import org.opensearch.action.admin.cluster.health.ClusterHealthResponse;
 import org.opensearch.client.Client;
 import org.opensearch.cluster.coordination.FailedToCommitClusterStateException;
-import org.opensearch.cluster.coordination.NoMasterBlockService;
+import org.opensearch.cluster.coordination.NoClusterManagerBlockService;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.service.ClusterService;
@@ -93,7 +93,7 @@ public void testTwoNodesNoClusterManagerBlock() throws Exception {
 
         logger.info("--> should be blocked, no cluster-manager...");
         ClusterState state = client().admin().cluster().prepareState().setLocal(true).execute().actionGet().getState();
-        assertThat(state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID), equalTo(true));
+        assertThat(state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID), equalTo(true));
         assertThat(state.nodes().getSize(), equalTo(1)); // verify that we still see the local node in the cluster state
 
         logger.info("--> start second node, cluster should be formed");
@@ -109,9 +109,9 @@ public void testTwoNodesNoClusterManagerBlock() throws Exception {
         assertThat(clusterHealthResponse.isTimedOut(), equalTo(false));
 
         state = client().admin().cluster().prepareState().setLocal(true).execute().actionGet().getState();
-        assertThat(state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID), equalTo(false));
+        assertThat(state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID), equalTo(false));
         state = client().admin().cluster().prepareState().setLocal(true).execute().actionGet().getState();
-        assertThat(state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID), equalTo(false));
+        assertThat(state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID), equalTo(false));
 
         state = client().admin().cluster().prepareState().execute().actionGet().getState();
         assertThat(state.nodes().getSize(), equalTo(2));
@@ -161,11 +161,11 @@ public void testTwoNodesNoClusterManagerBlock() throws Exception {
 
         assertBusy(() -> {
             ClusterState clusterState = client().admin().cluster().prepareState().setLocal(true).execute().actionGet().getState();
-            assertTrue(clusterState.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID));
+            assertTrue(clusterState.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID));
         });
 
         state = client().admin().cluster().prepareState().setLocal(true).execute().actionGet().getState();
-        assertThat(state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID), equalTo(true));
+        assertThat(state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID), equalTo(true));
         // verify that both nodes are still in the cluster state but there is no cluster-manager
         assertThat(state.nodes().getSize(), equalTo(2));
         assertThat(state.nodes().getMasterNode(), equalTo(null));
@@ -184,9 +184,9 @@ public void testTwoNodesNoClusterManagerBlock() throws Exception {
         assertThat(clusterHealthResponse.isTimedOut(), equalTo(false));
 
         state = client().admin().cluster().prepareState().setLocal(true).execute().actionGet().getState();
-        assertThat(state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID), equalTo(false));
+        assertThat(state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID), equalTo(false));
         state = client().admin().cluster().prepareState().setLocal(true).execute().actionGet().getState();
-        assertThat(state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID), equalTo(false));
+        assertThat(state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID), equalTo(false));
 
         state = client().admin().cluster().prepareState().execute().actionGet().getState();
         assertThat(state.nodes().getSize(), equalTo(2));
@@ -214,7 +214,7 @@ public void testTwoNodesNoClusterManagerBlock() throws Exception {
 
         assertBusy(() -> {
             ClusterState state1 = client().admin().cluster().prepareState().setLocal(true).execute().actionGet().getState();
-            assertThat(state1.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID), equalTo(true));
+            assertThat(state1.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID), equalTo(true));
         });
 
         logger.info("--> starting the previous cluster-manager node again...");
@@ -232,9 +232,9 @@ public void testTwoNodesNoClusterManagerBlock() throws Exception {
         assertThat(clusterHealthResponse.isTimedOut(), equalTo(false));
 
         state = client().admin().cluster().prepareState().setLocal(true).execute().actionGet().getState();
-        assertThat(state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID), equalTo(false));
+        assertThat(state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID), equalTo(false));
         state = client().admin().cluster().prepareState().setLocal(true).execute().actionGet().getState();
-        assertThat(state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID), equalTo(false));
+        assertThat(state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID), equalTo(false));
 
         state = client().admin().cluster().prepareState().execute().actionGet().getState();
         assertThat(state.nodes().getSize(), equalTo(2));
@@ -262,7 +262,7 @@ public void testThreeNodesNoClusterManagerBlock() throws Exception {
         assertBusy(() -> {
             for (Client client : clients()) {
                 ClusterState state1 = client.admin().cluster().prepareState().setLocal(true).execute().actionGet().getState();
-                assertThat(state1.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID), equalTo(true));
+                assertThat(state1.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID), equalTo(true));
             }
         });
 
@@ -321,7 +321,7 @@ public void testThreeNodesNoClusterManagerBlock() throws Exception {
         // spin here to wait till the state is set
         assertBusy(() -> {
             ClusterState st = client().admin().cluster().prepareState().setLocal(true).execute().actionGet().getState();
-            assertThat(st.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID), equalTo(true));
+            assertThat(st.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID), equalTo(true));
         });
 
         logger.info("--> start back the 2 nodes ");
diff --git a/server/src/internalClusterTest/java/org/opensearch/cluster/NoClusterManagerNodeIT.java b/server/src/internalClusterTest/java/org/opensearch/cluster/NoClusterManagerNodeIT.java
index 26852e59d1c86..0a4d9f8564b61 100644
--- a/server/src/internalClusterTest/java/org/opensearch/cluster/NoClusterManagerNodeIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/cluster/NoClusterManagerNodeIT.java
@@ -44,13 +44,13 @@
 import org.opensearch.client.Requests;
 import org.opensearch.cluster.action.index.MappingUpdatedAction;
 import org.opensearch.cluster.block.ClusterBlockException;
-import org.opensearch.cluster.coordination.NoMasterBlockService;
+import org.opensearch.cluster.coordination.NoClusterManagerBlockService;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.xcontent.XContentFactory;
-import org.opensearch.discovery.MasterNotDiscoveredException;
+import org.opensearch.discovery.ClusterManagerNotDiscoveredException;
 import org.opensearch.plugins.Plugin;
 import org.opensearch.rest.RestStatus;
 import org.opensearch.script.Script;
@@ -90,7 +90,7 @@ protected Collection<Class<? extends Plugin>> nodePlugins() {
     public void testNoClusterManagerActions() throws Exception {
         Settings settings = Settings.builder()
             .put(AutoCreateIndex.AUTO_CREATE_INDEX_SETTING.getKey(), true)
-            .put(NoMasterBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.getKey(), "all")
+            .put(NoClusterManagerBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.getKey(), "all")
             .build();
 
         final TimeValue timeout = TimeValue.timeValueMillis(10);
@@ -117,7 +117,7 @@ public void testNoClusterManagerActions() throws Exception {
                 .execute()
                 .actionGet()
                 .getState();
-            assertTrue(state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID));
+            assertTrue(state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID));
         });
 
         assertRequestBuilderThrows(
@@ -233,9 +233,9 @@ void checkUpdateAction(boolean autoCreateIndex, TimeValue timeout, ActionRequest
         // we clean the metadata when loosing a cluster-manager, therefore all operations on indices will auto create it, if allowed
         try {
             builder.get();
-            fail("expected ClusterBlockException or MasterNotDiscoveredException");
-        } catch (ClusterBlockException | MasterNotDiscoveredException e) {
-            if (e instanceof MasterNotDiscoveredException) {
+            fail("expected ClusterBlockException or ClusterManagerNotDiscoveredException");
+        } catch (ClusterBlockException | ClusterManagerNotDiscoveredException e) {
+            if (e instanceof ClusterManagerNotDiscoveredException) {
                 assertTrue(autoCreateIndex);
             } else {
                 assertFalse(autoCreateIndex);
@@ -256,7 +256,7 @@ void checkWriteAction(ActionRequestBuilder<?, ?> builder) {
     public void testNoClusterManagerActionsWriteClusterManagerBlock() throws Exception {
         Settings settings = Settings.builder()
             .put(AutoCreateIndex.AUTO_CREATE_INDEX_SETTING.getKey(), false)
-            .put(NoMasterBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.getKey(), "write")
+            .put(NoClusterManagerBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.getKey(), "write")
             .build();
 
         final List<String> nodes = internalCluster().startNodes(3, settings);
@@ -288,7 +288,7 @@ public void testNoClusterManagerActionsWriteClusterManagerBlock() throws Excepti
 
         assertBusy(() -> {
             ClusterState state = clientToClusterManagerlessNode.admin().cluster().prepareState().setLocal(true).get().getState();
-            assertTrue(state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID));
+            assertTrue(state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID));
         });
 
         GetResponse getResponse = clientToClusterManagerlessNode.prepareGet("test1", "1").get();
@@ -340,7 +340,7 @@ public void testNoClusterManagerActionsWriteClusterManagerBlock() throws Excepti
 
     public void testNoClusterManagerActionsMetadataWriteClusterManagerBlock() throws Exception {
         Settings settings = Settings.builder()
-            .put(NoMasterBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.getKey(), "metadata_write")
+            .put(NoClusterManagerBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.getKey(), "metadata_write")
             .put(MappingUpdatedAction.INDICES_MAPPING_DYNAMIC_TIMEOUT_SETTING.getKey(), "100ms")
             .build();
 
@@ -387,7 +387,7 @@ public void testNoClusterManagerActionsMetadataWriteClusterManagerBlock() throws
         assertBusy(() -> {
             for (String node : nodesWithShards) {
                 ClusterState state = client(node).admin().cluster().prepareState().setLocal(true).get().getState();
-                assertTrue(state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID));
+                assertTrue(state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID));
             }
         });
 
@@ -429,7 +429,7 @@ public void testNoClusterManagerActionsMetadataWriteClusterManagerBlock() throws
 
         // dynamic mapping updates fail
         expectThrows(
-            MasterNotDiscoveredException.class,
+            ClusterManagerNotDiscoveredException.class,
             () -> client(randomFrom(nodesWithShards)).prepareIndex("test1")
                 .setId("1")
                 .setSource(XContentFactory.jsonBuilder().startObject().field("new_field", "value").endObject())
@@ -439,7 +439,7 @@ public void testNoClusterManagerActionsMetadataWriteClusterManagerBlock() throws
 
         // dynamic index creation fails
         expectThrows(
-            MasterNotDiscoveredException.class,
+            ClusterManagerNotDiscoveredException.class,
             () -> client(randomFrom(nodesWithShards)).prepareIndex("test2")
                 .setId("1")
                 .setSource(XContentFactory.jsonBuilder().startObject().endObject())
diff --git a/server/src/internalClusterTest/java/org/opensearch/cluster/SpecificClusterManagerNodesIT.java b/server/src/internalClusterTest/java/org/opensearch/cluster/SpecificClusterManagerNodesIT.java
index 2f81299d76db9..ebdff162ca4e2 100644
--- a/server/src/internalClusterTest/java/org/opensearch/cluster/SpecificClusterManagerNodesIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/cluster/SpecificClusterManagerNodesIT.java
@@ -36,7 +36,7 @@
 import org.opensearch.action.admin.cluster.configuration.AddVotingConfigExclusionsAction;
 import org.opensearch.action.admin.cluster.configuration.AddVotingConfigExclusionsRequest;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.discovery.MasterNotDiscoveredException;
+import org.opensearch.discovery.ClusterManagerNotDiscoveredException;
 import org.opensearch.index.query.QueryBuilders;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.OpenSearchIntegTestCase.ClusterScope;
@@ -73,7 +73,7 @@ public void testSimpleOnlyClusterManagerNodeElection() throws IOException {
                 nullValue()
             );
             fail("should not be able to find cluster-manager");
-        } catch (MasterNotDiscoveredException e) {
+        } catch (ClusterManagerNotDiscoveredException e) {
             // all is well, no cluster-manager elected
         }
         logger.info("--> start cluster-manager node");
@@ -123,7 +123,7 @@ public void testSimpleOnlyClusterManagerNodeElection() throws IOException {
                 nullValue()
             );
             fail("should not be able to find cluster-manager");
-        } catch (MasterNotDiscoveredException e) {
+        } catch (ClusterManagerNotDiscoveredException e) {
             // all is well, no cluster-manager elected
         }
 
@@ -177,7 +177,7 @@ public void testElectOnlyBetweenClusterManagerNodes() throws Exception {
                 nullValue()
             );
             fail("should not be able to find cluster-manager");
-        } catch (MasterNotDiscoveredException e) {
+        } catch (ClusterManagerNotDiscoveredException e) {
             // all is well, no cluster-manager elected
         }
         logger.info("--> start cluster-manager node (1)");
diff --git a/server/src/internalClusterTest/java/org/opensearch/cluster/coordination/UnsafeBootstrapAndDetachCommandIT.java b/server/src/internalClusterTest/java/org/opensearch/cluster/coordination/UnsafeBootstrapAndDetachCommandIT.java
index b0153a1306928..72e24b0396695 100644
--- a/server/src/internalClusterTest/java/org/opensearch/cluster/coordination/UnsafeBootstrapAndDetachCommandIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/cluster/coordination/UnsafeBootstrapAndDetachCommandIT.java
@@ -109,9 +109,15 @@ private MockTerminal executeCommand(
     }
 
     private MockTerminal unsafeBootstrap(Environment environment, boolean abort, Boolean applyClusterReadOnlyBlock) throws Exception {
-        final MockTerminal terminal = executeCommand(new UnsafeBootstrapMasterCommand(), environment, 0, abort, applyClusterReadOnlyBlock);
-        assertThat(terminal.getOutput(), containsString(UnsafeBootstrapMasterCommand.CONFIRMATION_MSG));
-        assertThat(terminal.getOutput(), containsString(UnsafeBootstrapMasterCommand.CLUSTER_MANAGER_NODE_BOOTSTRAPPED_MSG));
+        final MockTerminal terminal = executeCommand(
+            new UnsafeBootstrapClusterManagerCommand(),
+            environment,
+            0,
+            abort,
+            applyClusterReadOnlyBlock
+        );
+        assertThat(terminal.getOutput(), containsString(UnsafeBootstrapClusterManagerCommand.CONFIRMATION_MSG));
+        assertThat(terminal.getOutput(), containsString(UnsafeBootstrapClusterManagerCommand.CLUSTER_MANAGER_NODE_BOOTSTRAPPED_MSG));
         return terminal;
     }
 
@@ -171,7 +177,7 @@ public void testBootstrapNotClusterManagerEligible() {
         final Environment environment = TestEnvironment.newEnvironment(
             Settings.builder().put(nonMasterNode(internalCluster().getDefaultSettings())).build()
         );
-        expectThrows(() -> unsafeBootstrap(environment), UnsafeBootstrapMasterCommand.NOT_CLUSTER_MANAGER_NODE_MSG);
+        expectThrows(() -> unsafeBootstrap(environment), UnsafeBootstrapClusterManagerCommand.NOT_CLUSTER_MANAGER_NODE_MSG);
     }
 
     public void testBootstrapNoDataFolder() {
@@ -214,7 +220,7 @@ public void testBootstrapNotBootstrappedCluster() throws Exception {
         );
         assertBusy(() -> {
             ClusterState state = client().admin().cluster().prepareState().setLocal(true).execute().actionGet().getState();
-            assertTrue(state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID));
+            assertTrue(state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID));
         });
 
         Settings dataPathSettings = internalCluster().dataPathSettings(node);
@@ -224,7 +230,7 @@ public void testBootstrapNotBootstrappedCluster() throws Exception {
         Environment environment = TestEnvironment.newEnvironment(
             Settings.builder().put(internalCluster().getDefaultSettings()).put(dataPathSettings).build()
         );
-        expectThrows(() -> unsafeBootstrap(environment), UnsafeBootstrapMasterCommand.EMPTY_LAST_COMMITTED_VOTING_CONFIG_MSG);
+        expectThrows(() -> unsafeBootstrap(environment), UnsafeBootstrapClusterManagerCommand.EMPTY_LAST_COMMITTED_VOTING_CONFIG_MSG);
     }
 
     public void testBootstrapNoClusterState() throws IOException {
@@ -332,14 +338,17 @@ public void test3ClusterManagerNodes2Failed() throws Exception {
                 .execute()
                 .actionGet()
                 .getState();
-            assertTrue(state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID));
+            assertTrue(state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID));
         });
 
         logger.info("--> try to unsafely bootstrap 1st cluster-manager-eligible node, while node lock is held");
         Environment environmentClusterManager1 = TestEnvironment.newEnvironment(
             Settings.builder().put(internalCluster().getDefaultSettings()).put(clusterManager1DataPathSettings).build()
         );
-        expectThrows(() -> unsafeBootstrap(environmentClusterManager1), UnsafeBootstrapMasterCommand.FAILED_TO_OBTAIN_NODE_LOCK_MSG);
+        expectThrows(
+            () -> unsafeBootstrap(environmentClusterManager1),
+            UnsafeBootstrapClusterManagerCommand.FAILED_TO_OBTAIN_NODE_LOCK_MSG
+        );
 
         logger.info("--> stop 1st cluster-manager-eligible node and data-only node");
         NodeEnvironment nodeEnvironment = internalCluster().getMasterNodeInstance(NodeEnvironment.class);
@@ -356,7 +365,7 @@ public void test3ClusterManagerNodes2Failed() throws Exception {
             containsString(
                 String.format(
                     Locale.ROOT,
-                    UnsafeBootstrapMasterCommand.CLUSTER_STATE_TERM_VERSION_MSG_FORMAT,
+                    UnsafeBootstrapClusterManagerCommand.CLUSTER_STATE_TERM_VERSION_MSG_FORMAT,
                     metadata.coordinationMetadata().term(),
                     metadata.version()
                 )
@@ -385,8 +394,10 @@ public void test3ClusterManagerNodes2Failed() throws Exception {
                 .execute()
                 .actionGet()
                 .getState();
-            assertFalse(state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID));
-            assertTrue(state.metadata().persistentSettings().getAsBoolean(UnsafeBootstrapMasterCommand.UNSAFE_BOOTSTRAP.getKey(), false));
+            assertFalse(state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID));
+            assertTrue(
+                state.metadata().persistentSettings().getAsBoolean(UnsafeBootstrapClusterManagerCommand.UNSAFE_BOOTSTRAP.getKey(), false)
+            );
         });
 
         List<String> bootstrappedNodes = new ArrayList<>();
@@ -497,7 +508,7 @@ public void testNoInitialBootstrapAfterDetach() throws Exception {
         );
 
         ClusterState state = internalCluster().client().admin().cluster().prepareState().setLocal(true).execute().actionGet().getState();
-        assertTrue(state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID));
+        assertTrue(state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID));
 
         internalCluster().stopRandomNode(InternalTestCluster.nameFilter(node));
     }
diff --git a/server/src/internalClusterTest/java/org/opensearch/discovery/ClusterManagerDisruptionIT.java b/server/src/internalClusterTest/java/org/opensearch/discovery/ClusterManagerDisruptionIT.java
index d2f406a0c5d98..2f19d1e476c94 100644
--- a/server/src/internalClusterTest/java/org/opensearch/discovery/ClusterManagerDisruptionIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/discovery/ClusterManagerDisruptionIT.java
@@ -37,7 +37,7 @@
 import org.opensearch.action.bulk.BulkRequestBuilder;
 import org.opensearch.action.bulk.BulkResponse;
 import org.opensearch.cluster.ClusterState;
-import org.opensearch.cluster.coordination.NoMasterBlockService;
+import org.opensearch.cluster.coordination.NoClusterManagerBlockService;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
@@ -198,7 +198,10 @@ public void testIsolateClusterManagerAndVerifyClusterStateConsensus() throws Exc
      * Verify that the proper block is applied when nodes lose their cluster-manager
      */
     public void testVerifyApiBlocksDuringPartition() throws Exception {
-        internalCluster().startNodes(3, Settings.builder().putNull(NoMasterBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.getKey()).build());
+        internalCluster().startNodes(
+            3,
+            Settings.builder().putNull(NoClusterManagerBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.getKey()).build()
+        );
 
         // Makes sure that the get request can be executed on each node locally:
         assertAcked(
@@ -227,7 +230,7 @@ public void testVerifyApiBlocksDuringPartition() throws Exception {
         // continuously ping until network failures have been resolved. However
         // It may a take a bit before the node detects it has been cut off from the elected cluster-manager
         logger.info("waiting for isolated node [{}] to have no cluster-manager", isolatedNode);
-        assertNoClusterManager(isolatedNode, NoMasterBlockService.NO_MASTER_BLOCK_METADATA_WRITES, TimeValue.timeValueSeconds(30));
+        assertNoClusterManager(isolatedNode, NoClusterManagerBlockService.NO_MASTER_BLOCK_METADATA_WRITES, TimeValue.timeValueSeconds(30));
 
         logger.info("wait until elected cluster-manager has been removed and a new 2 node cluster was from (via [{}])", isolatedNode);
         ensureStableCluster(2, nonIsolatedNode);
@@ -258,13 +261,13 @@ public void testVerifyApiBlocksDuringPartition() throws Exception {
 
         logger.info(
             "Verify no cluster-manager block with {} set to {}",
-            NoMasterBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.getKey(),
+            NoClusterManagerBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.getKey(),
             "all"
         );
         client().admin()
             .cluster()
             .prepareUpdateSettings()
-            .setTransientSettings(Settings.builder().put(NoMasterBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.getKey(), "all"))
+            .setTransientSettings(Settings.builder().put(NoClusterManagerBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.getKey(), "all"))
             .get();
 
         networkDisruption.startDisrupting();
@@ -273,7 +276,7 @@ public void testVerifyApiBlocksDuringPartition() throws Exception {
         // continuously ping until network failures have been resolved. However
         // It may a take a bit before the node detects it has been cut off from the elected cluster-manager
         logger.info("waiting for isolated node [{}] to have no cluster-manager", isolatedNode);
-        assertNoClusterManager(isolatedNode, NoMasterBlockService.NO_MASTER_BLOCK_ALL, TimeValue.timeValueSeconds(30));
+        assertNoClusterManager(isolatedNode, NoClusterManagerBlockService.NO_MASTER_BLOCK_ALL, TimeValue.timeValueSeconds(30));
 
         // make sure we have stable cluster & cross partition recoveries are canceled by the removal of the missing node
         // the unresponsive partition causes recoveries to only time out after 15m (default) and these will cause
diff --git a/server/src/main/java/org/opensearch/Assertions.java b/server/src/main/java/org/opensearch/Assertions.java
index 843853ec8b20b..dd2fcf9481a3c 100644
--- a/server/src/main/java/org/opensearch/Assertions.java
+++ b/server/src/main/java/org/opensearch/Assertions.java
@@ -35,7 +35,7 @@
 /**
  * Provides a static final field that can be used to check if assertions are enabled. Since this field might be used elsewhere to check if
  * assertions are enabled, if you are running with assertions enabled for specific packages or classes, you should enable assertions on this
- * class too (e.g., {@code -ea org.opensearch.Assertions -ea org.opensearch.cluster.service.MasterService}).
+ * class too (e.g., {@code -ea org.opensearch.Assertions -ea org.opensearch.cluster.service.ClusterManagerService}).
  *
  * @opensearch.internal
  */
diff --git a/server/src/main/java/org/opensearch/OpenSearchException.java b/server/src/main/java/org/opensearch/OpenSearchException.java
index a6a12d7ebb4f7..019d3a2cb42cd 100644
--- a/server/src/main/java/org/opensearch/OpenSearchException.java
+++ b/server/src/main/java/org/opensearch/OpenSearchException.java
@@ -788,8 +788,8 @@ private enum OpenSearchExceptionHandle {
             UNKNOWN_VERSION_ADDED
         ),
         CLUSTER_MANAGER_NOT_DISCOVERED_EXCEPTION(
-            org.opensearch.discovery.MasterNotDiscoveredException.class,
-            org.opensearch.discovery.MasterNotDiscoveredException::new,
+            org.opensearch.discovery.ClusterManagerNotDiscoveredException.class,
+            org.opensearch.discovery.ClusterManagerNotDiscoveredException::new,
             3,
             UNKNOWN_VERSION_ADDED
         ),
@@ -1499,8 +1499,8 @@ private enum OpenSearchExceptionHandle {
             UNKNOWN_VERSION_ADDED
         ),
         NOT_CLUSTER_MANAGER_EXCEPTION(
-            org.opensearch.cluster.NotMasterException.class,
-            org.opensearch.cluster.NotMasterException::new,
+            org.opensearch.cluster.NotClusterManagerException.class,
+            org.opensearch.cluster.NotClusterManagerException::new,
             144,
             UNKNOWN_VERSION_ADDED
         ),
diff --git a/server/src/main/java/org/opensearch/action/ActionModule.java b/server/src/main/java/org/opensearch/action/ActionModule.java
index 790f8f6cbdc36..2a3c82991d9bb 100644
--- a/server/src/main/java/org/opensearch/action/ActionModule.java
+++ b/server/src/main/java/org/opensearch/action/ActionModule.java
@@ -368,7 +368,7 @@
 import org.opensearch.rest.action.cat.RestFielddataAction;
 import org.opensearch.rest.action.cat.RestHealthAction;
 import org.opensearch.rest.action.cat.RestIndicesAction;
-import org.opensearch.rest.action.cat.RestMasterAction;
+import org.opensearch.rest.action.cat.RestClusterManagerAction;
 import org.opensearch.rest.action.cat.RestNodeAttrsAction;
 import org.opensearch.rest.action.cat.RestNodesAction;
 import org.opensearch.rest.action.cat.RestPluginsAction;
@@ -809,7 +809,7 @@ public void initRestHandlers(Supplier<DiscoveryNodes> nodesInCluster) {
         // CAT API
         registerHandler.accept(new RestAllocationAction());
         registerHandler.accept(new RestShardsAction());
-        registerHandler.accept(new RestMasterAction());
+        registerHandler.accept(new RestClusterManagerAction());
         registerHandler.accept(new RestNodesAction());
         registerHandler.accept(new RestTasksAction(nodesInCluster));
         registerHandler.accept(new RestIndicesAction());
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/health/TransportClusterHealthAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/health/TransportClusterHealthAction.java
index 6120317dfeace..3e3d373ff3b31 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/health/TransportClusterHealthAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/health/TransportClusterHealthAction.java
@@ -44,7 +44,7 @@
 import org.opensearch.cluster.ClusterStateObserver;
 import org.opensearch.cluster.ClusterStateUpdateTask;
 import org.opensearch.cluster.LocalClusterUpdateTask;
-import org.opensearch.cluster.NotMasterException;
+import org.opensearch.cluster.NotClusterManagerException;
 import org.opensearch.cluster.block.ClusterBlockException;
 import org.opensearch.cluster.health.ClusterHealthStatus;
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
@@ -226,8 +226,9 @@ public void onNoLongerMaster(String source) {
                             "stopped being cluster-manager while waiting for events with priority [{}]. retrying.",
                             request.waitForEvents()
                         );
-                        // TransportMasterNodeAction implements the retry logic, which is triggered by passing a NotMasterException
-                        listener.onFailure(new NotMasterException("no longer cluster-manager. source: [" + source + "]"));
+                        // TransportClusterManagerNodeAction implements the retry logic,
+                        // which is triggered by passing a NotClusterManagerException
+                        listener.onFailure(new NotClusterManagerException("no longer cluster-manager. source: [" + source + "]"));
                     }
 
                     @Override
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
index 673153c40bf46..b2e09629fc501 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
@@ -40,7 +40,7 @@
 import org.opensearch.action.support.clustermanager.TransportClusterManagerNodeReadAction;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateObserver;
-import org.opensearch.cluster.NotMasterException;
+import org.opensearch.cluster.NotClusterManagerException;
 import org.opensearch.cluster.block.ClusterBlockException;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
@@ -142,7 +142,7 @@ public void onNewClusterState(ClusterState newState) {
                             ActionListener.completeWith(listener, () -> buildResponse(request, newState));
                         } else {
                             listener.onFailure(
-                                new NotMasterException(
+                                new NotClusterManagerException(
                                     "cluster-manager stepped down waiting for metadata version " + request.waitForMetadataVersion()
                                 )
                             );
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
index 46c93a8d33c7b..05b2f5eb168d8 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
@@ -43,8 +43,8 @@
 import org.opensearch.action.support.HandledTransportAction;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateObserver;
-import org.opensearch.cluster.MasterNodeChangePredicate;
-import org.opensearch.cluster.NotMasterException;
+import org.opensearch.cluster.ClusterManagerNodeChangePredicate;
+import org.opensearch.cluster.NotClusterManagerException;
 import org.opensearch.cluster.block.ClusterBlockException;
 import org.opensearch.cluster.coordination.FailedToCommitClusterStateException;
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
@@ -54,7 +54,7 @@
 import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.common.io.stream.Writeable;
 import org.opensearch.common.unit.TimeValue;
-import org.opensearch.discovery.MasterNotDiscoveredException;
+import org.opensearch.discovery.ClusterManagerNotDiscoveredException;
 import org.opensearch.node.NodeClosedException;
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
@@ -186,7 +186,7 @@ protected void doStart(ClusterState clusterState) {
                         }
                     } else {
                         ActionListener<Response> delegate = ActionListener.delegateResponse(listener, (delegatedListener, t) -> {
-                            if (t instanceof FailedToCommitClusterStateException || t instanceof NotMasterException) {
+                            if (t instanceof FailedToCommitClusterStateException || t instanceof NotClusterManagerException) {
                                 logger.debug(
                                     () -> new ParameterizedMessage(
                                         "master could not publish cluster state or "
@@ -243,7 +243,7 @@ public void handleException(final TransportException exp) {
         }
 
         private void retryOnMasterChange(ClusterState state, Throwable failure) {
-            retry(state, failure, MasterNodeChangePredicate.build(state));
+            retry(state, failure, ClusterManagerNodeChangePredicate.build(state));
         }
 
         private void retry(ClusterState state, final Throwable failure, final Predicate<ClusterState> statePredicate) {
@@ -252,7 +252,7 @@ private void retry(ClusterState state, final Throwable failure, final Predicate<
                     - startTime);
                 if (remainingTimeoutMS <= 0) {
                     logger.debug(() -> new ParameterizedMessage("timed out before retrying [{}] after failure", actionName), failure);
-                    listener.onFailure(new MasterNotDiscoveredException(failure));
+                    listener.onFailure(new ClusterManagerNotDiscoveredException(failure));
                     return;
                 }
                 this.observer = new ClusterStateObserver(
@@ -280,7 +280,7 @@ public void onTimeout(TimeValue timeout) {
                         () -> new ParameterizedMessage("timed out while retrying [{}] after failure (timeout [{}])", actionName, timeout),
                         failure
                     );
-                    listener.onFailure(new MasterNotDiscoveredException(failure));
+                    listener.onFailure(new ClusterManagerNotDiscoveredException(failure));
                 }
             }, statePredicate);
         }
diff --git a/server/src/main/java/org/opensearch/cluster/MasterNodeChangePredicate.java b/server/src/main/java/org/opensearch/cluster/ClusterManagerNodeChangePredicate.java
similarity index 95%
rename from server/src/main/java/org/opensearch/cluster/MasterNodeChangePredicate.java
rename to server/src/main/java/org/opensearch/cluster/ClusterManagerNodeChangePredicate.java
index 7ff5161c443a1..ecb99e06f3ef0 100644
--- a/server/src/main/java/org/opensearch/cluster/MasterNodeChangePredicate.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterManagerNodeChangePredicate.java
@@ -41,9 +41,9 @@
  *
  * @opensearch.internal
  */
-public final class MasterNodeChangePredicate {
+public final class ClusterManagerNodeChangePredicate {
 
-    private MasterNodeChangePredicate() {
+    private ClusterManagerNodeChangePredicate() {
 
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterStateTaskListener.java b/server/src/main/java/org/opensearch/cluster/ClusterStateTaskListener.java
index 91137a7efae92..74cc118892579 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterStateTaskListener.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterStateTaskListener.java
@@ -52,7 +52,7 @@ public interface ClusterStateTaskListener {
      * Used only for tasks submitted to {@link MasterService}.
      */
     default void onNoLongerMaster(String source) {
-        onFailure(source, new NotMasterException("no longer cluster-manager. source: [" + source + "]"));
+        onFailure(source, new NotClusterManagerException("no longer cluster-manager. source: [" + source + "]"));
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/cluster/LocalNodeMasterListener.java b/server/src/main/java/org/opensearch/cluster/LocalNodeClusterManagerListener.java
similarity index 96%
rename from server/src/main/java/org/opensearch/cluster/LocalNodeMasterListener.java
rename to server/src/main/java/org/opensearch/cluster/LocalNodeClusterManagerListener.java
index bec2674f5d549..42a6438ff125e 100644
--- a/server/src/main/java/org/opensearch/cluster/LocalNodeMasterListener.java
+++ b/server/src/main/java/org/opensearch/cluster/LocalNodeClusterManagerListener.java
@@ -37,7 +37,7 @@
  *
  * @opensearch.internal
  */
-public interface LocalNodeMasterListener extends ClusterStateListener {
+public interface LocalNodeClusterManagerListener extends ClusterStateListener {
 
     /**
      * Called when local node is elected to be the cluster-manager
diff --git a/server/src/main/java/org/opensearch/cluster/NotMasterException.java b/server/src/main/java/org/opensearch/cluster/NotClusterManagerException.java
similarity index 89%
rename from server/src/main/java/org/opensearch/cluster/NotMasterException.java
rename to server/src/main/java/org/opensearch/cluster/NotClusterManagerException.java
index a855f3b665ac3..522bad0f9d682 100644
--- a/server/src/main/java/org/opensearch/cluster/NotMasterException.java
+++ b/server/src/main/java/org/opensearch/cluster/NotClusterManagerException.java
@@ -43,13 +43,13 @@
  *
  * @opensearch.internal
  */
-public class NotMasterException extends OpenSearchException {
+public class NotClusterManagerException extends OpenSearchException {
 
-    public NotMasterException(String msg) {
+    public NotClusterManagerException(String msg) {
         super(msg);
     }
 
-    public NotMasterException(StreamInput in) throws IOException {
+    public NotClusterManagerException(StreamInput in) throws IOException {
         super(in);
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/action/shard/ShardStateAction.java b/server/src/main/java/org/opensearch/cluster/action/shard/ShardStateAction.java
index 93ddd74322ce9..81a365df9866d 100644
--- a/server/src/main/java/org/opensearch/cluster/action/shard/ShardStateAction.java
+++ b/server/src/main/java/org/opensearch/cluster/action/shard/ShardStateAction.java
@@ -44,8 +44,8 @@
 import org.opensearch.cluster.ClusterStateTaskConfig;
 import org.opensearch.cluster.ClusterStateTaskExecutor;
 import org.opensearch.cluster.ClusterStateTaskListener;
-import org.opensearch.cluster.MasterNodeChangePredicate;
-import org.opensearch.cluster.NotMasterException;
+import org.opensearch.cluster.ClusterManagerNodeChangePredicate;
+import org.opensearch.cluster.NotClusterManagerException;
 import org.opensearch.cluster.coordination.FailedToCommitClusterStateException;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
@@ -183,7 +183,7 @@ private void sendShardAction(
     ) {
         ClusterStateObserver observer = new ClusterStateObserver(currentState, clusterService, null, logger, threadPool.getThreadContext());
         DiscoveryNode clusterManagerNode = currentState.nodes().getMasterNode();
-        Predicate<ClusterState> changePredicate = MasterNodeChangePredicate.build(currentState);
+        Predicate<ClusterState> changePredicate = ClusterManagerNodeChangePredicate.build(currentState);
         if (clusterManagerNode == null) {
             logger.warn("no cluster-manager known for action [{}] for shard entry [{}]", actionName, request);
             waitForNewClusterManagerAndRetry(actionName, observer, request, listener, changePredicate);
@@ -223,7 +223,7 @@ public void handleException(TransportException exp) {
     }
 
     private static Class[] CLUSTER_MANAGER_CHANNEL_EXCEPTIONS = new Class[] {
-        NotMasterException.class,
+        NotClusterManagerException.class,
         ConnectTransportException.class,
         FailedToCommitClusterStateException.class };
 
@@ -388,7 +388,7 @@ public void onFailure(String source, Exception e) {
                     public void onNoLongerMaster(String source) {
                         logger.error("{} no longer cluster-manager while failing shard [{}]", request.shardId, request);
                         try {
-                            channel.sendResponse(new NotMasterException(source));
+                            channel.sendResponse(new NotClusterManagerException(source));
                         } catch (Exception channelException) {
                             logger.warn(
                                 () -> new ParameterizedMessage(
@@ -817,7 +817,7 @@ public ClusterTasksResult<StartedShardEntry> execute(ClusterState currentState,
 
         @Override
         public void onFailure(String source, Exception e) {
-            if (e instanceof FailedToCommitClusterStateException || e instanceof NotMasterException) {
+            if (e instanceof FailedToCommitClusterStateException || e instanceof NotClusterManagerException) {
                 logger.debug(() -> new ParameterizedMessage("failure during [{}]", source), e);
             } else {
                 logger.error(() -> new ParameterizedMessage("unexpected failure during [{}]", source), e);
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
index 5a4f9be40600d..e3a72faace106 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
@@ -105,7 +105,7 @@
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
-import static org.opensearch.cluster.coordination.NoMasterBlockService.NO_MASTER_BLOCK_ID;
+import static org.opensearch.cluster.coordination.NoClusterManagerBlockService.NO_MASTER_BLOCK_ID;
 import static org.opensearch.gateway.ClusterStateUpdaters.hideStateIfNotRecovered;
 import static org.opensearch.gateway.GatewayService.STATE_NOT_RECOVERED_BLOCK;
 import static org.opensearch.monitor.StatusInfo.Status.UNHEALTHY;
@@ -141,12 +141,12 @@ public class Coordinator extends AbstractLifecycleComponent implements Discovery
     private final boolean singleNodeDiscovery;
     private final ElectionStrategy electionStrategy;
     private final TransportService transportService;
-    private final MasterService clusterManagerService;
+    private final MasterService masterService;
     private final AllocationService allocationService;
     private final JoinHelper joinHelper;
     private final NodeRemovalClusterStateTaskExecutor nodeRemovalExecutor;
     private final Supplier<CoordinationState.PersistedState> persistedStateSupplier;
-    private final NoMasterBlockService noClusterManagerBlockService;
+    private final NoClusterManagerBlockService noClusterManagerBlockService;
     final Object mutex = new Object(); // package-private to allow tests to call methods that assert that the mutex is held
     private final SetOnce<CoordinationState> coordinationState = new SetOnce<>(); // initialized on start-up (see doStart)
     private volatile ClusterState applierState; // the state that should be exposed to the cluster state applier
@@ -191,7 +191,7 @@ public Coordinator(
         TransportService transportService,
         NamedWriteableRegistry namedWriteableRegistry,
         AllocationService allocationService,
-        MasterService clusterManagerService,
+        MasterService masterService,
         Supplier<CoordinationState.PersistedState> persistedStateSupplier,
         SeedHostsProvider seedHostsProvider,
         ClusterApplier clusterApplier,
@@ -203,7 +203,7 @@ public Coordinator(
     ) {
         this.settings = settings;
         this.transportService = transportService;
-        this.clusterManagerService = clusterManagerService;
+        this.masterService = masterService;
         this.allocationService = allocationService;
         this.onJoinValidators = JoinTaskExecutor.addBuiltInJoinValidators(onJoinValidators);
         this.singleNodeDiscovery = DiscoveryModule.isSingleNodeDiscovery(settings);
@@ -211,7 +211,7 @@ public Coordinator(
         this.joinHelper = new JoinHelper(
             settings,
             allocationService,
-            clusterManagerService,
+            masterService,
             transportService,
             this::getCurrentTerm,
             this::getStateForClusterManagerService,
@@ -222,7 +222,7 @@ public Coordinator(
             nodeHealthService
         );
         this.persistedStateSupplier = persistedStateSupplier;
-        this.noClusterManagerBlockService = new NoMasterBlockService(settings, clusterSettings);
+        this.noClusterManagerBlockService = new NoClusterManagerBlockService(settings, clusterSettings);
         this.lastKnownLeader = Optional.empty();
         this.lastJoin = Optional.empty();
         this.joinAccumulator = new InitialJoinAccumulator();
@@ -260,7 +260,7 @@ public Coordinator(
         );
         this.nodeRemovalExecutor = new NodeRemovalClusterStateTaskExecutor(allocationService, logger);
         this.clusterApplier = clusterApplier;
-        clusterManagerService.setClusterStateSupplier(this::getStateForClusterManagerService);
+        masterService.setClusterStateSupplier(this::getStateForClusterManagerService);
         this.reconfigurator = new Reconfigurator(settings, clusterSettings);
         this.clusterBootstrapService = new ClusterBootstrapService(
             settings,
@@ -310,7 +310,7 @@ private void onLeaderFailure(Exception e) {
     private void removeNode(DiscoveryNode discoveryNode, String reason) {
         synchronized (mutex) {
             if (mode == Mode.LEADER) {
-                clusterManagerService.submitStateUpdateTask(
+                masterService.submitStateUpdateTask(
                     "node-left",
                     new NodeRemovalClusterStateTaskExecutor.Task(discoveryNode, reason),
                     ClusterStateTaskConfig.build(Priority.IMMEDIATE),
@@ -756,7 +756,7 @@ void becomeFollower(String method, DiscoveryNode leaderNode) {
     }
 
     private void cleanClusterManagerService() {
-        clusterManagerService.submitStateUpdateTask("clean-up after stepping down as cluster-manager", new LocalClusterUpdateTask() {
+        masterService.submitStateUpdateTask("clean-up after stepping down as cluster-manager", new LocalClusterUpdateTask() {
             @Override
             public void onFailure(String source, Exception e) {
                 // ignore
@@ -1126,7 +1126,7 @@ private void scheduleReconfigurationIfNeeded() {
         final ClusterState state = getLastAcceptedState();
         if (improveConfiguration(state) != state && reconfigurationTaskScheduled.compareAndSet(false, true)) {
             logger.trace("scheduling reconfiguration");
-            clusterManagerService.submitStateUpdateTask("reconfigure", new ClusterStateUpdateTask(Priority.URGENT) {
+            masterService.submitStateUpdateTask("reconfigure", new ClusterStateUpdateTask(Priority.URGENT) {
                 @Override
                 public ClusterState execute(ClusterState currentState) {
                     reconfigurationTaskScheduled.set(false);
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java b/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
index 8ec215719b642..3accc4f1d5baf 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/JoinHelper.java
@@ -40,7 +40,7 @@
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateTaskConfig;
 import org.opensearch.cluster.ClusterStateTaskListener;
-import org.opensearch.cluster.NotMasterException;
+import org.opensearch.cluster.NotClusterManagerException;
 import org.opensearch.cluster.coordination.Coordinator.Mode;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
@@ -143,13 +143,13 @@ public class JoinHelper {
             @Override
             public ClusterTasksResult<JoinTaskExecutor.Task> execute(ClusterState currentState, List<JoinTaskExecutor.Task> joiningTasks)
                 throws Exception {
-                // The current state that MasterService uses might have been updated by a (different) cluster-manager in a higher term
-                // already
+                // The current state that ClusterManagerService uses might have been updated by a (different) cluster-manager
+                // in a higher term already
                 // Stop processing the current cluster state update, as there's no point in continuing to compute it as
                 // it will later be rejected by Coordinator.publish(...) anyhow
                 if (currentState.term() > term) {
                     logger.trace("encountered higher term {} than current {}, there is a newer cluster-manager", currentState.term(), term);
-                    throw new NotMasterException(
+                    throw new NotClusterManagerException(
                         "Higher term encountered (current: "
                             + currentState.term()
                             + " > used: "
@@ -284,7 +284,7 @@ static Level getLogLevel(TransportException e) {
             Throwable cause = e.unwrapCause();
             if (cause instanceof CoordinationStateRejectedException
                 || cause instanceof FailedToCommitClusterStateException
-                || cause instanceof NotMasterException) {
+                || cause instanceof NotClusterManagerException) {
                 return Level.DEBUG;
             }
             return Level.INFO;
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/JoinTaskExecutor.java b/server/src/main/java/org/opensearch/cluster/coordination/JoinTaskExecutor.java
index 766dd2d11b03e..629a016e0eab1 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/JoinTaskExecutor.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/JoinTaskExecutor.java
@@ -37,7 +37,7 @@
 import org.opensearch.action.ActionListener;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateTaskExecutor;
-import org.opensearch.cluster.NotMasterException;
+import org.opensearch.cluster.NotClusterManagerException;
 import org.opensearch.cluster.block.ClusterBlocks;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
@@ -156,7 +156,7 @@ public ClusterTasksResult<Task> execute(ClusterState currentState, List<Task> jo
                 "processing node joins, but we are not the cluster-manager. current cluster-manager: {}",
                 currentNodes.getMasterNode()
             );
-            throw new NotMasterException("Node [" + currentNodes.getLocalNode() + "] not cluster-manager for join request");
+            throw new NotClusterManagerException("Node [" + currentNodes.getLocalNode() + "] not cluster-manager for join request");
         } else {
             newState = ClusterState.builder(currentState);
         }
@@ -278,7 +278,9 @@ protected ClusterState.Builder becomeClusterManagerAndTrimConflictingNodes(Clust
         // or removed by us above
         ClusterState tmpState = ClusterState.builder(currentState)
             .nodes(nodesBuilder)
-            .blocks(ClusterBlocks.builder().blocks(currentState.blocks()).removeGlobalBlock(NoMasterBlockService.NO_MASTER_BLOCK_ID))
+            .blocks(
+                ClusterBlocks.builder().blocks(currentState.blocks()).removeGlobalBlock(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID)
+            )
             .build();
         logger.trace("becomeClusterManagerAndTrimConflictingNodes: {}", tmpState.nodes());
         allocationService.cleanCaches();
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/NoMasterBlockService.java b/server/src/main/java/org/opensearch/cluster/coordination/NoClusterManagerBlockService.java
similarity index 93%
rename from server/src/main/java/org/opensearch/cluster/coordination/NoMasterBlockService.java
rename to server/src/main/java/org/opensearch/cluster/coordination/NoClusterManagerBlockService.java
index c861456d66330..44ced46048736 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/NoMasterBlockService.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/NoClusterManagerBlockService.java
@@ -46,7 +46,7 @@
  *
  * @opensearch.internal
  */
-public class NoMasterBlockService {
+public class NoClusterManagerBlockService {
     public static final int NO_MASTER_BLOCK_ID = 2;
     public static final ClusterBlock NO_MASTER_BLOCK_WRITES = new ClusterBlock(
         NO_MASTER_BLOCK_ID,
@@ -79,7 +79,7 @@ public class NoMasterBlockService {
     public static final Setting<ClusterBlock> NO_MASTER_BLOCK_SETTING = new Setting<>(
         "cluster.no_master_block",
         "metadata_write",
-        NoMasterBlockService::parseNoClusterManagerBlock,
+        NoClusterManagerBlockService::parseNoClusterManagerBlock,
         Property.Dynamic,
         Property.NodeScope,
         Property.Deprecated
@@ -89,14 +89,14 @@ public class NoMasterBlockService {
     public static final Setting<ClusterBlock> NO_CLUSTER_MANAGER_BLOCK_SETTING = new Setting<>(
         "cluster.no_cluster_manager_block",
         NO_MASTER_BLOCK_SETTING,
-        NoMasterBlockService::parseNoClusterManagerBlock,
+        NoClusterManagerBlockService::parseNoClusterManagerBlock,
         Property.Dynamic,
         Property.NodeScope
     );
 
     private volatile ClusterBlock noClusterManagerBlock;
 
-    public NoMasterBlockService(Settings settings, ClusterSettings clusterSettings) {
+    public NoClusterManagerBlockService(Settings settings, ClusterSettings clusterSettings) {
         this.noClusterManagerBlock = NO_CLUSTER_MANAGER_BLOCK_SETTING.get(settings);
         clusterSettings.addSettingsUpdateConsumer(NO_CLUSTER_MANAGER_BLOCK_SETTING, this::setNoMasterBlock);
     }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/NodeToolCli.java b/server/src/main/java/org/opensearch/cluster/coordination/NodeToolCli.java
index 3db2171b4cca0..7d51002150fb9 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/NodeToolCli.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/NodeToolCli.java
@@ -39,7 +39,7 @@
 
 // NodeToolCli does not extend LoggingAwareCommand, because LoggingAwareCommand performs logging initialization
 // after LoggingAwareCommand instance is constructed.
-// It's too late for us, because before UnsafeBootstrapMasterCommand is added to the list of subcommands
+// It's too late for us, because before UnsafeBootstrapClusterManagerCommand is added to the list of subcommands
 // log4j2 initialization will happen, because it has static reference to Logger class.
 // Even if we avoid making a static reference to Logger class, there is no nice way to avoid declaring
 // UNSAFE_BOOTSTRAP, which depends on ClusterService, which in turn has static Logger.
@@ -56,7 +56,7 @@ public NodeToolCli() {
         super("A CLI tool to do unsafe cluster and index manipulations on current node", () -> {});
         CommandLoggingConfigurator.configureLoggingWithoutConfig();
         subcommands.put("repurpose", new NodeRepurposeCommand());
-        subcommands.put("unsafe-bootstrap", new UnsafeBootstrapMasterCommand());
+        subcommands.put("unsafe-bootstrap", new UnsafeBootstrapClusterManagerCommand());
         subcommands.put("detach-cluster", new DetachClusterCommand());
         subcommands.put("override-version", new OverrideNodeVersionCommand());
         subcommands.put("remove-settings", new RemoveSettingsCommand());
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/UnsafeBootstrapMasterCommand.java b/server/src/main/java/org/opensearch/cluster/coordination/UnsafeBootstrapClusterManagerCommand.java
similarity index 98%
rename from server/src/main/java/org/opensearch/cluster/coordination/UnsafeBootstrapMasterCommand.java
rename to server/src/main/java/org/opensearch/cluster/coordination/UnsafeBootstrapClusterManagerCommand.java
index 1f17844adf4fe..8506a59b22763 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/UnsafeBootstrapMasterCommand.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/UnsafeBootstrapClusterManagerCommand.java
@@ -59,7 +59,7 @@
  *
  * @opensearch.internal
  */
-public class UnsafeBootstrapMasterCommand extends OpenSearchNodeCommand {
+public class UnsafeBootstrapClusterManagerCommand extends OpenSearchNodeCommand {
 
     static final String CLUSTER_STATE_TERM_VERSION_MSG_FORMAT = "Current node cluster state (term, version) pair is (%s, %s)";
     static final String CONFIRMATION_MSG = DELIMITER
@@ -85,7 +85,7 @@ public class UnsafeBootstrapMasterCommand extends OpenSearchNodeCommand {
 
     private OptionSpec<Boolean> applyClusterReadOnlyBlockOption;
 
-    UnsafeBootstrapMasterCommand() {
+    UnsafeBootstrapClusterManagerCommand() {
         super(
             "Forces the successful election of the current node after the permanent loss of the half or more cluster-manager-eligible nodes"
         );
diff --git a/server/src/main/java/org/opensearch/cluster/routing/BatchedRerouteService.java b/server/src/main/java/org/opensearch/cluster/routing/BatchedRerouteService.java
index a3fa683acba6f..0738254823964 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/BatchedRerouteService.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/BatchedRerouteService.java
@@ -39,7 +39,7 @@
 import org.opensearch.action.ActionListener;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateUpdateTask;
-import org.opensearch.cluster.NotMasterException;
+import org.opensearch.cluster.NotClusterManagerException;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.Priority;
@@ -50,7 +50,7 @@
 
 /**
  * A {@link BatchedRerouteService} is a {@link RerouteService} that batches together reroute requests to avoid unnecessary extra reroutes.
- * This component only does meaningful work on the elected cluster-manager node. Reroute requests will fail with a {@link NotMasterException} on
+ * This component only does meaningful work on the elected cluster-manager node. Reroute requests will fail with a {@link NotClusterManagerException} on
  * other nodes.
  *
  * @opensearch.internal
@@ -147,7 +147,10 @@ public void onNoLongerMaster(String source) {
                             pendingRerouteListeners = null;
                         }
                     }
-                    ActionListener.onFailure(currentListeners, new NotMasterException("delayed reroute [" + reason + "] cancelled"));
+                    ActionListener.onFailure(
+                        currentListeners,
+                        new NotClusterManagerException("delayed reroute [" + reason + "] cancelled")
+                    );
                     // no big deal, the new cluster-manager will reroute again
                 }
 
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java b/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
index 76ac93d7d8d85..bc1397989dc96 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
@@ -41,7 +41,7 @@
 import org.opensearch.cluster.ClusterStateListener;
 import org.opensearch.cluster.ClusterStateObserver;
 import org.opensearch.cluster.ClusterStateTaskConfig;
-import org.opensearch.cluster.LocalNodeMasterListener;
+import org.opensearch.cluster.LocalNodeClusterManagerListener;
 import org.opensearch.cluster.NodeConnectionsService;
 import org.opensearch.cluster.TimeoutClusterStateListener;
 import org.opensearch.cluster.metadata.ProcessClusterEventTimeoutException;
@@ -277,7 +277,7 @@ public void removeTimeoutListener(TimeoutClusterStateListener listener) {
     /**
      * Add a listener for on/off local node cluster-manager events
      */
-    public void addLocalNodeMasterListener(LocalNodeMasterListener listener) {
+    public void addLocalNodeMasterListener(LocalNodeClusterManagerListener listener) {
         addListener(listener);
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterService.java b/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
index 3d643c96e65dc..baf453d18b3b3 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
@@ -39,7 +39,7 @@
 import org.opensearch.cluster.ClusterStateTaskConfig;
 import org.opensearch.cluster.ClusterStateTaskExecutor;
 import org.opensearch.cluster.ClusterStateTaskListener;
-import org.opensearch.cluster.LocalNodeMasterListener;
+import org.opensearch.cluster.LocalNodeClusterManagerListener;
 import org.opensearch.cluster.NodeConnectionsService;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.routing.OperationRouting;
@@ -214,7 +214,7 @@ public void removeListener(ClusterStateListener listener) {
     /**
      * Add a listener for on/off local node cluster-manager events
      */
-    public void addLocalNodeMasterListener(LocalNodeMasterListener listener) {
+    public void addLocalNodeMasterListener(LocalNodeClusterManagerListener listener) {
         clusterApplierService.addLocalNodeMasterListener(listener);
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/service/MasterService.java b/server/src/main/java/org/opensearch/cluster/service/MasterService.java
index 0f9106f6de0c9..2d52887858372 100644
--- a/server/src/main/java/org/opensearch/cluster/service/MasterService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/MasterService.java
@@ -825,7 +825,7 @@ private ClusterTasksResult<Object> executeTasks(TaskInputs taskInputs, ClusterSt
             if (previousClusterState != clusterTasksResult.resultingState
                 && previousClusterState.nodes().isLocalNodeElectedMaster()
                 && (clusterTasksResult.resultingState.nodes().isLocalNodeElectedMaster() == false)) {
-                throw new AssertionError("update task submitted to MasterService cannot remove master");
+                throw new AssertionError("update task submitted to ClusterManagerService cannot remove cluster-manager");
             }
         } catch (Exception e) {
             logger.trace(
diff --git a/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java b/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
index 617c5a9868409..4044d167f91be 100644
--- a/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
+++ b/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
@@ -63,7 +63,7 @@
 import org.opensearch.cluster.coordination.JoinHelper;
 import org.opensearch.cluster.coordination.LagDetector;
 import org.opensearch.cluster.coordination.LeaderChecker;
-import org.opensearch.cluster.coordination.NoMasterBlockService;
+import org.opensearch.cluster.coordination.NoClusterManagerBlockService;
 import org.opensearch.cluster.coordination.Reconfigurator;
 import org.opensearch.cluster.metadata.IndexGraveyard;
 import org.opensearch.cluster.metadata.Metadata;
@@ -274,8 +274,8 @@ public void apply(Settings value, Settings current, Settings previous) {
                 InternalClusterInfoService.INTERNAL_CLUSTER_INFO_TIMEOUT_SETTING,
                 InternalSnapshotsInfoService.INTERNAL_SNAPSHOT_INFO_MAX_CONCURRENT_FETCHES_SETTING,
                 DestructiveOperations.REQUIRES_NAME_SETTING,
-                NoMasterBlockService.NO_MASTER_BLOCK_SETTING,  // deprecated
-                NoMasterBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING,
+                NoClusterManagerBlockService.NO_MASTER_BLOCK_SETTING,  // deprecated
+                NoClusterManagerBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING,
                 GatewayService.EXPECTED_DATA_NODES_SETTING,
                 GatewayService.EXPECTED_MASTER_NODES_SETTING,
                 GatewayService.EXPECTED_NODES_SETTING,
diff --git a/server/src/main/java/org/opensearch/common/settings/ConsistentSettingsService.java b/server/src/main/java/org/opensearch/common/settings/ConsistentSettingsService.java
index e01a7919a4755..62000df33f0f1 100644
--- a/server/src/main/java/org/opensearch/common/settings/ConsistentSettingsService.java
+++ b/server/src/main/java/org/opensearch/common/settings/ConsistentSettingsService.java
@@ -36,7 +36,7 @@
 import org.apache.logging.log4j.Logger;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateUpdateTask;
-import org.opensearch.cluster.LocalNodeMasterListener;
+import org.opensearch.cluster.LocalNodeClusterManagerListener;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.Priority;
@@ -88,10 +88,10 @@ public ConsistentSettingsService(Settings settings, ClusterService clusterServic
     }
 
     /**
-     * Returns a {@link LocalNodeMasterListener} that will publish hashes of all the settings passed in the constructor. These hashes are
+     * Returns a {@link LocalNodeClusterManagerListener} that will publish hashes of all the settings passed in the constructor. These hashes are
      * published by the cluster-manager node only. Note that this is not designed for {@link SecureSettings} implementations that are mutable.
      */
-    public LocalNodeMasterListener newHashPublisher() {
+    public LocalNodeClusterManagerListener newHashPublisher() {
         // eagerly compute hashes to be published
         final Map<String, String> computedHashesOfConsistentSettings = computeHashesOfConsistentSecureSettings();
         return new HashesPublisher(computedHashesOfConsistentSettings, clusterService);
@@ -246,7 +246,7 @@ private byte[] computeSaltedPBKDF2Hash(byte[] bytes, byte[] salt) {
         }
     }
 
-    static final class HashesPublisher implements LocalNodeMasterListener {
+    static final class HashesPublisher implements LocalNodeClusterManagerListener {
 
         // eagerly compute hashes to be published
         final Map<String, String> computedHashesOfConsistentSettings;
diff --git a/server/src/main/java/org/opensearch/discovery/MasterNotDiscoveredException.java b/server/src/main/java/org/opensearch/discovery/ClusterManagerNotDiscoveredException.java
similarity index 82%
rename from server/src/main/java/org/opensearch/discovery/MasterNotDiscoveredException.java
rename to server/src/main/java/org/opensearch/discovery/ClusterManagerNotDiscoveredException.java
index dec50388b5624..1f2db95ed4203 100644
--- a/server/src/main/java/org/opensearch/discovery/MasterNotDiscoveredException.java
+++ b/server/src/main/java/org/opensearch/discovery/ClusterManagerNotDiscoveredException.java
@@ -43,17 +43,17 @@
  *
  * @opensearch.internal
  */
-public class MasterNotDiscoveredException extends OpenSearchException {
+public class ClusterManagerNotDiscoveredException extends OpenSearchException {
 
-    public MasterNotDiscoveredException() {
+    public ClusterManagerNotDiscoveredException() {
         super("");
     }
 
-    public MasterNotDiscoveredException(Throwable cause) {
+    public ClusterManagerNotDiscoveredException(Throwable cause) {
         super(cause);
     }
 
-    public MasterNotDiscoveredException(String message) {
+    public ClusterManagerNotDiscoveredException(String message) {
         super(message);
     }
 
@@ -62,7 +62,7 @@ public RestStatus status() {
         return RestStatus.SERVICE_UNAVAILABLE;
     }
 
-    public MasterNotDiscoveredException(StreamInput in) throws IOException {
+    public ClusterManagerNotDiscoveredException(StreamInput in) throws IOException {
         super(in);
     }
 }
diff --git a/server/src/main/java/org/opensearch/discovery/DiscoveryModule.java b/server/src/main/java/org/opensearch/discovery/DiscoveryModule.java
index c12283df1dbc9..6b746e5963bdc 100644
--- a/server/src/main/java/org/opensearch/discovery/DiscoveryModule.java
+++ b/server/src/main/java/org/opensearch/discovery/DiscoveryModule.java
@@ -121,7 +121,7 @@ public DiscoveryModule(
         TransportService transportService,
         NamedWriteableRegistry namedWriteableRegistry,
         NetworkService networkService,
-        MasterService clusterManagerService,
+        MasterService masterService,
         ClusterApplier clusterApplier,
         ClusterSettings clusterSettings,
         List<DiscoveryPlugin> plugins,
@@ -197,7 +197,7 @@ public DiscoveryModule(
                 transportService,
                 namedWriteableRegistry,
                 allocationService,
-                clusterManagerService,
+                masterService,
                 gatewayMetaState::getPersistedState,
                 seedHostsProvider,
                 clusterApplier,
diff --git a/server/src/main/java/org/opensearch/gateway/LocalAllocateDangledIndices.java b/server/src/main/java/org/opensearch/gateway/LocalAllocateDangledIndices.java
index fe0eacc244f32..98b3c104aadbf 100644
--- a/server/src/main/java/org/opensearch/gateway/LocalAllocateDangledIndices.java
+++ b/server/src/main/java/org/opensearch/gateway/LocalAllocateDangledIndices.java
@@ -53,7 +53,7 @@
 import org.opensearch.common.io.stream.StreamInput;
 import org.opensearch.common.io.stream.StreamOutput;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.discovery.MasterNotDiscoveredException;
+import org.opensearch.discovery.ClusterManagerNotDiscoveredException;
 import org.opensearch.tasks.Task;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportChannel;
@@ -110,7 +110,7 @@ public void allocateDangled(Collection<IndexMetadata> indices, ActionListener<Al
         ClusterState clusterState = clusterService.state();
         DiscoveryNode clusterManagerNode = clusterState.nodes().getMasterNode();
         if (clusterManagerNode == null) {
-            listener.onFailure(new MasterNotDiscoveredException("no cluster-manager to send allocate dangled request"));
+            listener.onFailure(new ClusterManagerNotDiscoveredException("no cluster-manager to send allocate dangled request"));
             return;
         }
         AllocateDangledRequest request = new AllocateDangledRequest(
diff --git a/server/src/main/java/org/opensearch/persistent/PersistentTasksClusterService.java b/server/src/main/java/org/opensearch/persistent/PersistentTasksClusterService.java
index b76fc1b93915e..b9cb03854829d 100644
--- a/server/src/main/java/org/opensearch/persistent/PersistentTasksClusterService.java
+++ b/server/src/main/java/org/opensearch/persistent/PersistentTasksClusterService.java
@@ -41,7 +41,7 @@
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateListener;
 import org.opensearch.cluster.ClusterStateUpdateTask;
-import org.opensearch.cluster.NotMasterException;
+import org.opensearch.cluster.NotClusterManagerException;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
@@ -381,7 +381,7 @@ public ClusterState execute(ClusterState currentState) {
             @Override
             public void onFailure(String source, Exception e) {
                 logger.warn("failed to reassign persistent tasks", e);
-                if (e instanceof NotMasterException == false) {
+                if (e instanceof NotClusterManagerException == false) {
                     // There must be a task that's worth rechecking because there was one
                     // that caused this method to be called and the method failed to assign it,
                     // but only do this if the node is still the master
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestMasterAction.java b/server/src/main/java/org/opensearch/rest/action/cat/RestClusterManagerAction.java
similarity index 97%
rename from server/src/main/java/org/opensearch/rest/action/cat/RestMasterAction.java
rename to server/src/main/java/org/opensearch/rest/action/cat/RestClusterManagerAction.java
index e54bcb39d9ec6..c1cf887884678 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestMasterAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestClusterManagerAction.java
@@ -53,9 +53,9 @@
  *
  * @opensearch.api
  */
-public class RestMasterAction extends AbstractCatAction {
+public class RestClusterManagerAction extends AbstractCatAction {
 
-    private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(RestMasterAction.class);
+    private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(RestClusterManagerAction.class);
 
     @Override
     public List<ReplacedRoute> replacedRoutes() {
diff --git a/server/src/main/java/org/opensearch/snapshots/SnapshotsService.java b/server/src/main/java/org/opensearch/snapshots/SnapshotsService.java
index dcedbc42aa6f5..c87bf33727524 100644
--- a/server/src/main/java/org/opensearch/snapshots/SnapshotsService.java
+++ b/server/src/main/java/org/opensearch/snapshots/SnapshotsService.java
@@ -56,7 +56,7 @@
 import org.opensearch.cluster.ClusterStateTaskExecutor;
 import org.opensearch.cluster.ClusterStateTaskListener;
 import org.opensearch.cluster.ClusterStateUpdateTask;
-import org.opensearch.cluster.NotMasterException;
+import org.opensearch.cluster.NotClusterManagerException;
 import org.opensearch.cluster.RepositoryCleanupInProgress;
 import org.opensearch.cluster.RestoreInProgress;
 import org.opensearch.cluster.SnapshotDeletionsInProgress;
@@ -1884,7 +1884,7 @@ private List<ActionListener<Tuple<RepositoryData, SnapshotInfo>>> endAndGetListe
      */
     private void handleFinalizationFailure(Exception e, SnapshotsInProgress.Entry entry, RepositoryData repositoryData) {
         Snapshot snapshot = entry.snapshot();
-        if (ExceptionsHelper.unwrap(e, NotMasterException.class, FailedToCommitClusterStateException.class) != null) {
+        if (ExceptionsHelper.unwrap(e, NotClusterManagerException.class, FailedToCommitClusterStateException.class) != null) {
             // Failure due to not being cluster-manager any more, don't try to remove snapshot from cluster state the next cluster-manager
             // will try ending this snapshot again
             logger.debug(() -> new ParameterizedMessage("[{}] failed to update cluster state during snapshot finalization", snapshot), e);
@@ -2094,7 +2094,7 @@ public void onFailure(String source, Exception e) {
             public void onNoLongerMaster(String source) {
                 failure.addSuppressed(new SnapshotException(snapshot, "no longer cluster-manager"));
                 failSnapshotCompletionListeners(snapshot, failure);
-                failAllListenersOnMasterFailOver(new NotMasterException(source));
+                failAllListenersOnMasterFailOver(new NotClusterManagerException(source));
                 if (listener != null) {
                     listener.onNoLongerMaster();
                 }
@@ -2306,7 +2306,7 @@ public void clusterStateProcessed(String source, ClusterState oldState, ClusterS
                         createDeleteStateUpdate(outstandingDeletes, repoName, result.v1(), Priority.IMMEDIATE, listener)
                     );
                 }, e -> {
-                    if (ExceptionsHelper.unwrap(e, NotMasterException.class, FailedToCommitClusterStateException.class) != null) {
+                    if (ExceptionsHelper.unwrap(e, NotClusterManagerException.class, FailedToCommitClusterStateException.class) != null) {
                         logger.warn("cluster-manager failover before deleted snapshot could complete", e);
                         // Just pass the exception to the transport handler as is so it is retried on the new cluster-manager
                         listener.onFailure(e);
@@ -2788,7 +2788,7 @@ protected void handleListeners(List<ActionListener<Void>> deleteListeners) {
     private void failAllListenersOnMasterFailOver(Exception e) {
         logger.debug("Failing all snapshot operation listeners because this node is not cluster-manager any longer", e);
         synchronized (currentlyFinalizing) {
-            if (ExceptionsHelper.unwrap(e, NotMasterException.class, FailedToCommitClusterStateException.class) != null) {
+            if (ExceptionsHelper.unwrap(e, NotClusterManagerException.class, FailedToCommitClusterStateException.class) != null) {
                 repositoryOperations.clear();
                 for (Snapshot snapshot : new HashSet<>(snapshotCompletionListeners.keySet())) {
                     failSnapshotCompletionListeners(snapshot, new SnapshotException(snapshot, "no longer cluster-manager"));
diff --git a/server/src/test/java/org/opensearch/ExceptionSerializationTests.java b/server/src/test/java/org/opensearch/ExceptionSerializationTests.java
index 888e855176fe6..c0dfef3ecf9d6 100644
--- a/server/src/test/java/org/opensearch/ExceptionSerializationTests.java
+++ b/server/src/test/java/org/opensearch/ExceptionSerializationTests.java
@@ -47,7 +47,7 @@
 import org.opensearch.cluster.action.shard.ShardStateAction;
 import org.opensearch.cluster.block.ClusterBlockException;
 import org.opensearch.cluster.coordination.CoordinationStateRejectedException;
-import org.opensearch.cluster.coordination.NoMasterBlockService;
+import org.opensearch.cluster.coordination.NoClusterManagerBlockService;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.routing.IllegalShardRoutingStateException;
 import org.opensearch.cluster.routing.ShardRouting;
@@ -510,9 +510,9 @@ public void testFailedNodeException() throws IOException {
     }
 
     public void testClusterBlockException() throws IOException {
-        ClusterBlockException ex = serialize(new ClusterBlockException(singleton(NoMasterBlockService.NO_MASTER_BLOCK_WRITES)));
+        ClusterBlockException ex = serialize(new ClusterBlockException(singleton(NoClusterManagerBlockService.NO_MASTER_BLOCK_WRITES)));
         assertEquals("blocked by: [SERVICE_UNAVAILABLE/2/no cluster-manager];", ex.getMessage());
-        assertTrue(ex.blocks().contains(NoMasterBlockService.NO_MASTER_BLOCK_WRITES));
+        assertTrue(ex.blocks().contains(NoClusterManagerBlockService.NO_MASTER_BLOCK_WRITES));
         assertEquals(1, ex.blocks().size());
     }
 
@@ -694,7 +694,7 @@ public void testIds() {
         ids.put(0, org.opensearch.index.snapshots.IndexShardSnapshotFailedException.class);
         ids.put(1, org.opensearch.search.dfs.DfsPhaseExecutionException.class);
         ids.put(2, org.opensearch.common.util.CancellableThreads.ExecutionCancelledException.class);
-        ids.put(3, org.opensearch.discovery.MasterNotDiscoveredException.class);
+        ids.put(3, org.opensearch.discovery.ClusterManagerNotDiscoveredException.class);
         ids.put(4, org.opensearch.OpenSearchSecurityException.class);
         ids.put(5, org.opensearch.index.snapshots.IndexShardRestoreException.class);
         ids.put(6, org.opensearch.indices.IndexClosedException.class);
@@ -832,7 +832,7 @@ public void testIds() {
         ids.put(141, org.opensearch.index.query.QueryShardException.class);
         ids.put(142, ShardStateAction.NoLongerPrimaryShardException.class);
         ids.put(143, org.opensearch.script.ScriptException.class);
-        ids.put(144, org.opensearch.cluster.NotMasterException.class);
+        ids.put(144, org.opensearch.cluster.NotClusterManagerException.class);
         ids.put(145, org.opensearch.OpenSearchStatusException.class);
         ids.put(146, org.opensearch.tasks.TaskCancelledException.class);
         ids.put(147, org.opensearch.env.ShardLockObtainFailedException.class);
diff --git a/server/src/test/java/org/opensearch/OpenSearchExceptionTests.java b/server/src/test/java/org/opensearch/OpenSearchExceptionTests.java
index 31c2d77370941..ca2940c742ec0 100644
--- a/server/src/test/java/org/opensearch/OpenSearchExceptionTests.java
+++ b/server/src/test/java/org/opensearch/OpenSearchExceptionTests.java
@@ -41,7 +41,7 @@
 import org.opensearch.action.support.broadcast.BroadcastShardOperationFailedException;
 import org.opensearch.client.transport.NoNodeAvailableException;
 import org.opensearch.cluster.block.ClusterBlockException;
-import org.opensearch.cluster.coordination.NoMasterBlockService;
+import org.opensearch.cluster.coordination.NoClusterManagerBlockService;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.ParsingException;
 import org.opensearch.common.Strings;
@@ -478,7 +478,7 @@ public void testToXContentWithHeadersAndMetadata() throws IOException {
             "foo",
             new OpenSearchException(
                 "bar",
-                new OpenSearchException("baz", new ClusterBlockException(singleton(NoMasterBlockService.NO_MASTER_BLOCK_WRITES)))
+                new OpenSearchException("baz", new ClusterBlockException(singleton(NoClusterManagerBlockService.NO_MASTER_BLOCK_WRITES)))
             )
         );
         e.addHeader("foo_0", "0");
@@ -1032,7 +1032,7 @@ public static Tuple<Throwable, OpenSearchException> randomExceptions() {
         int type = randomIntBetween(0, 5);
         switch (type) {
             case 0:
-                actual = new ClusterBlockException(singleton(NoMasterBlockService.NO_MASTER_BLOCK_WRITES));
+                actual = new ClusterBlockException(singleton(NoClusterManagerBlockService.NO_MASTER_BLOCK_WRITES));
                 expected = new OpenSearchException(
                     "OpenSearch exception [type=cluster_block_exception, "
                         + "reason=blocked by: [SERVICE_UNAVAILABLE/2/no cluster-manager];]"
diff --git a/server/src/test/java/org/opensearch/action/RenamedTimeoutRequestParameterTests.java b/server/src/test/java/org/opensearch/action/RenamedTimeoutRequestParameterTests.java
index 7669dcf38e6e9..cac33ac3a6128 100644
--- a/server/src/test/java/org/opensearch/action/RenamedTimeoutRequestParameterTests.java
+++ b/server/src/test/java/org/opensearch/action/RenamedTimeoutRequestParameterTests.java
@@ -68,7 +68,7 @@
 import org.opensearch.rest.action.cat.RestAllocationAction;
 import org.opensearch.rest.action.cat.RestRepositoriesAction;
 import org.opensearch.rest.action.cat.RestThreadPoolAction;
-import org.opensearch.rest.action.cat.RestMasterAction;
+import org.opensearch.rest.action.cat.RestClusterManagerAction;
 import org.opensearch.rest.action.cat.RestShardsAction;
 import org.opensearch.rest.action.cat.RestPluginsAction;
 import org.opensearch.rest.action.cat.RestNodeAttrsAction;
@@ -134,7 +134,7 @@ public void testCatIndices() {
     }
 
     public void testCatClusterManager() {
-        RestMasterAction action = new RestMasterAction();
+        RestClusterManagerAction action = new RestClusterManagerAction();
         Exception e = assertThrows(OpenSearchParseException.class, () -> action.doCatRequest(getRestRequestWithBothParams(), client));
         assertThat(e.getMessage(), containsString(DUPLICATE_PARAMETER_ERROR_MESSAGE));
     }
diff --git a/server/src/test/java/org/opensearch/action/resync/TransportResyncReplicationActionTests.java b/server/src/test/java/org/opensearch/action/resync/TransportResyncReplicationActionTests.java
index a544bad4cd9e6..91d780e218e71 100644
--- a/server/src/test/java/org/opensearch/action/resync/TransportResyncReplicationActionTests.java
+++ b/server/src/test/java/org/opensearch/action/resync/TransportResyncReplicationActionTests.java
@@ -38,7 +38,7 @@
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.action.shard.ShardStateAction;
 import org.opensearch.cluster.block.ClusterBlocks;
-import org.opensearch.cluster.coordination.NoMasterBlockService;
+import org.opensearch.cluster.coordination.NoClusterManagerBlockService;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.routing.IndexShardRoutingTable;
 import org.opensearch.cluster.routing.ShardRouting;
@@ -116,7 +116,7 @@ public void testResyncDoesNotBlockOnPrimaryAction() throws Exception {
                 ClusterState.builder(clusterService.state())
                     .blocks(
                         ClusterBlocks.builder()
-                            .addGlobalBlock(NoMasterBlockService.NO_MASTER_BLOCK_ALL)
+                            .addGlobalBlock(NoClusterManagerBlockService.NO_MASTER_BLOCK_ALL)
                             .addIndexBlock(indexName, IndexMetadata.INDEX_WRITE_BLOCK)
                     )
             );
diff --git a/server/src/test/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeActionTests.java b/server/src/test/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeActionTests.java
index a5828edd65c16..acfdf7982e9d0 100644
--- a/server/src/test/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeActionTests.java
+++ b/server/src/test/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeActionTests.java
@@ -42,7 +42,7 @@
 import org.opensearch.action.support.ThreadedActionListener;
 import org.opensearch.action.support.replication.ClusterStateCreationUtils;
 import org.opensearch.cluster.ClusterState;
-import org.opensearch.cluster.NotMasterException;
+import org.opensearch.cluster.NotClusterManagerException;
 import org.opensearch.cluster.block.ClusterBlock;
 import org.opensearch.cluster.block.ClusterBlockException;
 import org.opensearch.cluster.block.ClusterBlockLevel;
@@ -58,7 +58,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.ThreadContext;
-import org.opensearch.discovery.MasterNotDiscoveredException;
+import org.opensearch.discovery.ClusterManagerNotDiscoveredException;
 import org.opensearch.node.NodeClosedException;
 import org.opensearch.rest.RestStatus;
 import org.opensearch.tasks.Task;
@@ -314,7 +314,7 @@ protected ClusterBlockException checkBlock(Request request, ClusterState state)
                 listener.get();
                 fail("Expected exception but returned proper result");
             } catch (ExecutionException ex) {
-                assertThat(ex.getCause(), instanceOf(MasterNotDiscoveredException.class));
+                assertThat(ex.getCause(), instanceOf(ClusterManagerNotDiscoveredException.class));
                 assertThat(ex.getCause().getCause(), instanceOf(ClusterBlockException.class));
             }
         } else {
@@ -382,7 +382,7 @@ public void testClusterManagerNotAvailable() throws ExecutionException, Interrup
         PlainActionFuture<Response> listener = new PlainActionFuture<>();
         new Action("internal:testAction", transportService, clusterService, threadPool).execute(request, listener);
         assertTrue(listener.isDone());
-        assertListenerThrows("MasterNotDiscoveredException should be thrown", listener, MasterNotDiscoveredException.class);
+        assertListenerThrows("ClusterManagerNotDiscoveredException should be thrown", listener, ClusterManagerNotDiscoveredException.class);
     }
 
     public void testClusterManagerBecomesAvailable() throws ExecutionException, InterruptedException {
@@ -517,7 +517,7 @@ protected void masterOperation(Request request, ClusterState state, ActionListen
                 setState(clusterService, ClusterStateCreationUtils.state(localNode, remoteNode, allNodes));
                 Exception failure = randomBoolean()
                     ? new FailedToCommitClusterStateException("Fake error")
-                    : new NotMasterException("Fake error");
+                    : new NotClusterManagerException("Fake error");
                 listener.onFailure(failure);
             }
         }.execute(request, listener);
diff --git a/server/src/test/java/org/opensearch/cluster/InternalClusterInfoServiceSchedulingTests.java b/server/src/test/java/org/opensearch/cluster/InternalClusterInfoServiceSchedulingTests.java
index 251703a933525..7f09f1eb8e2be 100644
--- a/server/src/test/java/org/opensearch/cluster/InternalClusterInfoServiceSchedulingTests.java
+++ b/server/src/test/java/org/opensearch/cluster/InternalClusterInfoServiceSchedulingTests.java
@@ -42,7 +42,7 @@
 import org.opensearch.cluster.block.ClusterBlockException;
 import org.opensearch.cluster.coordination.DeterministicTaskQueue;
 import org.opensearch.cluster.coordination.MockSinglePrioritizingExecutor;
-import org.opensearch.cluster.coordination.NoMasterBlockService;
+import org.opensearch.cluster.coordination.NoClusterManagerBlockService;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.service.ClusterApplier;
@@ -87,14 +87,14 @@ protected PrioritizedOpenSearchThreadPoolExecutor createThreadPoolExecutor() {
             }
         };
 
-        final MasterService clusterManagerService = new FakeThreadPoolMasterService(
+        final MasterService masterService = new FakeThreadPoolMasterService(
             "test",
             "clusterManagerService",
             threadPool,
             r -> { fail("cluster-manager service should not run any tasks"); }
         );
 
-        final ClusterService clusterService = new ClusterService(settings, clusterSettings, clusterManagerService, clusterApplierService);
+        final ClusterService clusterService = new ClusterService(settings, clusterSettings, masterService, clusterApplierService);
 
         final FakeClusterInfoServiceClient client = new FakeClusterInfoServiceClient(threadPool);
         final InternalClusterInfoService clusterInfoService = new InternalClusterInfoService(settings, clusterService, threadPool, client);
@@ -103,8 +103,8 @@ protected PrioritizedOpenSearchThreadPoolExecutor createThreadPoolExecutor() {
 
         clusterService.setNodeConnectionsService(ClusterServiceUtils.createNoOpNodeConnectionsService());
         clusterApplierService.setInitialState(ClusterState.builder(new ClusterName("cluster")).nodes(noClusterManager).build());
-        clusterManagerService.setClusterStatePublisher((clusterChangedEvent, publishListener, ackListener) -> fail("should not publish"));
-        clusterManagerService.setClusterStateSupplier(clusterApplierService::state);
+        masterService.setClusterStatePublisher((clusterChangedEvent, publishListener, ackListener) -> fail("should not publish"));
+        masterService.setClusterStateSupplier(clusterApplierService::state);
         clusterService.start();
 
         final AtomicBoolean becameClusterManager1 = new AtomicBoolean();
@@ -208,7 +208,7 @@ protected <Request extends ActionRequest, Response extends ActionResponse> void
                 requestCount++;
                 // ClusterInfoService handles ClusterBlockExceptions quietly, so we invent such an exception to avoid excess logging
                 listener.onFailure(
-                    new ClusterBlockException(org.opensearch.common.collect.Set.of(NoMasterBlockService.NO_MASTER_BLOCK_ALL))
+                    new ClusterBlockException(org.opensearch.common.collect.Set.of(NoClusterManagerBlockService.NO_MASTER_BLOCK_ALL))
                 );
             } else {
                 fail("unexpected action: " + action.name());
diff --git a/server/src/test/java/org/opensearch/cluster/action/shard/ShardStateActionTests.java b/server/src/test/java/org/opensearch/cluster/action/shard/ShardStateActionTests.java
index cf34af718c660..a61d878d90c7c 100644
--- a/server/src/test/java/org/opensearch/cluster/action/shard/ShardStateActionTests.java
+++ b/server/src/test/java/org/opensearch/cluster/action/shard/ShardStateActionTests.java
@@ -39,7 +39,7 @@
 import org.opensearch.action.support.replication.ClusterStateCreationUtils;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateObserver;
-import org.opensearch.cluster.NotMasterException;
+import org.opensearch.cluster.NotClusterManagerException;
 import org.opensearch.cluster.action.shard.ShardStateAction.FailedShardEntry;
 import org.opensearch.cluster.action.shard.ShardStateAction.StartedShardEntry;
 import org.opensearch.cluster.coordination.FailedToCommitClusterStateException;
@@ -256,7 +256,7 @@ public void testClusterManagerChannelException() throws InterruptedException {
             if (randomBoolean()) {
                 transport.handleRemoteError(
                     requestId,
-                    randomFrom(new NotMasterException("simulated"), new FailedToCommitClusterStateException("simulated"))
+                    randomFrom(new NotClusterManagerException("simulated"), new FailedToCommitClusterStateException("simulated"))
                 );
             } else {
                 if (randomBoolean()) {
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/CoordinatorTests.java b/server/src/test/java/org/opensearch/cluster/coordination/CoordinatorTests.java
index 44239fdc0883f..b9ae08775d11a 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/CoordinatorTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/CoordinatorTests.java
@@ -82,10 +82,10 @@
 import static org.opensearch.cluster.coordination.LeaderChecker.LEADER_CHECK_INTERVAL_SETTING;
 import static org.opensearch.cluster.coordination.LeaderChecker.LEADER_CHECK_RETRY_COUNT_SETTING;
 import static org.opensearch.cluster.coordination.LeaderChecker.LEADER_CHECK_TIMEOUT_SETTING;
-import static org.opensearch.cluster.coordination.NoMasterBlockService.NO_MASTER_BLOCK_ALL;
-import static org.opensearch.cluster.coordination.NoMasterBlockService.NO_MASTER_BLOCK_METADATA_WRITES;
-import static org.opensearch.cluster.coordination.NoMasterBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING;
-import static org.opensearch.cluster.coordination.NoMasterBlockService.NO_MASTER_BLOCK_WRITES;
+import static org.opensearch.cluster.coordination.NoClusterManagerBlockService.NO_MASTER_BLOCK_ALL;
+import static org.opensearch.cluster.coordination.NoClusterManagerBlockService.NO_MASTER_BLOCK_METADATA_WRITES;
+import static org.opensearch.cluster.coordination.NoClusterManagerBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING;
+import static org.opensearch.cluster.coordination.NoClusterManagerBlockService.NO_MASTER_BLOCK_WRITES;
 import static org.opensearch.cluster.coordination.Reconfigurator.CLUSTER_AUTO_SHRINK_VOTING_CONFIGURATION;
 import static org.opensearch.discovery.PeerFinder.DISCOVERY_FIND_PEERS_INTERVAL_SETTING;
 import static org.opensearch.monitor.StatusInfo.Status.HEALTHY;
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/JoinHelperTests.java b/server/src/test/java/org/opensearch/cluster/coordination/JoinHelperTests.java
index b53cf9ddf1dd2..a3c945cdbac3a 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/JoinHelperTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/JoinHelperTests.java
@@ -37,7 +37,7 @@
 import org.opensearch.action.support.PlainActionFuture;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
-import org.opensearch.cluster.NotMasterException;
+import org.opensearch.cluster.NotClusterManagerException;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.settings.Settings;
@@ -186,7 +186,7 @@ public void testFailedJoinAttemptLogLevel() {
 
         assertThat(
             JoinHelper.FailedJoinAttempt.getLogLevel(
-                new RemoteTransportException("caused by NotMasterException", new NotMasterException("test"))
+                new RemoteTransportException("caused by NotClusterManagerException", new NotClusterManagerException("test"))
             ),
             is(Level.DEBUG)
         );
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/NoMasterBlockServiceRenamedSettingTests.java b/server/src/test/java/org/opensearch/cluster/coordination/NoClusterManagerBlockServiceRenamedSettingTests.java
similarity index 62%
rename from server/src/test/java/org/opensearch/cluster/coordination/NoMasterBlockServiceRenamedSettingTests.java
rename to server/src/test/java/org/opensearch/cluster/coordination/NoClusterManagerBlockServiceRenamedSettingTests.java
index 2c988cad5f79c..42a230d05cbd4 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/NoMasterBlockServiceRenamedSettingTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/NoClusterManagerBlockServiceRenamedSettingTests.java
@@ -21,7 +21,7 @@
  * after it is deprecated, so that the backwards compatibility is maintained.
  * The test can be removed along with removing support of the deprecated setting.
  */
-public class NoMasterBlockServiceRenamedSettingTests extends OpenSearchTestCase {
+public class NoClusterManagerBlockServiceRenamedSettingTests extends OpenSearchTestCase {
 
     /**
      * Validate the both settings are known and supported.
@@ -31,7 +31,10 @@ public void testReindexSettingsExist() {
         assertTrue(
             "Both 'cluster.no_cluster_manager_block' and its predecessor should be supported built-in settings.",
             settings.containsAll(
-                Arrays.asList(NoMasterBlockService.NO_MASTER_BLOCK_SETTING, NoMasterBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING)
+                Arrays.asList(
+                    NoClusterManagerBlockService.NO_MASTER_BLOCK_SETTING,
+                    NoClusterManagerBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING
+                )
             )
         );
     }
@@ -41,8 +44,8 @@ public void testReindexSettingsExist() {
      */
     public void testSettingFallback() {
         assertEquals(
-            NoMasterBlockService.NO_MASTER_BLOCK_SETTING.get(Settings.EMPTY),
-            NoMasterBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.get(Settings.EMPTY)
+            NoClusterManagerBlockService.NO_MASTER_BLOCK_SETTING.get(Settings.EMPTY),
+            NoClusterManagerBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.get(Settings.EMPTY)
 
         );
     }
@@ -52,10 +55,13 @@ public void testSettingFallback() {
      */
     public void testSettingGetValue() {
         Settings settings = Settings.builder().put("cluster.no_cluster_manager_block", "all").build();
-        assertEquals(NoMasterBlockService.NO_MASTER_BLOCK_ALL, NoMasterBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.get(settings));
         assertEquals(
-            NoMasterBlockService.NO_MASTER_BLOCK_SETTING.getDefault(Settings.EMPTY),
-            NoMasterBlockService.NO_MASTER_BLOCK_SETTING.get(settings)
+            NoClusterManagerBlockService.NO_MASTER_BLOCK_ALL,
+            NoClusterManagerBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.get(settings)
+        );
+        assertEquals(
+            NoClusterManagerBlockService.NO_MASTER_BLOCK_SETTING.getDefault(Settings.EMPTY),
+            NoClusterManagerBlockService.NO_MASTER_BLOCK_SETTING.get(settings)
         );
     }
 
@@ -65,10 +71,10 @@ public void testSettingGetValue() {
     public void testSettingGetValueWithFallback() {
         Settings settings = Settings.builder().put("cluster.no_master_block", "metadata_write").build();
         assertEquals(
-            NoMasterBlockService.NO_MASTER_BLOCK_METADATA_WRITES,
-            NoMasterBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.get(settings)
+            NoClusterManagerBlockService.NO_MASTER_BLOCK_METADATA_WRITES,
+            NoClusterManagerBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.get(settings)
         );
-        assertSettingDeprecationsAndWarnings(new Setting<?>[] { NoMasterBlockService.NO_MASTER_BLOCK_SETTING });
+        assertSettingDeprecationsAndWarnings(new Setting<?>[] { NoClusterManagerBlockService.NO_MASTER_BLOCK_SETTING });
     }
 
     /**
@@ -79,9 +85,15 @@ public void testSettingGetValueWhenBothAreConfigured() {
             .put("cluster.no_cluster_manager_block", "all")
             .put("cluster.no_master_block", "metadata_write")
             .build();
-        assertEquals(NoMasterBlockService.NO_MASTER_BLOCK_ALL, NoMasterBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.get(settings));
-        assertEquals(NoMasterBlockService.NO_MASTER_BLOCK_METADATA_WRITES, NoMasterBlockService.NO_MASTER_BLOCK_SETTING.get(settings));
-        assertSettingDeprecationsAndWarnings(new Setting<?>[] { NoMasterBlockService.NO_MASTER_BLOCK_SETTING });
+        assertEquals(
+            NoClusterManagerBlockService.NO_MASTER_BLOCK_ALL,
+            NoClusterManagerBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.get(settings)
+        );
+        assertEquals(
+            NoClusterManagerBlockService.NO_MASTER_BLOCK_METADATA_WRITES,
+            NoClusterManagerBlockService.NO_MASTER_BLOCK_SETTING.get(settings)
+        );
+        assertSettingDeprecationsAndWarnings(new Setting<?>[] { NoClusterManagerBlockService.NO_MASTER_BLOCK_SETTING });
     }
 
 }
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/NoMasterBlockServiceTests.java b/server/src/test/java/org/opensearch/cluster/coordination/NoClusterManagerBlockServiceTests.java
similarity index 85%
rename from server/src/test/java/org/opensearch/cluster/coordination/NoMasterBlockServiceTests.java
rename to server/src/test/java/org/opensearch/cluster/coordination/NoClusterManagerBlockServiceTests.java
index ed8027dc8e838..b9a72e00aebb0 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/NoMasterBlockServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/NoClusterManagerBlockServiceTests.java
@@ -35,21 +35,21 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.test.OpenSearchTestCase;
 
-import static org.opensearch.cluster.coordination.NoMasterBlockService.NO_MASTER_BLOCK_ALL;
-import static org.opensearch.cluster.coordination.NoMasterBlockService.NO_MASTER_BLOCK_METADATA_WRITES;
-import static org.opensearch.cluster.coordination.NoMasterBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING;
-import static org.opensearch.cluster.coordination.NoMasterBlockService.NO_MASTER_BLOCK_WRITES;
+import static org.opensearch.cluster.coordination.NoClusterManagerBlockService.NO_MASTER_BLOCK_ALL;
+import static org.opensearch.cluster.coordination.NoClusterManagerBlockService.NO_MASTER_BLOCK_METADATA_WRITES;
+import static org.opensearch.cluster.coordination.NoClusterManagerBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING;
+import static org.opensearch.cluster.coordination.NoClusterManagerBlockService.NO_MASTER_BLOCK_WRITES;
 import static org.opensearch.common.settings.ClusterSettings.BUILT_IN_CLUSTER_SETTINGS;
 import static org.hamcrest.Matchers.sameInstance;
 
-public class NoMasterBlockServiceTests extends OpenSearchTestCase {
+public class NoClusterManagerBlockServiceTests extends OpenSearchTestCase {
 
-    private NoMasterBlockService noClusterManagerBlockService;
+    private NoClusterManagerBlockService noClusterManagerBlockService;
     private ClusterSettings clusterSettings;
 
     private void createService(Settings settings) {
         clusterSettings = new ClusterSettings(settings, BUILT_IN_CLUSTER_SETTINGS);
-        noClusterManagerBlockService = new NoMasterBlockService(settings, clusterSettings);
+        noClusterManagerBlockService = new NoClusterManagerBlockService(settings, clusterSettings);
     }
 
     private void assertDeprecatedWarningEmitted() {
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/NodeJoinTests.java b/server/src/test/java/org/opensearch/cluster/coordination/NodeJoinTests.java
index 2cf8c2c13d3b6..806468ed5e761 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/NodeJoinTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/NodeJoinTests.java
@@ -98,7 +98,7 @@ public class NodeJoinTests extends OpenSearchTestCase {
 
     private static ThreadPool threadPool;
 
-    private MasterService clusterManagerService;
+    private MasterService masterService;
     private Coordinator coordinator;
     private DeterministicTaskQueue deterministicTaskQueue;
     private Transport transport;
@@ -117,7 +117,7 @@ public static void afterClass() {
     @After
     public void tearDown() throws Exception {
         super.tearDown();
-        clusterManagerService.close();
+        masterService.close();
     }
 
     private static ClusterState initialState(DiscoveryNode localNode, long term, long version, VotingConfiguration config) {
@@ -166,40 +166,40 @@ private void setupFakeClusterManagerServiceAndCoordinator(long term, ClusterStat
     }
 
     private void setupRealClusterManagerServiceAndCoordinator(long term, ClusterState initialState) {
-        MasterService clusterManagerService = new MasterService(
+        MasterService masterService = new MasterService(
             Settings.builder().put(Node.NODE_NAME_SETTING.getKey(), "test_node").build(),
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             threadPool
         );
         AtomicReference<ClusterState> clusterStateRef = new AtomicReference<>(initialState);
-        clusterManagerService.setClusterStatePublisher((event, publishListener, ackListener) -> {
+        masterService.setClusterStatePublisher((event, publishListener, ackListener) -> {
             clusterStateRef.set(event.state());
             publishListener.onResponse(null);
         });
         setupClusterManagerServiceAndCoordinator(
             term,
             initialState,
-            clusterManagerService,
+            masterService,
             threadPool,
             new Random(Randomness.get().nextLong()),
             () -> new StatusInfo(HEALTHY, "healthy-info")
         );
-        clusterManagerService.setClusterStateSupplier(clusterStateRef::get);
-        clusterManagerService.start();
+        masterService.setClusterStateSupplier(clusterStateRef::get);
+        masterService.start();
     }
 
     private void setupClusterManagerServiceAndCoordinator(
         long term,
         ClusterState initialState,
-        MasterService clusterManagerService,
+        MasterService masterService,
         ThreadPool threadPool,
         Random random,
         NodeHealthService nodeHealthService
     ) {
-        if (this.clusterManagerService != null || coordinator != null) {
-            throw new IllegalStateException("method setupMasterServiceAndCoordinator can only be called once");
+        if (this.masterService != null || coordinator != null) {
+            throw new IllegalStateException("method setupClusterManagerServiceAndCoordinator can only be called once");
         }
-        this.clusterManagerService = clusterManagerService;
+        this.masterService = masterService;
         CapturingTransport capturingTransport = new CapturingTransport() {
             @Override
             protected void onSendRequest(long requestId, String action, TransportRequest request, DiscoveryNode destination) {
@@ -231,7 +231,7 @@ protected void onSendRequest(long requestId, String action, TransportRequest req
             transportService,
             writableRegistry(),
             OpenSearchAllocationTestCase.createAllocationService(Settings.EMPTY),
-            clusterManagerService,
+            masterService,
             () -> new InMemoryPersistedState(term, initialState),
             r -> emptyList(),
             new NoOpClusterApplier(),
@@ -514,7 +514,7 @@ public void testJoinUpdateVotingConfigExclusion() throws Exception {
         );
 
         assertTrue(
-            MasterServiceTests.discoveryState(clusterManagerService)
+            MasterServiceTests.discoveryState(masterService)
                 .getVotingConfigExclusions()
                 .stream()
                 .anyMatch(
@@ -746,7 +746,7 @@ public void testConcurrentJoining() {
             throw new RuntimeException(e);
         }
 
-        assertTrue(MasterServiceTests.discoveryState(clusterManagerService).nodes().isLocalNodeElectedMaster());
+        assertTrue(MasterServiceTests.discoveryState(masterService).nodes().isLocalNodeElectedMaster());
         for (DiscoveryNode successfulNode : successfulNodes) {
             assertTrue(successfulNode + " joined cluster", clusterStateHasNode(successfulNode));
             assertFalse(successfulNode + " voted for cluster-manager", coordinator.missingJoinVoteFrom(successfulNode));
@@ -776,10 +776,10 @@ public void testJoinElectedLeaderWithDeprecatedMasterRole() {
     }
 
     private boolean isLocalNodeElectedMaster() {
-        return MasterServiceTests.discoveryState(clusterManagerService).nodes().isLocalNodeElectedMaster();
+        return MasterServiceTests.discoveryState(masterService).nodes().isLocalNodeElectedMaster();
     }
 
     private boolean clusterStateHasNode(DiscoveryNode node) {
-        return node.equals(MasterServiceTests.discoveryState(clusterManagerService).nodes().get(node.getId()));
+        return node.equals(MasterServiceTests.discoveryState(masterService).nodes().get(node.getId()));
     }
 }
diff --git a/server/src/test/java/org/opensearch/cluster/service/ClusterApplierServiceTests.java b/server/src/test/java/org/opensearch/cluster/service/ClusterApplierServiceTests.java
index 8a7e14c63d3b0..166fb7a935009 100644
--- a/server/src/test/java/org/opensearch/cluster/service/ClusterApplierServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/service/ClusterApplierServiceTests.java
@@ -38,9 +38,9 @@
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateObserver;
-import org.opensearch.cluster.LocalNodeMasterListener;
+import org.opensearch.cluster.LocalNodeClusterManagerListener;
 import org.opensearch.cluster.block.ClusterBlocks;
-import org.opensearch.cluster.coordination.NoMasterBlockService;
+import org.opensearch.cluster.coordination.NoClusterManagerBlockService;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
@@ -296,7 +296,7 @@ public void testLocalNodeClusterManagerListenerCallbacks() {
         TimedClusterApplierService timedClusterApplierService = createTimedClusterService(false);
 
         AtomicBoolean isClusterManager = new AtomicBoolean();
-        timedClusterApplierService.addLocalNodeMasterListener(new LocalNodeMasterListener() {
+        timedClusterApplierService.addLocalNodeMasterListener(new LocalNodeClusterManagerListener() {
             @Override
             public void onMaster() {
                 isClusterManager.set(true);
@@ -318,7 +318,7 @@ public void offMaster() {
         nodes = state.nodes();
         nodesBuilder = DiscoveryNodes.builder(nodes).masterNodeId(null);
         state = ClusterState.builder(state)
-            .blocks(ClusterBlocks.builder().addGlobalBlock(NoMasterBlockService.NO_MASTER_BLOCK_WRITES))
+            .blocks(ClusterBlocks.builder().addGlobalBlock(NoClusterManagerBlockService.NO_MASTER_BLOCK_WRITES))
             .nodes(nodesBuilder)
             .build();
         setState(timedClusterApplierService, state);
diff --git a/server/src/test/java/org/opensearch/cluster/service/MasterServiceTests.java b/server/src/test/java/org/opensearch/cluster/service/MasterServiceTests.java
index d5f7344c544b9..c829bef576be5 100644
--- a/server/src/test/java/org/opensearch/cluster/service/MasterServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/service/MasterServiceTests.java
@@ -123,7 +123,7 @@ public void randomizeCurrentTime() {
 
     private MasterService createClusterManagerService(boolean makeClusterManager) {
         final DiscoveryNode localNode = new DiscoveryNode("node1", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
-        final MasterService clusterManagerService = new MasterService(
+        final MasterService masterService = new MasterService(
             Settings.builder()
                 .put(ClusterName.CLUSTER_NAME_SETTING.getKey(), MasterServiceTests.class.getSimpleName())
                 .put(Node.NODE_NAME_SETTING.getKey(), "test_node")
@@ -141,13 +141,13 @@ private MasterService createClusterManagerService(boolean makeClusterManager) {
             .blocks(ClusterBlocks.EMPTY_CLUSTER_BLOCK)
             .build();
         final AtomicReference<ClusterState> clusterStateRef = new AtomicReference<>(initialClusterState);
-        clusterManagerService.setClusterStatePublisher((event, publishListener, ackListener) -> {
+        masterService.setClusterStatePublisher((event, publishListener, ackListener) -> {
             clusterStateRef.set(event.state());
             publishListener.onResponse(null);
         });
-        clusterManagerService.setClusterStateSupplier(clusterStateRef::get);
-        clusterManagerService.start();
-        return clusterManagerService;
+        masterService.setClusterStateSupplier(clusterStateRef::get);
+        masterService.start();
+        return masterService;
     }
 
     public void testClusterManagerAwareExecution() throws Exception {
@@ -194,7 +194,7 @@ public void onFailure(String source, Exception e) {
     }
 
     public void testThreadContext() throws InterruptedException {
-        final MasterService clusterManager = createClusterManagerService(true);
+        final MasterService masterService = createClusterManagerService(true);
         final CountDownLatch latch = new CountDownLatch(1);
 
         try (ThreadContext.StoredContext ignored = threadPool.getThreadContext().stashContext()) {
@@ -208,7 +208,7 @@ public void testThreadContext() throws InterruptedException {
             final TimeValue ackTimeout = randomBoolean() ? TimeValue.ZERO : TimeValue.timeValueMillis(randomInt(10000));
             final TimeValue clusterManagerTimeout = randomBoolean() ? TimeValue.ZERO : TimeValue.timeValueMillis(randomInt(10000));
 
-            clusterManager.submitStateUpdateTask("test", new AckedClusterStateUpdateTask<Void>(null, null) {
+            masterService.submitStateUpdateTask("test", new AckedClusterStateUpdateTask<Void>(null, null) {
                 @Override
                 public ClusterState execute(ClusterState currentState) {
                     assertTrue(threadPool.getThreadContext().isSystemContext());
@@ -280,7 +280,7 @@ public void onAckTimeout() {
 
         latch.await();
 
-        clusterManager.close();
+        masterService.close();
     }
 
     /*
@@ -292,8 +292,8 @@ public void testClusterStateTaskListenerThrowingExceptionIsOkay() throws Interru
         final CountDownLatch latch = new CountDownLatch(1);
         AtomicBoolean published = new AtomicBoolean();
 
-        try (MasterService clusterManagerService = createClusterManagerService(true)) {
-            clusterManagerService.submitStateUpdateTask(
+        try (MasterService masterService = createClusterManagerService(true)) {
+            masterService.submitStateUpdateTask(
                 "testClusterStateTaskListenerThrowingExceptionIsOkay",
                 new Object(),
                 ClusterStateTaskConfig.build(Priority.NORMAL),
@@ -421,8 +421,8 @@ public void testClusterStateUpdateLogging() throws Exception {
                 )
             );
 
-            try (MasterService clusterManagerService = createClusterManagerService(true)) {
-                clusterManagerService.submitStateUpdateTask("test1", new ClusterStateUpdateTask() {
+            try (MasterService masterService = createClusterManagerService(true)) {
+                masterService.submitStateUpdateTask("test1", new ClusterStateUpdateTask() {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         relativeTimeInMillis += TimeValue.timeValueSeconds(1).millis();
@@ -437,7 +437,7 @@ public void onFailure(String source, Exception e) {
                         fail();
                     }
                 });
-                clusterManagerService.submitStateUpdateTask("test2", new ClusterStateUpdateTask() {
+                masterService.submitStateUpdateTask("test2", new ClusterStateUpdateTask() {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         relativeTimeInMillis += TimeValue.timeValueSeconds(2).millis();
@@ -452,7 +452,7 @@ public void clusterStateProcessed(String source, ClusterState oldState, ClusterS
                     @Override
                     public void onFailure(String source, Exception e) {}
                 });
-                clusterManagerService.submitStateUpdateTask("test3", new ClusterStateUpdateTask() {
+                masterService.submitStateUpdateTask("test3", new ClusterStateUpdateTask() {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         relativeTimeInMillis += TimeValue.timeValueSeconds(3).millis();
@@ -469,7 +469,7 @@ public void onFailure(String source, Exception e) {
                         fail();
                     }
                 });
-                clusterManagerService.submitStateUpdateTask("test4", new ClusterStateUpdateTask() {
+                masterService.submitStateUpdateTask("test4", new ClusterStateUpdateTask() {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         return currentState;
@@ -617,7 +617,7 @@ public void clusterStateProcessed(String source, ClusterState oldState, ClusterS
             }
         };
 
-        try (MasterService clusterManagerService = createClusterManagerService(true)) {
+        try (MasterService masterService = createClusterManagerService(true)) {
             final ConcurrentMap<String, AtomicInteger> submittedTasksPerThread = new ConcurrentHashMap<>();
             CyclicBarrier barrier = new CyclicBarrier(1 + numberOfThreads);
             for (int i = 0; i < numberOfThreads; i++) {
@@ -632,7 +632,7 @@ public void clusterStateProcessed(String source, ClusterState oldState, ClusterS
                             submittedTasksPerThread.computeIfAbsent(threadName, key -> new AtomicInteger()).addAndGet(tasks.size());
                             final TaskExecutor executor = assignment.v1();
                             if (tasks.size() == 1) {
-                                clusterManagerService.submitStateUpdateTask(
+                                masterService.submitStateUpdateTask(
                                     threadName,
                                     tasks.stream().findFirst().get(),
                                     ClusterStateTaskConfig.build(randomFrom(Priority.values())),
@@ -642,7 +642,7 @@ public void clusterStateProcessed(String source, ClusterState oldState, ClusterS
                             } else {
                                 Map<Task, ClusterStateTaskListener> taskListeners = new HashMap<>();
                                 tasks.forEach(t -> taskListeners.put(t, listener));
-                                clusterManagerService.submitStateUpdateTasks(
+                                masterService.submitStateUpdateTasks(
                                     threadName,
                                     taskListeners,
                                     ClusterStateTaskConfig.build(randomFrom(Priority.values())),
@@ -696,8 +696,8 @@ public void testBlockingCallInClusterStateTaskListenerFails() throws Interrupted
         final CountDownLatch latch = new CountDownLatch(1);
         final AtomicReference<AssertionError> assertionRef = new AtomicReference<>();
 
-        try (MasterService clusterManagerService = createClusterManagerService(true)) {
-            clusterManagerService.submitStateUpdateTask(
+        try (MasterService masterService = createClusterManagerService(true)) {
+            masterService.submitStateUpdateTask(
                 "testBlockingCallInClusterStateTaskListenerFails",
                 new Object(),
                 ClusterStateTaskConfig.build(Priority.NORMAL),
@@ -788,7 +788,7 @@ public void testLongClusterStateUpdateLogging() throws Exception {
             );
 
             try (
-                MasterService clusterManagerService = new MasterService(
+                MasterService masterService = new MasterService(
                     Settings.builder()
                         .put(ClusterName.CLUSTER_NAME_SETTING.getKey(), MasterServiceTests.class.getSimpleName())
                         .put(Node.NODE_NAME_SETTING.getKey(), "test_node")
@@ -810,7 +810,7 @@ public void testLongClusterStateUpdateLogging() throws Exception {
                     .blocks(ClusterBlocks.EMPTY_CLUSTER_BLOCK)
                     .build();
                 final AtomicReference<ClusterState> clusterStateRef = new AtomicReference<>(initialClusterState);
-                clusterManagerService.setClusterStatePublisher((event, publishListener, ackListener) -> {
+                masterService.setClusterStatePublisher((event, publishListener, ackListener) -> {
                     if (event.source().contains("test5")) {
                         relativeTimeInMillis += MasterService.CLUSTER_MANAGER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING.get(
                             Settings.EMPTY
@@ -825,12 +825,12 @@ public void testLongClusterStateUpdateLogging() throws Exception {
                     clusterStateRef.set(event.state());
                     publishListener.onResponse(null);
                 });
-                clusterManagerService.setClusterStateSupplier(clusterStateRef::get);
-                clusterManagerService.start();
+                masterService.setClusterStateSupplier(clusterStateRef::get);
+                masterService.start();
 
                 final CountDownLatch latch = new CountDownLatch(6);
                 final CountDownLatch processedFirstTask = new CountDownLatch(1);
-                clusterManagerService.submitStateUpdateTask("test1", new ClusterStateUpdateTask() {
+                masterService.submitStateUpdateTask("test1", new ClusterStateUpdateTask() {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         relativeTimeInMillis += randomLongBetween(
@@ -853,7 +853,7 @@ public void onFailure(String source, Exception e) {
                 });
 
                 processedFirstTask.await();
-                clusterManagerService.submitStateUpdateTask("test2", new ClusterStateUpdateTask() {
+                masterService.submitStateUpdateTask("test2", new ClusterStateUpdateTask() {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         relativeTimeInMillis += MasterService.CLUSTER_MANAGER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING.get(
@@ -872,7 +872,7 @@ public void onFailure(String source, Exception e) {
                         latch.countDown();
                     }
                 });
-                clusterManagerService.submitStateUpdateTask("test3", new ClusterStateUpdateTask() {
+                masterService.submitStateUpdateTask("test3", new ClusterStateUpdateTask() {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         relativeTimeInMillis += MasterService.CLUSTER_MANAGER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING.get(
@@ -891,7 +891,7 @@ public void onFailure(String source, Exception e) {
                         fail();
                     }
                 });
-                clusterManagerService.submitStateUpdateTask("test4", new ClusterStateUpdateTask() {
+                masterService.submitStateUpdateTask("test4", new ClusterStateUpdateTask() {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         relativeTimeInMillis += MasterService.CLUSTER_MANAGER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING.get(
@@ -910,7 +910,7 @@ public void onFailure(String source, Exception e) {
                         fail();
                     }
                 });
-                clusterManagerService.submitStateUpdateTask("test5", new ClusterStateUpdateTask() {
+                masterService.submitStateUpdateTask("test5", new ClusterStateUpdateTask() {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         return ClusterState.builder(currentState).incrementVersion().build();
@@ -926,7 +926,7 @@ public void onFailure(String source, Exception e) {
                         fail();
                     }
                 });
-                clusterManagerService.submitStateUpdateTask("test6", new ClusterStateUpdateTask() {
+                masterService.submitStateUpdateTask("test6", new ClusterStateUpdateTask() {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         return ClusterState.builder(currentState).incrementVersion().build();
@@ -944,7 +944,7 @@ public void onFailure(String source, Exception e) {
                 });
                 // Additional update task to make sure all previous logging made it to the loggerName
                 // We don't check logging for this on since there is no guarantee that it will occur before our check
-                clusterManagerService.submitStateUpdateTask("test7", new ClusterStateUpdateTask() {
+                masterService.submitStateUpdateTask("test7", new ClusterStateUpdateTask() {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         return currentState;
@@ -971,7 +971,7 @@ public void testAcking() throws InterruptedException {
         final DiscoveryNode node2 = new DiscoveryNode("node2", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
         final DiscoveryNode node3 = new DiscoveryNode("node3", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
         try (
-            MasterService clusterManagerService = new MasterService(
+            MasterService masterService = new MasterService(
                 Settings.builder()
                     .put(ClusterName.CLUSTER_NAME_SETTING.getKey(), MasterServiceTests.class.getSimpleName())
                     .put(Node.NODE_NAME_SETTING.getKey(), "test_node")
@@ -986,9 +986,9 @@ public void testAcking() throws InterruptedException {
                 .blocks(ClusterBlocks.EMPTY_CLUSTER_BLOCK)
                 .build();
             final AtomicReference<ClusterStatePublisher> publisherRef = new AtomicReference<>();
-            clusterManagerService.setClusterStatePublisher((e, pl, al) -> publisherRef.get().publish(e, pl, al));
-            clusterManagerService.setClusterStateSupplier(() -> initialClusterState);
-            clusterManagerService.start();
+            masterService.setClusterStatePublisher((e, pl, al) -> publisherRef.get().publish(e, pl, al));
+            masterService.setClusterStateSupplier(() -> initialClusterState);
+            masterService.start();
 
             // check that we don't time out before even committing the cluster state
             {
@@ -1000,7 +1000,7 @@ public void testAcking() throws InterruptedException {
                     )
                 );
 
-                clusterManagerService.submitStateUpdateTask("test2", new AckedClusterStateUpdateTask<Void>(null, null) {
+                masterService.submitStateUpdateTask("test2", new AckedClusterStateUpdateTask<Void>(null, null) {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         return ClusterState.builder(currentState).build();
@@ -1055,7 +1055,7 @@ public void onAckTimeout() {
                     ackListener.onNodeAck(node3, null);
                 });
 
-                clusterManagerService.submitStateUpdateTask("test2", new AckedClusterStateUpdateTask<Void>(null, null) {
+                masterService.submitStateUpdateTask("test2", new AckedClusterStateUpdateTask<Void>(null, null) {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         return ClusterState.builder(currentState).build();
@@ -1101,8 +1101,8 @@ public void onAckTimeout() {
     /**
      * Returns the cluster state that the cluster-manager service uses (and that is provided by the discovery layer)
      */
-    public static ClusterState discoveryState(MasterService clusterManagerService) {
-        return clusterManagerService.state();
+    public static ClusterState discoveryState(MasterService masterService) {
+        return masterService.state();
     }
 
 }
diff --git a/server/src/test/java/org/opensearch/discovery/DiscoveryModuleTests.java b/server/src/test/java/org/opensearch/discovery/DiscoveryModuleTests.java
index efcefab6c9f8b..d1e3f406b4933 100644
--- a/server/src/test/java/org/opensearch/discovery/DiscoveryModuleTests.java
+++ b/server/src/test/java/org/opensearch/discovery/DiscoveryModuleTests.java
@@ -70,7 +70,7 @@ public class DiscoveryModuleTests extends OpenSearchTestCase {
 
     private TransportService transportService;
     private NamedWriteableRegistry namedWriteableRegistry;
-    private MasterService clusterManagerService;
+    private MasterService masterService;
     private ClusterApplier clusterApplier;
     private ThreadPool threadPool;
     private ClusterSettings clusterSettings;
@@ -93,7 +93,7 @@ public void setupDummyServices() {
         threadPool = mock(ThreadPool.class);
         when(threadPool.getThreadContext()).thenReturn(new ThreadContext(Settings.EMPTY));
         transportService = MockTransportService.createNewService(Settings.EMPTY, Version.CURRENT, threadPool, null);
-        clusterManagerService = mock(MasterService.class);
+        masterService = mock(MasterService.class);
         namedWriteableRegistry = new NamedWriteableRegistry(Collections.emptyList());
         clusterApplier = mock(ClusterApplier.class);
         clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
@@ -112,7 +112,7 @@ private DiscoveryModule newModule(Settings settings, List<DiscoveryPlugin> plugi
             transportService,
             namedWriteableRegistry,
             null,
-            clusterManagerService,
+            masterService,
             clusterApplier,
             clusterSettings,
             plugins,
diff --git a/server/src/test/java/org/opensearch/indices/cluster/IndicesClusterStateServiceRandomUpdatesTests.java b/server/src/test/java/org/opensearch/indices/cluster/IndicesClusterStateServiceRandomUpdatesTests.java
index 61a9d4bdd2f62..616baa50b0b19 100644
--- a/server/src/test/java/org/opensearch/indices/cluster/IndicesClusterStateServiceRandomUpdatesTests.java
+++ b/server/src/test/java/org/opensearch/indices/cluster/IndicesClusterStateServiceRandomUpdatesTests.java
@@ -47,7 +47,7 @@
 import org.opensearch.cluster.action.shard.ShardStateAction;
 import org.opensearch.cluster.block.ClusterBlock;
 import org.opensearch.cluster.block.ClusterBlocks;
-import org.opensearch.cluster.coordination.NoMasterBlockService;
+import org.opensearch.cluster.coordination.NoClusterManagerBlockService;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
@@ -368,20 +368,22 @@ public ClusterState randomlyUpdateClusterState(
         Supplier<MockIndicesService> indicesServiceSupplier
     ) {
         // randomly remove no_cluster_manager blocks
-        if (randomBoolean() && state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID)) {
+        if (randomBoolean() && state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID)) {
             state = ClusterState.builder(state)
-                .blocks(ClusterBlocks.builder().blocks(state.blocks()).removeGlobalBlock(NoMasterBlockService.NO_MASTER_BLOCK_ID))
+                .blocks(ClusterBlocks.builder().blocks(state.blocks()).removeGlobalBlock(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID))
                 .build();
         }
 
         // randomly add no_cluster_manager blocks
-        if (rarely() && state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID) == false) {
-            ClusterBlock block = randomBoolean() ? NoMasterBlockService.NO_MASTER_BLOCK_ALL : NoMasterBlockService.NO_MASTER_BLOCK_WRITES;
+        if (rarely() && state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID) == false) {
+            ClusterBlock block = randomBoolean()
+                ? NoClusterManagerBlockService.NO_MASTER_BLOCK_ALL
+                : NoClusterManagerBlockService.NO_MASTER_BLOCK_WRITES;
             state = ClusterState.builder(state).blocks(ClusterBlocks.builder().blocks(state.blocks()).addGlobalBlock(block)).build();
         }
 
         // if no_cluster_manager block is in place, make no other cluster state changes
-        if (state.blocks().hasGlobalBlockWithId(NoMasterBlockService.NO_MASTER_BLOCK_ID)) {
+        if (state.blocks().hasGlobalBlockWithId(NoClusterManagerBlockService.NO_MASTER_BLOCK_ID)) {
             return state;
         }
 
diff --git a/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java b/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
index d305776482fee..60333203b7bfb 100644
--- a/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
+++ b/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
@@ -1641,7 +1641,7 @@ private final class TestClusterNode {
 
             private final DiscoveryNode node;
 
-            private final MasterService clusterManagerService;
+            private final MasterService masterService;
 
             private final AllocationService allocationService;
 
@@ -1661,18 +1661,13 @@ private final class TestClusterNode {
                 this.node = node;
                 final Environment environment = createEnvironment(node.getName());
                 threadPool = deterministicTaskQueue.getThreadPool(runnable -> CoordinatorTests.onNodeLog(node, runnable));
-                clusterManagerService = new FakeThreadPoolMasterService(
-                    node.getName(),
-                    "test",
-                    threadPool,
-                    deterministicTaskQueue::scheduleNow
-                );
+                masterService = new FakeThreadPoolMasterService(node.getName(), "test", threadPool, deterministicTaskQueue::scheduleNow);
                 final Settings settings = environment.settings();
                 final ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
                 clusterService = new ClusterService(
                     settings,
                     clusterSettings,
-                    clusterManagerService,
+                    masterService,
                     new ClusterApplierService(node.getName(), settings, clusterSettings, threadPool) {
                         @Override
                         protected PrioritizedOpenSearchThreadPoolExecutor createThreadPoolExecutor() {
@@ -2201,7 +2196,7 @@ public void start(ClusterState initialState) {
                     transportService,
                     namedWriteableRegistry,
                     allocationService,
-                    clusterManagerService,
+                    masterService,
                     () -> persistedState,
                     hostsResolver -> nodes.values()
                         .stream()
@@ -2215,7 +2210,7 @@ public void start(ClusterState initialState) {
                     ElectionStrategy.DEFAULT_INSTANCE,
                     () -> new StatusInfo(HEALTHY, "healthy-info")
                 );
-                clusterManagerService.setClusterStatePublisher(coordinator);
+                masterService.setClusterStatePublisher(coordinator);
                 coordinator.start();
                 clusterService.getClusterApplierService().setNodeConnectionsService(nodeConnectionsService);
                 nodeConnectionsService.start();
diff --git a/test/framework/src/main/java/org/opensearch/cluster/coordination/AbstractCoordinatorTestCase.java b/test/framework/src/main/java/org/opensearch/cluster/coordination/AbstractCoordinatorTestCase.java
index e341a330e2c4c..19551b0adecb2 100644
--- a/test/framework/src/main/java/org/opensearch/cluster/coordination/AbstractCoordinatorTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/cluster/coordination/AbstractCoordinatorTestCase.java
@@ -139,7 +139,7 @@
 import static org.opensearch.cluster.coordination.LeaderChecker.LEADER_CHECK_INTERVAL_SETTING;
 import static org.opensearch.cluster.coordination.LeaderChecker.LEADER_CHECK_RETRY_COUNT_SETTING;
 import static org.opensearch.cluster.coordination.LeaderChecker.LEADER_CHECK_TIMEOUT_SETTING;
-import static org.opensearch.cluster.coordination.NoMasterBlockService.NO_MASTER_BLOCK_ID;
+import static org.opensearch.cluster.coordination.NoClusterManagerBlockService.NO_MASTER_BLOCK_ID;
 import static org.opensearch.cluster.coordination.Reconfigurator.CLUSTER_AUTO_SHRINK_VOTING_CONFIGURATION;
 import static org.opensearch.discovery.PeerFinder.DISCOVERY_FIND_PEERS_INTERVAL_SETTING;
 import static org.opensearch.gateway.GatewayService.STATE_NOT_RECOVERED_BLOCK;
@@ -557,7 +557,7 @@ void stabilise(long stabilisationDurationMillis) {
             final ClusterNode leader = getAnyLeader();
             final long leaderTerm = leader.coordinator.getCurrentTerm();
 
-            final int pendingTaskCount = leader.clusterManagerService.getFakeMasterServicePendingTaskCount();
+            final int pendingTaskCount = leader.masterService.getFakeMasterServicePendingTaskCount();
             runFor((pendingTaskCount + 1) * DEFAULT_CLUSTER_STATE_UPDATE_DELAY, "draining task queue");
 
             final Matcher<Long> isEqualToLeaderVersion = equalTo(leader.coordinator.getLastAcceptedState().getVersion());
@@ -1025,7 +1025,7 @@ class ClusterNode {
             private final DiscoveryNode localNode;
             final MockPersistedState persistedState;
             final Settings nodeSettings;
-            private AckedFakeThreadPoolClusterManagerService clusterManagerService;
+            private AckedFakeThreadPoolMasterService masterService;
             private DisruptableClusterApplierService clusterApplierService;
             private ClusterService clusterService;
             TransportService transportService;
@@ -1105,7 +1105,7 @@ protected Optional<DisruptableMockTransport> getDisruptableMockTransport(Transpo
                     null,
                     emptySet()
                 );
-                clusterManagerService = new AckedFakeThreadPoolClusterManagerService(
+                masterService = new AckedFakeThreadPoolMasterService(
                     localNode.getId(),
                     "test",
                     threadPool,
@@ -1119,7 +1119,7 @@ protected Optional<DisruptableMockTransport> getDisruptableMockTransport(Transpo
                     deterministicTaskQueue,
                     threadPool
                 );
-                clusterService = new ClusterService(settings, clusterSettings, clusterManagerService, clusterApplierService);
+                clusterService = new ClusterService(settings, clusterSettings, masterService, clusterApplierService);
                 clusterService.setNodeConnectionsService(
                     new NodeConnectionsService(clusterService.getSettings(), threadPool, transportService)
                 );
@@ -1134,7 +1134,7 @@ protected Optional<DisruptableMockTransport> getDisruptableMockTransport(Transpo
                     transportService,
                     writableRegistry(),
                     allocationService,
-                    clusterManagerService,
+                    masterService,
                     this::getPersistedState,
                     Cluster.this::provideSeedHosts,
                     clusterApplierService,
@@ -1144,7 +1144,7 @@ protected Optional<DisruptableMockTransport> getDisruptableMockTransport(Transpo
                     getElectionStrategy(),
                     nodeHealthService
                 );
-                clusterManagerService.setClusterStatePublisher(coordinator);
+                masterService.setClusterStatePublisher(coordinator);
                 final GatewayService gatewayService = new GatewayService(
                     settings,
                     allocationService,
@@ -1331,11 +1331,11 @@ AckCollector submitUpdateTask(
                 onNode(() -> {
                     logger.trace("[{}] submitUpdateTask: enqueueing [{}]", localNode.getId(), source);
                     final long submittedTerm = coordinator.getCurrentTerm();
-                    clusterManagerService.submitStateUpdateTask(source, new ClusterStateUpdateTask() {
+                    masterService.submitStateUpdateTask(source, new ClusterStateUpdateTask() {
                         @Override
                         public ClusterState execute(ClusterState currentState) {
                             assertThat(currentState.term(), greaterThanOrEqualTo(submittedTerm));
-                            clusterManagerService.nextAckCollector = ackCollector;
+                            masterService.nextAckCollector = ackCollector;
                             return clusterStateUpdate.apply(currentState);
                         }
 
@@ -1510,11 +1510,11 @@ int getSuccessfulAckIndex(ClusterNode clusterNode) {
         }
     }
 
-    static class AckedFakeThreadPoolClusterManagerService extends FakeThreadPoolMasterService {
+    static class AckedFakeThreadPoolMasterService extends FakeThreadPoolMasterService {
 
         AckCollector nextAckCollector = new AckCollector();
 
-        AckedFakeThreadPoolClusterManagerService(
+        AckedFakeThreadPoolMasterService(
             String nodeName,
             String serviceName,
             ThreadPool threadPool,
diff --git a/test/framework/src/main/java/org/opensearch/test/ClusterServiceUtils.java b/test/framework/src/main/java/org/opensearch/test/ClusterServiceUtils.java
index f709d8bcaff34..99f9b86fb6479 100644
--- a/test/framework/src/main/java/org/opensearch/test/ClusterServiceUtils.java
+++ b/test/framework/src/main/java/org/opensearch/test/ClusterServiceUtils.java
@@ -62,19 +62,19 @@
 public class ClusterServiceUtils {
 
     public static MasterService createMasterService(ThreadPool threadPool, ClusterState initialClusterState) {
-        MasterService clusterManagerService = new MasterService(
+        MasterService masterService = new MasterService(
             Settings.builder().put(Node.NODE_NAME_SETTING.getKey(), "test_cluster_manager_node").build(),
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             threadPool
         );
         AtomicReference<ClusterState> clusterStateRef = new AtomicReference<>(initialClusterState);
-        clusterManagerService.setClusterStatePublisher((event, publishListener, ackListener) -> {
+        masterService.setClusterStatePublisher((event, publishListener, ackListener) -> {
             clusterStateRef.set(event.state());
             publishListener.onResponse(null);
         });
-        clusterManagerService.setClusterStateSupplier(clusterStateRef::get);
-        clusterManagerService.start();
-        return clusterManagerService;
+        masterService.setClusterStateSupplier(clusterStateRef::get);
+        masterService.start();
+        return masterService;
     }
 
     public static MasterService createMasterService(ThreadPool threadPool, DiscoveryNode localNode) {
diff --git a/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java b/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java
index 5ccdd2c529308..70a306eda0ff8 100644
--- a/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java
+++ b/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java
@@ -55,7 +55,7 @@
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.action.index.MappingUpdatedAction;
 import org.opensearch.cluster.coordination.ClusterBootstrapService;
-import org.opensearch.cluster.coordination.NoMasterBlockService;
+import org.opensearch.cluster.coordination.NoClusterManagerBlockService;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodeRole;
@@ -434,7 +434,7 @@ public InternalTestCluster(
         );
         // TODO: currently we only randomize "cluster.no_cluster_manager_block" between "write" and "metadata_write", as "all" is fragile
         // and fails shards when a cluster-manager abdicates, which breaks many tests.
-        builder.put(NoMasterBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.getKey(), randomFrom(random, "write", "metadata_write"));
+        builder.put(NoClusterManagerBlockService.NO_CLUSTER_MANAGER_BLOCK_SETTING.getKey(), randomFrom(random, "write", "metadata_write"));
         defaultSettings = builder.build();
         executor = OpenSearchExecutors.newScaling(
             "internal_test_cluster_executor",
diff --git a/test/framework/src/main/java/org/opensearch/test/RandomObjects.java b/test/framework/src/main/java/org/opensearch/test/RandomObjects.java
index 8beac9e441787..a0227c51c8085 100644
--- a/test/framework/src/main/java/org/opensearch/test/RandomObjects.java
+++ b/test/framework/src/main/java/org/opensearch/test/RandomObjects.java
@@ -43,7 +43,7 @@
 import org.opensearch.action.support.replication.ReplicationResponse.ShardInfo;
 import org.opensearch.action.support.replication.ReplicationResponse.ShardInfo.Failure;
 import org.opensearch.cluster.block.ClusterBlockException;
-import org.opensearch.cluster.coordination.NoMasterBlockService;
+import org.opensearch.cluster.coordination.NoClusterManagerBlockService;
 import org.opensearch.common.bytes.BytesArray;
 import org.opensearch.common.bytes.BytesReference;
 import org.opensearch.common.collect.Tuple;
@@ -331,7 +331,7 @@ private static Tuple<Failure, Failure> randomShardInfoFailure(Random random) {
         int type = randomIntBetween(random, 0, 3);
         switch (type) {
             case 0:
-                actualException = new ClusterBlockException(singleton(NoMasterBlockService.NO_MASTER_BLOCK_WRITES));
+                actualException = new ClusterBlockException(singleton(NoClusterManagerBlockService.NO_MASTER_BLOCK_WRITES));
                 expectedException = new OpenSearchException(
                     "OpenSearch exception [type=cluster_block_exception, "
                         + "reason=blocked by: [SERVICE_UNAVAILABLE/2/no cluster-manager];]"
diff --git a/test/framework/src/test/java/org/opensearch/cluster/service/FakeThreadPoolMasterServiceTests.java b/test/framework/src/test/java/org/opensearch/cluster/service/FakeThreadPoolMasterServiceTests.java
index dabeeb6742ec4..b4cdb0b33391a 100644
--- a/test/framework/src/test/java/org/opensearch/cluster/service/FakeThreadPoolMasterServiceTests.java
+++ b/test/framework/src/test/java/org/opensearch/cluster/service/FakeThreadPoolMasterServiceTests.java
@@ -84,21 +84,21 @@ public void testFakeClusterManagerService() {
         doAnswer(invocationOnMock -> runnableTasks.add((Runnable) invocationOnMock.getArguments()[0])).when(executorService).execute(any());
         when(mockThreadPool.generic()).thenReturn(executorService);
 
-        FakeThreadPoolMasterService clusterManagerService = new FakeThreadPoolMasterService(
+        FakeThreadPoolMasterService masterService = new FakeThreadPoolMasterService(
             "test_node",
             "test",
             mockThreadPool,
             runnableTasks::add
         );
-        clusterManagerService.setClusterStateSupplier(lastClusterStateRef::get);
-        clusterManagerService.setClusterStatePublisher((event, publishListener, ackListener) -> {
+        masterService.setClusterStateSupplier(lastClusterStateRef::get);
+        masterService.setClusterStatePublisher((event, publishListener, ackListener) -> {
             lastClusterStateRef.set(event.state());
             publishingCallback.set(publishListener);
         });
-        clusterManagerService.start();
+        masterService.start();
 
         AtomicBoolean firstTaskCompleted = new AtomicBoolean();
-        clusterManagerService.submitStateUpdateTask("test1", new ClusterStateUpdateTask() {
+        masterService.submitStateUpdateTask("test1", new ClusterStateUpdateTask() {
             @Override
             public ClusterState execute(ClusterState currentState) {
                 return ClusterState.builder(currentState)
@@ -138,7 +138,7 @@ public void onFailure(String source, Exception e) {
         assertThat(runnableTasks.size(), equalTo(0));
 
         AtomicBoolean secondTaskCompleted = new AtomicBoolean();
-        clusterManagerService.submitStateUpdateTask("test2", new ClusterStateUpdateTask() {
+        masterService.submitStateUpdateTask("test2", new ClusterStateUpdateTask() {
             @Override
             public ClusterState execute(ClusterState currentState) {
                 return ClusterState.builder(currentState)