You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hbase.apache.org by an...@apache.org on 2026/03/13 20:01:28 UTC

(hbase) 20/26: HBASE-29841: Split bulky ReadOnlyController into multiple smaller controllers (#7661)

This is an automated email from the ASF dual-hosted git repository.

andor pushed a commit to branch HBASE-29081_rebased
in repository https://gitbox.apache.org/repos/asf/hbase.git

commit 36569438551d6c20c2a31698dcdd628448e359da
Author: Anuj Sharma <sh...@gmail.com>
AuthorDate: Fri Feb 6 05:51:22 2026 +0530

    HBASE-29841: Split bulky ReadOnlyController into multiple smaller controllers (#7661)
    
    * HBASE-29841: Split bulky ReadOnlyController into multiple smaller controllers
    
    Currently we have created a single ReadOnlyController which needs to get added as coprocessor for master, region and region server. In this task we will be breaking ReadOnlyController into multiple smaller controller to avoid unnecessarily adding methods which are not relevant for particular role for example, master copocessor should only register methods which may run on master and not on region or region server.
    
    * Addres review Comments
---
 .../access/AbstractReadOnlyController.java         | 119 +++
 .../access/BulkLoadReadOnlyController.java         |  53 ++
 .../access/EndpointReadOnlyController.java         |  50 ++
 .../security/access/MasterReadOnlyController.java  | 433 ++++++++++
 .../hbase/security/access/ReadOnlyController.java  | 913 ---------------------
 .../security/access/RegionReadOnlyController.java  | 369 +++++++++
 .../access/RegionServerReadOnlyController.java     |  64 ++
 .../apache/hadoop/hbase/TestRefreshHFilesBase.java |  16 +-
 .../TestRefreshMetaProcedureIntegration.java       |  17 +-
 .../access/TestCanStartHBaseInReadOnlyMode.java    |  11 +-
 .../security/access/TestReadOnlyController.java    |  11 +-
 .../TestReadOnlyControllerBulkLoadObserver.java    |  16 +-
 .../TestReadOnlyControllerEndpointObserver.java    |  10 +-
 .../TestReadOnlyControllerMasterObserver.java      | 298 +++----
 .../TestReadOnlyControllerRegionObserver.java      | 368 +++++----
 ...TestReadOnlyControllerRegionServerObserver.java |  33 +-
 16 files changed, 1495 insertions(+), 1286 deletions(-)

diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/AbstractReadOnlyController.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/AbstractReadOnlyController.java
new file mode 100644
index 00000000000..402009c025a
--- /dev/null
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/AbstractReadOnlyController.java
@@ -0,0 +1,119 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.security.access;
+
+import java.io.IOException;
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.Path;
+import org.apache.hadoop.hbase.Coprocessor;
+import org.apache.hadoop.hbase.CoprocessorEnvironment;
+import org.apache.hadoop.hbase.DoNotRetryIOException;
+import org.apache.hadoop.hbase.HBaseInterfaceAudience;
+import org.apache.hadoop.hbase.HConstants;
+import org.apache.hadoop.hbase.conf.ConfigurationObserver;
+import org.apache.hadoop.hbase.coprocessor.MasterCoprocessorEnvironment;
+import org.apache.hadoop.hbase.master.MasterFileSystem;
+import org.apache.hadoop.hbase.master.MasterServices;
+import org.apache.hadoop.hbase.util.FSUtils;
+import org.apache.yetus.audience.InterfaceAudience;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+@InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.CONFIG)
+public abstract class AbstractReadOnlyController implements ConfigurationObserver, Coprocessor {
+  protected volatile boolean globalReadOnlyEnabled;
+  private MasterServices masterServices;
+  private static final Logger LOG = LoggerFactory.getLogger(AbstractReadOnlyController.class);
+
+  protected void internalReadOnlyGuard() throws DoNotRetryIOException {
+    if (this.globalReadOnlyEnabled) {
+      throw new DoNotRetryIOException("Operation not allowed in Read-Only Mode");
+    }
+  }
+
+  @Override
+  public void start(CoprocessorEnvironment env) throws IOException {
+    if (env instanceof MasterCoprocessorEnvironment) {
+      this.masterServices = ((MasterCoprocessorEnvironment) env).getMasterServices();
+      LOG.info("ReadOnlyController obtained MasterServices reference from start().");
+    } else {
+      LOG.debug("ReadOnlyController loaded in a non-Master environment. "
+        + "File system operations for read-only state will not work.");
+    }
+
+    this.globalReadOnlyEnabled =
+      env.getConfiguration().getBoolean(HConstants.HBASE_GLOBAL_READONLY_ENABLED_KEY,
+        HConstants.HBASE_GLOBAL_READONLY_ENABLED_DEFAULT);
+  }
+
+  @Override
+  public void stop(CoprocessorEnvironment env) {
+  }
+
+  private void manageActiveClusterIdFile(boolean readOnlyEnabled) {
+    MasterFileSystem mfs = this.masterServices.getMasterFileSystem();
+    FileSystem fs = mfs.getFileSystem();
+    Path rootDir = mfs.getRootDir();
+    Path activeClusterFile = new Path(rootDir, HConstants.ACTIVE_CLUSTER_SUFFIX_FILE_NAME);
+
+    try {
+      if (readOnlyEnabled) {
+        // ENABLING READ-ONLY (false -> true), delete the active cluster file.
+        LOG.debug("Global read-only mode is being ENABLED. Deleting active cluster file: {}",
+          activeClusterFile);
+        try {
+          fs.delete(activeClusterFile, false);
+          LOG.info("Successfully deleted active cluster file: {}", activeClusterFile);
+        } catch (IOException e) {
+          LOG.error(
+            "Failed to delete active cluster file: {}. "
+              + "Read-only flag will be updated, but file system state is inconsistent.",
+            activeClusterFile);
+        }
+      } else {
+        // DISABLING READ-ONLY (true -> false), create the active cluster file id file
+        int wait = mfs.getConfiguration().getInt(HConstants.THREAD_WAKE_FREQUENCY, 10 * 1000);
+        FSUtils.setActiveClusterSuffix(fs, rootDir, mfs.getSuffixFileDataToWrite(), wait);
+      }
+    } catch (IOException e) {
+      // We still update the flag, but log that the operation failed.
+      LOG.error("Failed to perform file operation for read-only switch. "
+        + "Flag will be updated, but file system state may be inconsistent.", e);
+    }
+  }
+
+  @Override
+  public void onConfigurationChange(Configuration conf) {
+    boolean maybeUpdatedConfValue = conf.getBoolean(HConstants.HBASE_GLOBAL_READONLY_ENABLED_KEY,
+      HConstants.HBASE_GLOBAL_READONLY_ENABLED_DEFAULT);
+    if (this.globalReadOnlyEnabled != maybeUpdatedConfValue) {
+      if (this.masterServices != null) {
+        manageActiveClusterIdFile(maybeUpdatedConfValue);
+      } else {
+        LOG.debug("Global R/O flag changed, but not running on master");
+      }
+
+      this.globalReadOnlyEnabled = maybeUpdatedConfValue;
+      LOG.info("Config {} has been dynamically changed to {}.",
+        HConstants.HBASE_GLOBAL_READONLY_ENABLED_KEY, this.globalReadOnlyEnabled);
+    }
+  }
+
+}
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/BulkLoadReadOnlyController.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/BulkLoadReadOnlyController.java
new file mode 100644
index 00000000000..d81515c98ed
--- /dev/null
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/BulkLoadReadOnlyController.java
@@ -0,0 +1,53 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.security.access;
+
+import java.io.IOException;
+import java.util.Optional;
+import org.apache.hadoop.hbase.HBaseInterfaceAudience;
+import org.apache.hadoop.hbase.coprocessor.BulkLoadObserver;
+import org.apache.hadoop.hbase.coprocessor.CoreCoprocessor;
+import org.apache.hadoop.hbase.coprocessor.ObserverContext;
+import org.apache.hadoop.hbase.coprocessor.RegionCoprocessor;
+import org.apache.hadoop.hbase.coprocessor.RegionCoprocessorEnvironment;
+import org.apache.yetus.audience.InterfaceAudience;
+
+@CoreCoprocessor
+@InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.CONFIG)
+public class BulkLoadReadOnlyController extends AbstractReadOnlyController
+  implements BulkLoadObserver, RegionCoprocessor {
+
+  @Override
+  public Optional<BulkLoadObserver> getBulkLoadObserver() {
+    return Optional.of(this);
+  }
+
+  @Override
+  public void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx)
+    throws IOException {
+    internalReadOnlyGuard();
+    BulkLoadObserver.super.prePrepareBulkLoad(ctx);
+  }
+
+  @Override
+  public void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx)
+    throws IOException {
+    internalReadOnlyGuard();
+    BulkLoadObserver.super.preCleanupBulkLoad(ctx);
+  }
+}
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/EndpointReadOnlyController.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/EndpointReadOnlyController.java
new file mode 100644
index 00000000000..edecc839ce4
--- /dev/null
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/EndpointReadOnlyController.java
@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.security.access;
+
+import java.io.IOException;
+import java.util.Optional;
+import org.apache.hadoop.hbase.HBaseInterfaceAudience;
+import org.apache.hadoop.hbase.coprocessor.CoreCoprocessor;
+import org.apache.hadoop.hbase.coprocessor.EndpointObserver;
+import org.apache.hadoop.hbase.coprocessor.ObserverContext;
+import org.apache.hadoop.hbase.coprocessor.RegionCoprocessor;
+import org.apache.hadoop.hbase.coprocessor.RegionCoprocessorEnvironment;
+import org.apache.yetus.audience.InterfaceAudience;
+
+import org.apache.hbase.thirdparty.com.google.protobuf.Message;
+import org.apache.hbase.thirdparty.com.google.protobuf.Service;
+
+@CoreCoprocessor
+@InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.CONFIG)
+public class EndpointReadOnlyController extends AbstractReadOnlyController
+  implements EndpointObserver, RegionCoprocessor {
+
+  @Override
+  public Optional<EndpointObserver> getEndpointObserver() {
+    return Optional.of(this);
+  }
+
+  @Override
+  public Message preEndpointInvocation(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
+    Service service, String methodName, Message request) throws IOException {
+    internalReadOnlyGuard();
+    return EndpointObserver.super.preEndpointInvocation(ctx, service, methodName, request);
+  }
+
+}
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/MasterReadOnlyController.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/MasterReadOnlyController.java
new file mode 100644
index 00000000000..c2eb8833b08
--- /dev/null
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/MasterReadOnlyController.java
@@ -0,0 +1,433 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.security.access;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import org.apache.hadoop.hbase.HBaseInterfaceAudience;
+import org.apache.hadoop.hbase.NamespaceDescriptor;
+import org.apache.hadoop.hbase.TableName;
+import org.apache.hadoop.hbase.client.BalanceRequest;
+import org.apache.hadoop.hbase.client.Mutation;
+import org.apache.hadoop.hbase.client.RegionInfo;
+import org.apache.hadoop.hbase.client.SnapshotDescription;
+import org.apache.hadoop.hbase.client.TableDescriptor;
+import org.apache.hadoop.hbase.coprocessor.CoreCoprocessor;
+import org.apache.hadoop.hbase.coprocessor.MasterCoprocessor;
+import org.apache.hadoop.hbase.coprocessor.MasterCoprocessorEnvironment;
+import org.apache.hadoop.hbase.coprocessor.MasterObserver;
+import org.apache.hadoop.hbase.coprocessor.ObserverContext;
+import org.apache.hadoop.hbase.master.MasterServices;
+import org.apache.hadoop.hbase.net.Address;
+import org.apache.hadoop.hbase.quotas.GlobalQuotaSettings;
+import org.apache.hadoop.hbase.replication.ReplicationPeerConfig;
+import org.apache.hadoop.hbase.replication.SyncReplicationState;
+import org.apache.yetus.audience.InterfaceAudience;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@CoreCoprocessor
+@InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.CONFIG)
+public class MasterReadOnlyController extends AbstractReadOnlyController
+  implements MasterCoprocessor, MasterObserver {
+
+  private static final Logger LOG = LoggerFactory.getLogger(MasterReadOnlyController.class);
+
+  private MasterServices masterServices;
+
+  @Override
+  public Optional<MasterObserver> getMasterObserver() {
+    return Optional.of(this);
+  }
+
+  @Override
+  public TableDescriptor preCreateTableRegionsInfos(
+    ObserverContext<MasterCoprocessorEnvironment> ctx, TableDescriptor desc) throws IOException {
+    internalReadOnlyGuard();
+    return MasterObserver.super.preCreateTableRegionsInfos(ctx, desc);
+  }
+
+  @Override
+  public void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    TableDescriptor desc, RegionInfo[] regions) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preCreateTable(ctx, desc, regions);
+  }
+
+  @Override
+  public void preCreateTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    TableDescriptor desc, RegionInfo[] regions) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preCreateTableAction(ctx, desc, regions);
+  }
+
+  @Override
+  public void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
+    throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preDeleteTable(ctx, tableName);
+  }
+
+  @Override
+  public void preDeleteTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    TableName tableName) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preDeleteTableAction(ctx, tableName);
+  }
+
+  @Override
+  public void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    TableName tableName) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preTruncateTable(ctx, tableName);
+  }
+
+  @Override
+  public void preTruncateTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    TableName tableName) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preTruncateTableAction(ctx, tableName);
+  }
+
+  @Override
+  public TableDescriptor preModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    TableName tableName, TableDescriptor currentDescriptor, TableDescriptor newDescriptor)
+    throws IOException {
+    internalReadOnlyGuard();
+    return MasterObserver.super.preModifyTable(ctx, tableName, currentDescriptor, newDescriptor);
+  }
+
+  @Override
+  public String preModifyTableStoreFileTracker(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    TableName tableName, String dstSFT) throws IOException {
+    internalReadOnlyGuard();
+    return MasterObserver.super.preModifyTableStoreFileTracker(ctx, tableName, dstSFT);
+  }
+
+  @Override
+  public String preModifyColumnFamilyStoreFileTracker(
+    ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] family,
+    String dstSFT) throws IOException {
+    internalReadOnlyGuard();
+    return MasterObserver.super.preModifyColumnFamilyStoreFileTracker(ctx, tableName, family,
+      dstSFT);
+  }
+
+  @Override
+  public void preModifyTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    TableName tableName, TableDescriptor currentDescriptor, TableDescriptor newDescriptor)
+    throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preModifyTableAction(ctx, tableName, currentDescriptor, newDescriptor);
+  }
+
+  @Override
+  public void preSplitRegion(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
+    byte[] splitRow) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preSplitRegion(c, tableName, splitRow);
+  }
+
+  @Override
+  public void preSplitRegionAction(ObserverContext<MasterCoprocessorEnvironment> c,
+    TableName tableName, byte[] splitRow) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preSplitRegionAction(c, tableName, splitRow);
+  }
+
+  @Override
+  public void preSplitRegionBeforeMETAAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    byte[] splitKey, List<Mutation> metaEntries) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preSplitRegionBeforeMETAAction(ctx, splitKey, metaEntries);
+  }
+
+  @Override
+  public void preSplitRegionAfterMETAAction(ObserverContext<MasterCoprocessorEnvironment> ctx)
+    throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preSplitRegionAfterMETAAction(ctx);
+  }
+
+  @Override
+  public void preTruncateRegion(ObserverContext<MasterCoprocessorEnvironment> c,
+    RegionInfo regionInfo) {
+    try {
+      internalReadOnlyGuard();
+    } catch (IOException e) {
+      LOG.info("Region truncation of region {} not allowed in read-only mode",
+        regionInfo.getRegionNameAsString());
+    }
+    MasterObserver.super.preTruncateRegion(c, regionInfo);
+  }
+
+  @Override
+  public void preTruncateRegionAction(ObserverContext<MasterCoprocessorEnvironment> c,
+    RegionInfo regionInfo) {
+    try {
+      internalReadOnlyGuard();
+    } catch (IOException e) {
+      LOG.info("Region truncation of region {} not allowed in read-only mode",
+        regionInfo.getRegionNameAsString());
+    }
+    MasterObserver.super.preTruncateRegionAction(c, regionInfo);
+  }
+
+  @Override
+  public void preMergeRegionsAction(final ObserverContext<MasterCoprocessorEnvironment> ctx,
+    final RegionInfo[] regionsToMerge) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preMergeRegionsAction(ctx, regionsToMerge);
+  }
+
+  @Override
+  public void preMergeRegionsCommitAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    RegionInfo[] regionsToMerge, List<Mutation> metaEntries) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preMergeRegionsCommitAction(ctx, regionsToMerge, metaEntries);
+  }
+
+  @Override
+  public void preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    SnapshotDescription snapshot, TableDescriptor tableDescriptor) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preSnapshot(ctx, snapshot, tableDescriptor);
+  }
+
+  @Override
+  public void preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    SnapshotDescription snapshot, TableDescriptor tableDescriptor) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preCloneSnapshot(ctx, snapshot, tableDescriptor);
+  }
+
+  @Override
+  public void preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    SnapshotDescription snapshot, TableDescriptor tableDescriptor) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preRestoreSnapshot(ctx, snapshot, tableDescriptor);
+  }
+
+  @Override
+  public void preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    SnapshotDescription snapshot) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preDeleteSnapshot(ctx, snapshot);
+  }
+
+  @Override
+  public void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    NamespaceDescriptor ns) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preCreateNamespace(ctx, ns);
+  }
+
+  @Override
+  public void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    NamespaceDescriptor currentNsDescriptor, NamespaceDescriptor newNsDescriptor)
+    throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preModifyNamespace(ctx, currentNsDescriptor, newNsDescriptor);
+  }
+
+  @Override
+  public void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    String namespace) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preDeleteNamespace(ctx, namespace);
+  }
+
+  @Override
+  public void preMasterStoreFlush(ObserverContext<MasterCoprocessorEnvironment> ctx)
+    throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preMasterStoreFlush(ctx);
+  }
+
+  @Override
+  public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName,
+    GlobalQuotaSettings quotas) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preSetUserQuota(ctx, userName, quotas);
+  }
+
+  @Override
+  public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName,
+    TableName tableName, GlobalQuotaSettings quotas) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preSetUserQuota(ctx, userName, tableName, quotas);
+  }
+
+  @Override
+  public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName,
+    String namespace, GlobalQuotaSettings quotas) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preSetUserQuota(ctx, userName, namespace, quotas);
+  }
+
+  @Override
+  public void preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    TableName tableName, GlobalQuotaSettings quotas) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preSetTableQuota(ctx, tableName, quotas);
+  }
+
+  @Override
+  public void preSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    String namespace, GlobalQuotaSettings quotas) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preSetNamespaceQuota(ctx, namespace, quotas);
+  }
+
+  @Override
+  public void preSetRegionServerQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    String regionServer, GlobalQuotaSettings quotas) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preSetRegionServerQuota(ctx, regionServer, quotas);
+  }
+
+  @Override
+  public void preMergeRegions(final ObserverContext<MasterCoprocessorEnvironment> ctx,
+    final RegionInfo[] regionsToMerge) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preMergeRegions(ctx, regionsToMerge);
+  }
+
+  @Override
+  public void preMoveServersAndTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    Set<Address> servers, Set<TableName> tables, String targetGroup) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preMoveServersAndTables(ctx, servers, tables, targetGroup);
+  }
+
+  @Override
+  public void preMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    Set<Address> servers, String targetGroup) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preMoveServers(ctx, servers, targetGroup);
+  }
+
+  @Override
+  public void preMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    Set<TableName> tables, String targetGroup) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preMoveTables(ctx, tables, targetGroup);
+  }
+
+  @Override
+  public void preAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)
+    throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preAddRSGroup(ctx, name);
+  }
+
+  @Override
+  public void preRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)
+    throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preRemoveRSGroup(ctx, name);
+  }
+
+  @Override
+  public void preBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String groupName,
+    BalanceRequest request) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preBalanceRSGroup(ctx, groupName, request);
+  }
+
+  @Override
+  public void preRemoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    Set<Address> servers) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preRemoveServers(ctx, servers);
+  }
+
+  @Override
+  public void preRenameRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String oldName,
+    String newName) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preRenameRSGroup(ctx, oldName, newName);
+  }
+
+  @Override
+  public void preUpdateRSGroupConfig(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    String groupName, Map<String, String> configuration) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preUpdateRSGroupConfig(ctx, groupName, configuration);
+  }
+
+  @Override
+  public void preAddReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    String peerId, ReplicationPeerConfig peerConfig) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preAddReplicationPeer(ctx, peerId, peerConfig);
+  }
+
+  @Override
+  public void preRemoveReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    String peerId) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preRemoveReplicationPeer(ctx, peerId);
+  }
+
+  @Override
+  public void preEnableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    String peerId) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preEnableReplicationPeer(ctx, peerId);
+  }
+
+  @Override
+  public void preDisableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    String peerId) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preDisableReplicationPeer(ctx, peerId);
+  }
+
+  @Override
+  public void preUpdateReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    String peerId, ReplicationPeerConfig peerConfig) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preUpdateReplicationPeerConfig(ctx, peerId, peerConfig);
+  }
+
+  @Override
+  public void preTransitReplicationPeerSyncReplicationState(
+    ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId, SyncReplicationState state)
+    throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preTransitReplicationPeerSyncReplicationState(ctx, peerId, state);
+  }
+
+  @Override
+  public void preGrant(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    UserPermission userPermission, boolean mergeExistingPermissions) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preGrant(ctx, userPermission, mergeExistingPermissions);
+  }
+
+  @Override
+  public void preRevoke(ObserverContext<MasterCoprocessorEnvironment> ctx,
+    UserPermission userPermission) throws IOException {
+    internalReadOnlyGuard();
+    MasterObserver.super.preRevoke(ctx, userPermission);
+  }
+}
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/ReadOnlyController.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/ReadOnlyController.java
deleted file mode 100644
index 163d4267fae..00000000000
--- a/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/ReadOnlyController.java
+++ /dev/null
@@ -1,913 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.hadoop.hbase.security.access;
-
-import java.io.IOException;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import org.apache.hadoop.conf.Configuration;
-import org.apache.hadoop.fs.FileSystem;
-import org.apache.hadoop.fs.Path;
-import org.apache.hadoop.hbase.CompareOperator;
-import org.apache.hadoop.hbase.CoprocessorEnvironment;
-import org.apache.hadoop.hbase.DoNotRetryIOException;
-import org.apache.hadoop.hbase.HBaseInterfaceAudience;
-import org.apache.hadoop.hbase.HConstants;
-import org.apache.hadoop.hbase.NamespaceDescriptor;
-import org.apache.hadoop.hbase.TableName;
-import org.apache.hadoop.hbase.client.Append;
-import org.apache.hadoop.hbase.client.BalanceRequest;
-import org.apache.hadoop.hbase.client.CheckAndMutate;
-import org.apache.hadoop.hbase.client.CheckAndMutateResult;
-import org.apache.hadoop.hbase.client.Delete;
-import org.apache.hadoop.hbase.client.Durability;
-import org.apache.hadoop.hbase.client.Increment;
-import org.apache.hadoop.hbase.client.Mutation;
-import org.apache.hadoop.hbase.client.Put;
-import org.apache.hadoop.hbase.client.RegionInfo;
-import org.apache.hadoop.hbase.client.Result;
-import org.apache.hadoop.hbase.client.SnapshotDescription;
-import org.apache.hadoop.hbase.client.TableDescriptor;
-import org.apache.hadoop.hbase.conf.ConfigurationObserver;
-import org.apache.hadoop.hbase.coprocessor.BulkLoadObserver;
-import org.apache.hadoop.hbase.coprocessor.CoreCoprocessor;
-import org.apache.hadoop.hbase.coprocessor.EndpointObserver;
-import org.apache.hadoop.hbase.coprocessor.MasterCoprocessor;
-import org.apache.hadoop.hbase.coprocessor.MasterCoprocessorEnvironment;
-import org.apache.hadoop.hbase.coprocessor.MasterObserver;
-import org.apache.hadoop.hbase.coprocessor.ObserverContext;
-import org.apache.hadoop.hbase.coprocessor.RegionCoprocessor;
-import org.apache.hadoop.hbase.coprocessor.RegionCoprocessorEnvironment;
-import org.apache.hadoop.hbase.coprocessor.RegionObserver;
-import org.apache.hadoop.hbase.coprocessor.RegionServerCoprocessor;
-import org.apache.hadoop.hbase.coprocessor.RegionServerCoprocessorEnvironment;
-import org.apache.hadoop.hbase.coprocessor.RegionServerObserver;
-import org.apache.hadoop.hbase.filter.ByteArrayComparable;
-import org.apache.hadoop.hbase.filter.Filter;
-import org.apache.hadoop.hbase.master.MasterFileSystem;
-import org.apache.hadoop.hbase.master.MasterServices;
-import org.apache.hadoop.hbase.net.Address;
-import org.apache.hadoop.hbase.quotas.GlobalQuotaSettings;
-import org.apache.hadoop.hbase.regionserver.FlushLifeCycleTracker;
-import org.apache.hadoop.hbase.regionserver.InternalScanner;
-import org.apache.hadoop.hbase.regionserver.MiniBatchOperationInProgress;
-import org.apache.hadoop.hbase.regionserver.ScanOptions;
-import org.apache.hadoop.hbase.regionserver.ScanType;
-import org.apache.hadoop.hbase.regionserver.Store;
-import org.apache.hadoop.hbase.regionserver.StoreFile;
-import org.apache.hadoop.hbase.regionserver.compactions.CompactionLifeCycleTracker;
-import org.apache.hadoop.hbase.regionserver.compactions.CompactionRequest;
-import org.apache.hadoop.hbase.replication.ReplicationPeerConfig;
-import org.apache.hadoop.hbase.replication.SyncReplicationState;
-import org.apache.hadoop.hbase.util.FSUtils;
-import org.apache.hadoop.hbase.util.Pair;
-import org.apache.hadoop.hbase.wal.WALEdit;
-import org.apache.hadoop.hbase.wal.WALKey;
-import org.apache.yetus.audience.InterfaceAudience;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import org.apache.hbase.thirdparty.com.google.protobuf.Message;
-import org.apache.hbase.thirdparty.com.google.protobuf.Service;
-
-import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos;
-
-@CoreCoprocessor
-@InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.CONFIG)
-public class ReadOnlyController implements MasterCoprocessor, RegionCoprocessor, MasterObserver,
-  RegionObserver, RegionServerCoprocessor, RegionServerObserver, EndpointObserver, BulkLoadObserver,
-  ConfigurationObserver {
-
-  private static final Logger LOG = LoggerFactory.getLogger(ReadOnlyController.class);
-  private MasterServices masterServices;
-
-  private volatile boolean globalReadOnlyEnabled;
-
-  private void internalReadOnlyGuard() throws DoNotRetryIOException {
-    if (this.globalReadOnlyEnabled) {
-      throw new DoNotRetryIOException("Operation not allowed in Read-Only Mode");
-    }
-  }
-
-  private boolean isOnMeta(final ObserverContext<? extends RegionCoprocessorEnvironment> c) {
-    return TableName.isMetaTableName(c.getEnvironment().getRegionInfo().getTable());
-  }
-
-  @Override
-  public void start(CoprocessorEnvironment env) throws IOException {
-    if (env instanceof MasterCoprocessorEnvironment) {
-      this.masterServices = ((MasterCoprocessorEnvironment) env).getMasterServices();
-      LOG.info("ReadOnlyController obtained MasterServices reference from start().");
-    } else {
-      LOG.debug("ReadOnlyController loaded in a non-Master environment. "
-        + "File system operations for read-only state will not work.");
-    }
-    this.globalReadOnlyEnabled =
-      env.getConfiguration().getBoolean(HConstants.HBASE_GLOBAL_READONLY_ENABLED_KEY,
-        HConstants.HBASE_GLOBAL_READONLY_ENABLED_DEFAULT);
-  }
-
-  @Override
-  public void stop(CoprocessorEnvironment env) {
-  }
-
-  /* ---- RegionObserver Overrides ---- */
-  @Override
-  public Optional<RegionObserver> getRegionObserver() {
-    return Optional.of(this);
-  }
-
-  @Override
-  public void preFlushScannerOpen(ObserverContext<? extends RegionCoprocessorEnvironment> c,
-    Store store, ScanOptions options, FlushLifeCycleTracker tracker) throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    RegionObserver.super.preFlushScannerOpen(c, store, options, tracker);
-  }
-
-  @Override
-  public void preFlush(final ObserverContext<? extends RegionCoprocessorEnvironment> c,
-    FlushLifeCycleTracker tracker) throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    RegionObserver.super.preFlush(c, tracker);
-  }
-
-  @Override
-  public InternalScanner preFlush(ObserverContext<? extends RegionCoprocessorEnvironment> c,
-    Store store, InternalScanner scanner, FlushLifeCycleTracker tracker) throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    return RegionObserver.super.preFlush(c, store, scanner, tracker);
-  }
-
-  @Override
-  public void preMemStoreCompaction(ObserverContext<? extends RegionCoprocessorEnvironment> c,
-    Store store) throws IOException {
-    internalReadOnlyGuard();
-    RegionObserver.super.preMemStoreCompaction(c, store);
-  }
-
-  @Override
-  public void preMemStoreCompactionCompactScannerOpen(
-    ObserverContext<? extends RegionCoprocessorEnvironment> c, Store store, ScanOptions options)
-    throws IOException {
-    internalReadOnlyGuard();
-    RegionObserver.super.preMemStoreCompactionCompactScannerOpen(c, store, options);
-  }
-
-  @Override
-  public InternalScanner preMemStoreCompactionCompact(
-    ObserverContext<? extends RegionCoprocessorEnvironment> c, Store store, InternalScanner scanner)
-    throws IOException {
-    internalReadOnlyGuard();
-    return RegionObserver.super.preMemStoreCompactionCompact(c, store, scanner);
-  }
-
-  @Override
-  public void preCompactSelection(ObserverContext<? extends RegionCoprocessorEnvironment> c,
-    Store store, List<? extends StoreFile> candidates, CompactionLifeCycleTracker tracker)
-    throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    RegionObserver.super.preCompactSelection(c, store, candidates, tracker);
-  }
-
-  @Override
-  public void preCompactScannerOpen(ObserverContext<? extends RegionCoprocessorEnvironment> c,
-    Store store, ScanType scanType, ScanOptions options, CompactionLifeCycleTracker tracker,
-    CompactionRequest request) throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    RegionObserver.super.preCompactScannerOpen(c, store, scanType, options, tracker, request);
-  }
-
-  @Override
-  public InternalScanner preCompact(ObserverContext<? extends RegionCoprocessorEnvironment> c,
-    Store store, InternalScanner scanner, ScanType scanType, CompactionLifeCycleTracker tracker,
-    CompactionRequest request) throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    return RegionObserver.super.preCompact(c, store, scanner, scanType, tracker, request);
-  }
-
-  @Override
-  public void prePut(ObserverContext<? extends RegionCoprocessorEnvironment> c, Put put,
-    WALEdit edit, Durability durability) throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    RegionObserver.super.prePut(c, put, edit, durability);
-  }
-
-  @Override
-  public void prePut(ObserverContext<? extends RegionCoprocessorEnvironment> c, Put put,
-    WALEdit edit) throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    RegionObserver.super.prePut(c, put, edit);
-  }
-
-  @Override
-  public void preDelete(ObserverContext<? extends RegionCoprocessorEnvironment> c, Delete delete,
-    WALEdit edit, Durability durability) throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    RegionObserver.super.preDelete(c, delete, edit, durability);
-  }
-
-  @Override
-  public void preDelete(ObserverContext<? extends RegionCoprocessorEnvironment> c, Delete delete,
-    WALEdit edit) throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    RegionObserver.super.preDelete(c, delete, edit);
-  }
-
-  @Override
-  public void preBatchMutate(ObserverContext<? extends RegionCoprocessorEnvironment> c,
-    MiniBatchOperationInProgress<Mutation> miniBatchOp) throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    RegionObserver.super.preBatchMutate(c, miniBatchOp);
-  }
-
-  @Override
-  public boolean preCheckAndPut(ObserverContext<? extends RegionCoprocessorEnvironment> c,
-    byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator,
-    Put put, boolean result) throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    return RegionObserver.super.preCheckAndPut(c, row, family, qualifier, op, comparator, put,
-      result);
-  }
-
-  @Override
-  public boolean preCheckAndPut(ObserverContext<? extends RegionCoprocessorEnvironment> c,
-    byte[] row, Filter filter, Put put, boolean result) throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    return RegionObserver.super.preCheckAndPut(c, row, filter, put, result);
-  }
-
-  @Override
-  public boolean preCheckAndPutAfterRowLock(
-    ObserverContext<? extends RegionCoprocessorEnvironment> c, byte[] row, byte[] family,
-    byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Put put, boolean result)
-    throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    return RegionObserver.super.preCheckAndPutAfterRowLock(c, row, family, qualifier, op,
-      comparator, put, result);
-  }
-
-  @Override
-  public boolean preCheckAndPutAfterRowLock(
-    ObserverContext<? extends RegionCoprocessorEnvironment> c, byte[] row, Filter filter, Put put,
-    boolean result) throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    return RegionObserver.super.preCheckAndPutAfterRowLock(c, row, filter, put, result);
-  }
-
-  @Override
-  public boolean preCheckAndDelete(ObserverContext<? extends RegionCoprocessorEnvironment> c,
-    byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator,
-    Delete delete, boolean result) throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    return RegionObserver.super.preCheckAndDelete(c, row, family, qualifier, op, comparator, delete,
-      result);
-  }
-
-  @Override
-  public boolean preCheckAndDelete(ObserverContext<? extends RegionCoprocessorEnvironment> c,
-    byte[] row, Filter filter, Delete delete, boolean result) throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    return RegionObserver.super.preCheckAndDelete(c, row, filter, delete, result);
-  }
-
-  @Override
-  public boolean preCheckAndDeleteAfterRowLock(
-    ObserverContext<? extends RegionCoprocessorEnvironment> c, byte[] row, byte[] family,
-    byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Delete delete,
-    boolean result) throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    return RegionObserver.super.preCheckAndDeleteAfterRowLock(c, row, family, qualifier, op,
-      comparator, delete, result);
-  }
-
-  @Override
-  public boolean preCheckAndDeleteAfterRowLock(
-    ObserverContext<? extends RegionCoprocessorEnvironment> c, byte[] row, Filter filter,
-    Delete delete, boolean result) throws IOException {
-    if (!isOnMeta(c)) {
-      internalReadOnlyGuard();
-    }
-    return RegionObserver.super.preCheckAndDeleteAfterRowLock(c, row, filter, delete, result);
-  }
-
-  @Override
-  public CheckAndMutateResult preCheckAndMutate(
-    ObserverContext<? extends RegionCoprocessorEnvironment> c, CheckAndMutate checkAndMutate,
-    CheckAndMutateResult result) throws IOException {
-    internalReadOnlyGuard();
-    return RegionObserver.super.preCheckAndMutate(c, checkAndMutate, result);
-  }
-
-  @Override
-  public CheckAndMutateResult preCheckAndMutateAfterRowLock(
-    ObserverContext<? extends RegionCoprocessorEnvironment> c, CheckAndMutate checkAndMutate,
-    CheckAndMutateResult result) throws IOException {
-    internalReadOnlyGuard();
-    return RegionObserver.super.preCheckAndMutateAfterRowLock(c, checkAndMutate, result);
-  }
-
-  @Override
-  public Result preAppend(ObserverContext<? extends RegionCoprocessorEnvironment> c, Append append)
-    throws IOException {
-    internalReadOnlyGuard();
-    return RegionObserver.super.preAppend(c, append);
-  }
-
-  @Override
-  public Result preAppend(ObserverContext<? extends RegionCoprocessorEnvironment> c, Append append,
-    WALEdit edit) throws IOException {
-    internalReadOnlyGuard();
-    return RegionObserver.super.preAppend(c, append, edit);
-  }
-
-  @Override
-  public Result preAppendAfterRowLock(ObserverContext<? extends RegionCoprocessorEnvironment> c,
-    Append append) throws IOException {
-    internalReadOnlyGuard();
-    return RegionObserver.super.preAppendAfterRowLock(c, append);
-  }
-
-  @Override
-  public Result preIncrement(ObserverContext<? extends RegionCoprocessorEnvironment> c,
-    Increment increment) throws IOException {
-    internalReadOnlyGuard();
-    return RegionObserver.super.preIncrement(c, increment);
-  }
-
-  @Override
-  public Result preIncrement(ObserverContext<? extends RegionCoprocessorEnvironment> c,
-    Increment increment, WALEdit edit) throws IOException {
-    internalReadOnlyGuard();
-    return RegionObserver.super.preIncrement(c, increment, edit);
-  }
-
-  @Override
-  public Result preIncrementAfterRowLock(ObserverContext<? extends RegionCoprocessorEnvironment> c,
-    Increment increment) throws IOException {
-    internalReadOnlyGuard();
-    return RegionObserver.super.preIncrementAfterRowLock(c, increment);
-  }
-
-  @Override
-  public void preReplayWALs(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
-    RegionInfo info, Path edits) throws IOException {
-    internalReadOnlyGuard();
-    RegionObserver.super.preReplayWALs(ctx, info, edits);
-  }
-
-  @Override
-  public void preBulkLoadHFile(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
-    List<Pair<byte[], String>> familyPaths) throws IOException {
-    internalReadOnlyGuard();
-    RegionObserver.super.preBulkLoadHFile(ctx, familyPaths);
-  }
-
-  @Override
-  public void preCommitStoreFile(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
-    byte[] family, List<Pair<Path, Path>> pairs) throws IOException {
-    internalReadOnlyGuard();
-    RegionObserver.super.preCommitStoreFile(ctx, family, pairs);
-  }
-
-  @Override
-  public void preWALAppend(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, WALKey key,
-    WALEdit edit) throws IOException {
-    // Only allow this operation for meta table
-    if (!TableName.isMetaTableName(key.getTableName())) {
-      internalReadOnlyGuard();
-    }
-    RegionObserver.super.preWALAppend(ctx, key, edit);
-  }
-
-  /* ---- MasterObserver Overrides ---- */
-  @Override
-  public Optional<MasterObserver> getMasterObserver() {
-    return Optional.of(this);
-  }
-
-  @Override
-  public TableDescriptor preCreateTableRegionsInfos(
-    ObserverContext<MasterCoprocessorEnvironment> ctx, TableDescriptor desc) throws IOException {
-    internalReadOnlyGuard();
-    return MasterObserver.super.preCreateTableRegionsInfos(ctx, desc);
-  }
-
-  @Override
-  public void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    TableDescriptor desc, RegionInfo[] regions) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preCreateTable(ctx, desc, regions);
-  }
-
-  @Override
-  public void preCreateTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    TableDescriptor desc, RegionInfo[] regions) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preCreateTableAction(ctx, desc, regions);
-  }
-
-  @Override
-  public void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
-    throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preDeleteTable(ctx, tableName);
-  }
-
-  @Override
-  public void preDeleteTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    TableName tableName) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preDeleteTableAction(ctx, tableName);
-  }
-
-  @Override
-  public void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    TableName tableName) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preTruncateTable(ctx, tableName);
-  }
-
-  @Override
-  public void preTruncateTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    TableName tableName) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preTruncateTableAction(ctx, tableName);
-  }
-
-  @Override
-  public TableDescriptor preModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    TableName tableName, TableDescriptor currentDescriptor, TableDescriptor newDescriptor)
-    throws IOException {
-    internalReadOnlyGuard();
-    return MasterObserver.super.preModifyTable(ctx, tableName, currentDescriptor, newDescriptor);
-  }
-
-  @Override
-  public String preModifyTableStoreFileTracker(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    TableName tableName, String dstSFT) throws IOException {
-    internalReadOnlyGuard();
-    return MasterObserver.super.preModifyTableStoreFileTracker(ctx, tableName, dstSFT);
-  }
-
-  @Override
-  public String preModifyColumnFamilyStoreFileTracker(
-    ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] family,
-    String dstSFT) throws IOException {
-    internalReadOnlyGuard();
-    return MasterObserver.super.preModifyColumnFamilyStoreFileTracker(ctx, tableName, family,
-      dstSFT);
-  }
-
-  @Override
-  public void preModifyTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    TableName tableName, TableDescriptor currentDescriptor, TableDescriptor newDescriptor)
-    throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preModifyTableAction(ctx, tableName, currentDescriptor, newDescriptor);
-  }
-
-  @Override
-  public void preSplitRegion(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName,
-    byte[] splitRow) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preSplitRegion(c, tableName, splitRow);
-  }
-
-  @Override
-  public void preSplitRegionAction(ObserverContext<MasterCoprocessorEnvironment> c,
-    TableName tableName, byte[] splitRow) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preSplitRegionAction(c, tableName, splitRow);
-  }
-
-  @Override
-  public void preSplitRegionBeforeMETAAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    byte[] splitKey, List<Mutation> metaEntries) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preSplitRegionBeforeMETAAction(ctx, splitKey, metaEntries);
-  }
-
-  @Override
-  public void preSplitRegionAfterMETAAction(ObserverContext<MasterCoprocessorEnvironment> ctx)
-    throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preSplitRegionAfterMETAAction(ctx);
-  }
-
-  @Override
-  public void preTruncateRegion(ObserverContext<MasterCoprocessorEnvironment> c,
-    RegionInfo regionInfo) {
-    try {
-      internalReadOnlyGuard();
-    } catch (IOException e) {
-      LOG.info("Region truncation of region {} not allowed in read-only mode",
-        regionInfo.getRegionNameAsString());
-    }
-    MasterObserver.super.preTruncateRegion(c, regionInfo);
-  }
-
-  @Override
-  public void preTruncateRegionAction(ObserverContext<MasterCoprocessorEnvironment> c,
-    RegionInfo regionInfo) {
-    try {
-      internalReadOnlyGuard();
-    } catch (IOException e) {
-      LOG.info("Region truncation of region {} not allowed in read-only mode",
-        regionInfo.getRegionNameAsString());
-    }
-    MasterObserver.super.preTruncateRegionAction(c, regionInfo);
-  }
-
-  @Override
-  public void preMergeRegionsAction(final ObserverContext<MasterCoprocessorEnvironment> ctx,
-    final RegionInfo[] regionsToMerge) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preMergeRegionsAction(ctx, regionsToMerge);
-  }
-
-  @Override
-  public void preMergeRegionsCommitAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    RegionInfo[] regionsToMerge, List<Mutation> metaEntries) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preMergeRegionsCommitAction(ctx, regionsToMerge, metaEntries);
-  }
-
-  @Override
-  public void preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    SnapshotDescription snapshot, TableDescriptor tableDescriptor) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preSnapshot(ctx, snapshot, tableDescriptor);
-  }
-
-  @Override
-  public void preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    SnapshotDescription snapshot, TableDescriptor tableDescriptor) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preCloneSnapshot(ctx, snapshot, tableDescriptor);
-  }
-
-  @Override
-  public void preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    SnapshotDescription snapshot, TableDescriptor tableDescriptor) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preRestoreSnapshot(ctx, snapshot, tableDescriptor);
-  }
-
-  @Override
-  public void preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    SnapshotDescription snapshot) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preDeleteSnapshot(ctx, snapshot);
-  }
-
-  @Override
-  public void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    NamespaceDescriptor ns) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preCreateNamespace(ctx, ns);
-  }
-
-  @Override
-  public void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    NamespaceDescriptor currentNsDescriptor, NamespaceDescriptor newNsDescriptor)
-    throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preModifyNamespace(ctx, currentNsDescriptor, newNsDescriptor);
-  }
-
-  @Override
-  public void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    String namespace) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preDeleteNamespace(ctx, namespace);
-  }
-
-  @Override
-  public void preMasterStoreFlush(ObserverContext<MasterCoprocessorEnvironment> ctx)
-    throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preMasterStoreFlush(ctx);
-  }
-
-  @Override
-  public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName,
-    GlobalQuotaSettings quotas) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preSetUserQuota(ctx, userName, quotas);
-  }
-
-  @Override
-  public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName,
-    TableName tableName, GlobalQuotaSettings quotas) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preSetUserQuota(ctx, userName, tableName, quotas);
-  }
-
-  @Override
-  public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName,
-    String namespace, GlobalQuotaSettings quotas) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preSetUserQuota(ctx, userName, namespace, quotas);
-  }
-
-  @Override
-  public void preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    TableName tableName, GlobalQuotaSettings quotas) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preSetTableQuota(ctx, tableName, quotas);
-  }
-
-  @Override
-  public void preSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    String namespace, GlobalQuotaSettings quotas) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preSetNamespaceQuota(ctx, namespace, quotas);
-  }
-
-  @Override
-  public void preSetRegionServerQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    String regionServer, GlobalQuotaSettings quotas) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preSetRegionServerQuota(ctx, regionServer, quotas);
-  }
-
-  @Override
-  public void preMergeRegions(final ObserverContext<MasterCoprocessorEnvironment> ctx,
-    final RegionInfo[] regionsToMerge) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preMergeRegions(ctx, regionsToMerge);
-  }
-
-  @Override
-  public void preMoveServersAndTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    Set<Address> servers, Set<TableName> tables, String targetGroup) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preMoveServersAndTables(ctx, servers, tables, targetGroup);
-  }
-
-  @Override
-  public void preMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    Set<Address> servers, String targetGroup) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preMoveServers(ctx, servers, targetGroup);
-  }
-
-  @Override
-  public void preMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    Set<TableName> tables, String targetGroup) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preMoveTables(ctx, tables, targetGroup);
-  }
-
-  @Override
-  public void preAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)
-    throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preAddRSGroup(ctx, name);
-  }
-
-  @Override
-  public void preRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)
-    throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preRemoveRSGroup(ctx, name);
-  }
-
-  @Override
-  public void preBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String groupName,
-    BalanceRequest request) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preBalanceRSGroup(ctx, groupName, request);
-  }
-
-  @Override
-  public void preRemoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    Set<Address> servers) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preRemoveServers(ctx, servers);
-  }
-
-  @Override
-  public void preRenameRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String oldName,
-    String newName) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preRenameRSGroup(ctx, oldName, newName);
-  }
-
-  @Override
-  public void preUpdateRSGroupConfig(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    String groupName, Map<String, String> configuration) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preUpdateRSGroupConfig(ctx, groupName, configuration);
-  }
-
-  @Override
-  public void preAddReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    String peerId, ReplicationPeerConfig peerConfig) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preAddReplicationPeer(ctx, peerId, peerConfig);
-  }
-
-  @Override
-  public void preRemoveReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    String peerId) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preRemoveReplicationPeer(ctx, peerId);
-  }
-
-  @Override
-  public void preEnableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    String peerId) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preEnableReplicationPeer(ctx, peerId);
-  }
-
-  @Override
-  public void preDisableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    String peerId) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preDisableReplicationPeer(ctx, peerId);
-  }
-
-  @Override
-  public void preUpdateReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    String peerId, ReplicationPeerConfig peerConfig) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preUpdateReplicationPeerConfig(ctx, peerId, peerConfig);
-  }
-
-  @Override
-  public void preTransitReplicationPeerSyncReplicationState(
-    ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId, SyncReplicationState state)
-    throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preTransitReplicationPeerSyncReplicationState(ctx, peerId, state);
-  }
-
-  @Override
-  public void preGrant(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    UserPermission userPermission, boolean mergeExistingPermissions) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preGrant(ctx, userPermission, mergeExistingPermissions);
-  }
-
-  @Override
-  public void preRevoke(ObserverContext<MasterCoprocessorEnvironment> ctx,
-    UserPermission userPermission) throws IOException {
-    internalReadOnlyGuard();
-    MasterObserver.super.preRevoke(ctx, userPermission);
-  }
-
-  /* ---- RegionServerObserver Overrides ---- */
-  @Override
-  public void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
-    throws IOException {
-    internalReadOnlyGuard();
-    RegionServerObserver.super.preRollWALWriterRequest(ctx);
-  }
-
-  @Override
-  public void preExecuteProcedures(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
-    throws IOException {
-    internalReadOnlyGuard();
-    RegionServerObserver.super.preExecuteProcedures(ctx);
-  }
-
-  @Override
-  public void preReplicationSinkBatchMutate(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
-    AdminProtos.WALEntry walEntry, Mutation mutation) throws IOException {
-    internalReadOnlyGuard();
-    RegionServerObserver.super.preReplicationSinkBatchMutate(ctx, walEntry, mutation);
-  }
-
-  @Override
-  public void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
-    throws IOException {
-    internalReadOnlyGuard();
-    RegionServerObserver.super.preReplicateLogEntries(ctx);
-  }
-
-  /* ---- EndpointObserver Overrides ---- */
-  @Override
-  public Message preEndpointInvocation(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
-    Service service, String methodName, Message request) throws IOException {
-    internalReadOnlyGuard();
-    return EndpointObserver.super.preEndpointInvocation(ctx, service, methodName, request);
-  }
-
-  /* ---- BulkLoadObserver Overrides ---- */
-  @Override
-  public void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx)
-    throws IOException {
-    internalReadOnlyGuard();
-    BulkLoadObserver.super.prePrepareBulkLoad(ctx);
-  }
-
-  @Override
-  public void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx)
-    throws IOException {
-    internalReadOnlyGuard();
-    BulkLoadObserver.super.preCleanupBulkLoad(ctx);
-  }
-
-  private void manageActiveClusterIdFile(boolean newValue) {
-    MasterFileSystem mfs = this.masterServices.getMasterFileSystem();
-    FileSystem fs = mfs.getFileSystem();
-    Path rootDir = mfs.getRootDir();
-    Path activeClusterFile = new Path(rootDir, HConstants.ACTIVE_CLUSTER_SUFFIX_FILE_NAME);
-
-    try {
-      if (newValue) {
-        // ENABLING READ-ONLY (false -> true), delete the active cluster file.
-        LOG.debug("Global read-only mode is being ENABLED. Deleting active cluster file: {}",
-          activeClusterFile);
-        try {
-          fs.delete(activeClusterFile, false);
-          LOG.info("Successfully deleted active cluster file: {}", activeClusterFile);
-        } catch (IOException e) {
-          LOG.error(
-            "Failed to delete active cluster file: {}. "
-              + "Read-only flag will be updated, but file system state is inconsistent.",
-            activeClusterFile);
-        }
-      } else {
-        // DISABLING READ-ONLY (true -> false), create the active cluster file id file
-        int wait = mfs.getConfiguration().getInt(HConstants.THREAD_WAKE_FREQUENCY, 10 * 1000);
-        FSUtils.setActiveClusterSuffix(fs, rootDir, mfs.getSuffixFileDataToWrite(), wait);
-      }
-    } catch (IOException e) {
-      // We still update the flag, but log that the operation failed.
-      LOG.error("Failed to perform file operation for read-only switch. "
-        + "Flag will be updated, but file system state may be inconsistent.", e);
-    }
-  }
-
-  /* ---- ConfigurationObserver Overrides ---- */
-  public void onConfigurationChange(Configuration conf) {
-    boolean maybeUpdatedConfValue = conf.getBoolean(HConstants.HBASE_GLOBAL_READONLY_ENABLED_KEY,
-      HConstants.HBASE_GLOBAL_READONLY_ENABLED_DEFAULT);
-    if (this.globalReadOnlyEnabled != maybeUpdatedConfValue) {
-      if (this.masterServices != null) {
-        manageActiveClusterIdFile(maybeUpdatedConfValue);
-      } else {
-        LOG.debug("Global R/O flag changed, but not running on master");
-      }
-      this.globalReadOnlyEnabled = maybeUpdatedConfValue;
-      LOG.info("Config {} has been dynamically changed to {}.",
-        HConstants.HBASE_GLOBAL_READONLY_ENABLED_KEY, this.globalReadOnlyEnabled);
-    }
-  }
-}
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/RegionReadOnlyController.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/RegionReadOnlyController.java
new file mode 100644
index 00000000000..ecd2dcedd64
--- /dev/null
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/RegionReadOnlyController.java
@@ -0,0 +1,369 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.security.access;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Optional;
+import org.apache.hadoop.fs.Path;
+import org.apache.hadoop.hbase.CompareOperator;
+import org.apache.hadoop.hbase.HBaseInterfaceAudience;
+import org.apache.hadoop.hbase.TableName;
+import org.apache.hadoop.hbase.client.Append;
+import org.apache.hadoop.hbase.client.CheckAndMutate;
+import org.apache.hadoop.hbase.client.CheckAndMutateResult;
+import org.apache.hadoop.hbase.client.Delete;
+import org.apache.hadoop.hbase.client.Durability;
+import org.apache.hadoop.hbase.client.Increment;
+import org.apache.hadoop.hbase.client.Mutation;
+import org.apache.hadoop.hbase.client.Put;
+import org.apache.hadoop.hbase.client.RegionInfo;
+import org.apache.hadoop.hbase.client.Result;
+import org.apache.hadoop.hbase.coprocessor.CoreCoprocessor;
+import org.apache.hadoop.hbase.coprocessor.ObserverContext;
+import org.apache.hadoop.hbase.coprocessor.RegionCoprocessor;
+import org.apache.hadoop.hbase.coprocessor.RegionCoprocessorEnvironment;
+import org.apache.hadoop.hbase.coprocessor.RegionObserver;
+import org.apache.hadoop.hbase.filter.ByteArrayComparable;
+import org.apache.hadoop.hbase.filter.Filter;
+import org.apache.hadoop.hbase.regionserver.FlushLifeCycleTracker;
+import org.apache.hadoop.hbase.regionserver.InternalScanner;
+import org.apache.hadoop.hbase.regionserver.MiniBatchOperationInProgress;
+import org.apache.hadoop.hbase.regionserver.ScanOptions;
+import org.apache.hadoop.hbase.regionserver.ScanType;
+import org.apache.hadoop.hbase.regionserver.Store;
+import org.apache.hadoop.hbase.regionserver.StoreFile;
+import org.apache.hadoop.hbase.regionserver.compactions.CompactionLifeCycleTracker;
+import org.apache.hadoop.hbase.regionserver.compactions.CompactionRequest;
+import org.apache.hadoop.hbase.util.Pair;
+import org.apache.hadoop.hbase.wal.WALEdit;
+import org.apache.hadoop.hbase.wal.WALKey;
+import org.apache.yetus.audience.InterfaceAudience;
+
+@CoreCoprocessor
+@InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.CONFIG)
+public class RegionReadOnlyController extends AbstractReadOnlyController
+  implements RegionCoprocessor, RegionObserver {
+
+  private boolean isOnMeta(final ObserverContext<? extends RegionCoprocessorEnvironment> c) {
+    return TableName.isMetaTableName(c.getEnvironment().getRegionInfo().getTable());
+  }
+
+  @Override
+  public Optional<RegionObserver> getRegionObserver() {
+    return Optional.of(this);
+  }
+
+  @Override
+  public void preFlushScannerOpen(ObserverContext<? extends RegionCoprocessorEnvironment> c,
+    Store store, ScanOptions options, FlushLifeCycleTracker tracker) throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    RegionObserver.super.preFlushScannerOpen(c, store, options, tracker);
+  }
+
+  @Override
+  public void preFlush(final ObserverContext<? extends RegionCoprocessorEnvironment> c,
+    FlushLifeCycleTracker tracker) throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    RegionObserver.super.preFlush(c, tracker);
+  }
+
+  @Override
+  public InternalScanner preFlush(ObserverContext<? extends RegionCoprocessorEnvironment> c,
+    Store store, InternalScanner scanner, FlushLifeCycleTracker tracker) throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    return RegionObserver.super.preFlush(c, store, scanner, tracker);
+  }
+
+  @Override
+  public void preMemStoreCompaction(ObserverContext<? extends RegionCoprocessorEnvironment> c,
+    Store store) throws IOException {
+    internalReadOnlyGuard();
+    RegionObserver.super.preMemStoreCompaction(c, store);
+  }
+
+  @Override
+  public void preMemStoreCompactionCompactScannerOpen(
+    ObserverContext<? extends RegionCoprocessorEnvironment> c, Store store, ScanOptions options)
+    throws IOException {
+    internalReadOnlyGuard();
+    RegionObserver.super.preMemStoreCompactionCompactScannerOpen(c, store, options);
+  }
+
+  @Override
+  public InternalScanner preMemStoreCompactionCompact(
+    ObserverContext<? extends RegionCoprocessorEnvironment> c, Store store, InternalScanner scanner)
+    throws IOException {
+    internalReadOnlyGuard();
+    return RegionObserver.super.preMemStoreCompactionCompact(c, store, scanner);
+  }
+
+  @Override
+  public void preCompactSelection(ObserverContext<? extends RegionCoprocessorEnvironment> c,
+    Store store, List<? extends StoreFile> candidates, CompactionLifeCycleTracker tracker)
+    throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    RegionObserver.super.preCompactSelection(c, store, candidates, tracker);
+  }
+
+  @Override
+  public void preCompactScannerOpen(ObserverContext<? extends RegionCoprocessorEnvironment> c,
+    Store store, ScanType scanType, ScanOptions options, CompactionLifeCycleTracker tracker,
+    CompactionRequest request) throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    RegionObserver.super.preCompactScannerOpen(c, store, scanType, options, tracker, request);
+  }
+
+  @Override
+  public InternalScanner preCompact(ObserverContext<? extends RegionCoprocessorEnvironment> c,
+    Store store, InternalScanner scanner, ScanType scanType, CompactionLifeCycleTracker tracker,
+    CompactionRequest request) throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    return RegionObserver.super.preCompact(c, store, scanner, scanType, tracker, request);
+  }
+
+  @Override
+  public void prePut(ObserverContext<? extends RegionCoprocessorEnvironment> c, Put put,
+    WALEdit edit, Durability durability) throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    RegionObserver.super.prePut(c, put, edit, durability);
+  }
+
+  @Override
+  public void prePut(ObserverContext<? extends RegionCoprocessorEnvironment> c, Put put,
+    WALEdit edit) throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    RegionObserver.super.prePut(c, put, edit);
+  }
+
+  @Override
+  public void preDelete(ObserverContext<? extends RegionCoprocessorEnvironment> c, Delete delete,
+    WALEdit edit, Durability durability) throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    RegionObserver.super.preDelete(c, delete, edit, durability);
+  }
+
+  @Override
+  public void preDelete(ObserverContext<? extends RegionCoprocessorEnvironment> c, Delete delete,
+    WALEdit edit) throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    RegionObserver.super.preDelete(c, delete, edit);
+  }
+
+  @Override
+  public void preBatchMutate(ObserverContext<? extends RegionCoprocessorEnvironment> c,
+    MiniBatchOperationInProgress<Mutation> miniBatchOp) throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    RegionObserver.super.preBatchMutate(c, miniBatchOp);
+  }
+
+  @Override
+  public boolean preCheckAndPut(ObserverContext<? extends RegionCoprocessorEnvironment> c,
+    byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator,
+    Put put, boolean result) throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    return RegionObserver.super.preCheckAndPut(c, row, family, qualifier, op, comparator, put,
+      result);
+  }
+
+  @Override
+  public boolean preCheckAndPut(ObserverContext<? extends RegionCoprocessorEnvironment> c,
+    byte[] row, Filter filter, Put put, boolean result) throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    return RegionObserver.super.preCheckAndPut(c, row, filter, put, result);
+  }
+
+  @Override
+  public boolean preCheckAndPutAfterRowLock(
+    ObserverContext<? extends RegionCoprocessorEnvironment> c, byte[] row, byte[] family,
+    byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Put put, boolean result)
+    throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    return RegionObserver.super.preCheckAndPutAfterRowLock(c, row, family, qualifier, op,
+      comparator, put, result);
+  }
+
+  @Override
+  public boolean preCheckAndPutAfterRowLock(
+    ObserverContext<? extends RegionCoprocessorEnvironment> c, byte[] row, Filter filter, Put put,
+    boolean result) throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    return RegionObserver.super.preCheckAndPutAfterRowLock(c, row, filter, put, result);
+  }
+
+  @Override
+  public boolean preCheckAndDelete(ObserverContext<? extends RegionCoprocessorEnvironment> c,
+    byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator,
+    Delete delete, boolean result) throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    return RegionObserver.super.preCheckAndDelete(c, row, family, qualifier, op, comparator, delete,
+      result);
+  }
+
+  @Override
+  public boolean preCheckAndDelete(ObserverContext<? extends RegionCoprocessorEnvironment> c,
+    byte[] row, Filter filter, Delete delete, boolean result) throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    return RegionObserver.super.preCheckAndDelete(c, row, filter, delete, result);
+  }
+
+  @Override
+  public boolean preCheckAndDeleteAfterRowLock(
+    ObserverContext<? extends RegionCoprocessorEnvironment> c, byte[] row, byte[] family,
+    byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Delete delete,
+    boolean result) throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    return RegionObserver.super.preCheckAndDeleteAfterRowLock(c, row, family, qualifier, op,
+      comparator, delete, result);
+  }
+
+  @Override
+  public boolean preCheckAndDeleteAfterRowLock(
+    ObserverContext<? extends RegionCoprocessorEnvironment> c, byte[] row, Filter filter,
+    Delete delete, boolean result) throws IOException {
+    if (!isOnMeta(c)) {
+      internalReadOnlyGuard();
+    }
+    return RegionObserver.super.preCheckAndDeleteAfterRowLock(c, row, filter, delete, result);
+  }
+
+  @Override
+  public CheckAndMutateResult preCheckAndMutate(
+    ObserverContext<? extends RegionCoprocessorEnvironment> c, CheckAndMutate checkAndMutate,
+    CheckAndMutateResult result) throws IOException {
+    internalReadOnlyGuard();
+    return RegionObserver.super.preCheckAndMutate(c, checkAndMutate, result);
+  }
+
+  @Override
+  public CheckAndMutateResult preCheckAndMutateAfterRowLock(
+    ObserverContext<? extends RegionCoprocessorEnvironment> c, CheckAndMutate checkAndMutate,
+    CheckAndMutateResult result) throws IOException {
+    internalReadOnlyGuard();
+    return RegionObserver.super.preCheckAndMutateAfterRowLock(c, checkAndMutate, result);
+  }
+
+  @Override
+  public Result preAppend(ObserverContext<? extends RegionCoprocessorEnvironment> c, Append append)
+    throws IOException {
+    internalReadOnlyGuard();
+    return RegionObserver.super.preAppend(c, append);
+  }
+
+  @Override
+  public Result preAppend(ObserverContext<? extends RegionCoprocessorEnvironment> c, Append append,
+    WALEdit edit) throws IOException {
+    internalReadOnlyGuard();
+    return RegionObserver.super.preAppend(c, append, edit);
+  }
+
+  @Override
+  public Result preAppendAfterRowLock(ObserverContext<? extends RegionCoprocessorEnvironment> c,
+    Append append) throws IOException {
+    internalReadOnlyGuard();
+    return RegionObserver.super.preAppendAfterRowLock(c, append);
+  }
+
+  @Override
+  public Result preIncrement(ObserverContext<? extends RegionCoprocessorEnvironment> c,
+    Increment increment) throws IOException {
+    internalReadOnlyGuard();
+    return RegionObserver.super.preIncrement(c, increment);
+  }
+
+  @Override
+  public Result preIncrement(ObserverContext<? extends RegionCoprocessorEnvironment> c,
+    Increment increment, WALEdit edit) throws IOException {
+    internalReadOnlyGuard();
+    return RegionObserver.super.preIncrement(c, increment, edit);
+  }
+
+  @Override
+  public Result preIncrementAfterRowLock(ObserverContext<? extends RegionCoprocessorEnvironment> c,
+    Increment increment) throws IOException {
+    internalReadOnlyGuard();
+    return RegionObserver.super.preIncrementAfterRowLock(c, increment);
+  }
+
+  @Override
+  public void preReplayWALs(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
+    RegionInfo info, Path edits) throws IOException {
+    internalReadOnlyGuard();
+    RegionObserver.super.preReplayWALs(ctx, info, edits);
+  }
+
+  @Override
+  public void preBulkLoadHFile(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
+    List<Pair<byte[], String>> familyPaths) throws IOException {
+    internalReadOnlyGuard();
+    RegionObserver.super.preBulkLoadHFile(ctx, familyPaths);
+  }
+
+  @Override
+  public void preCommitStoreFile(ObserverContext<? extends RegionCoprocessorEnvironment> ctx,
+    byte[] family, List<Pair<Path, Path>> pairs) throws IOException {
+    internalReadOnlyGuard();
+    RegionObserver.super.preCommitStoreFile(ctx, family, pairs);
+  }
+
+  @Override
+  public void preWALAppend(ObserverContext<? extends RegionCoprocessorEnvironment> ctx, WALKey key,
+    WALEdit edit) throws IOException {
+    // Only allow this operation for meta table
+    if (!TableName.isMetaTableName(key.getTableName())) {
+      internalReadOnlyGuard();
+    }
+    RegionObserver.super.preWALAppend(ctx, key, edit);
+  }
+}
diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/RegionServerReadOnlyController.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/RegionServerReadOnlyController.java
new file mode 100644
index 00000000000..2cd69f6f0d9
--- /dev/null
+++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/access/RegionServerReadOnlyController.java
@@ -0,0 +1,64 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hbase.security.access;
+
+import java.io.IOException;
+import java.util.Optional;
+import org.apache.hadoop.hbase.HBaseInterfaceAudience;
+import org.apache.hadoop.hbase.client.Mutation;
+import org.apache.hadoop.hbase.coprocessor.CoreCoprocessor;
+import org.apache.hadoop.hbase.coprocessor.ObserverContext;
+import org.apache.hadoop.hbase.coprocessor.RegionServerCoprocessor;
+import org.apache.hadoop.hbase.coprocessor.RegionServerCoprocessorEnvironment;
+import org.apache.hadoop.hbase.coprocessor.RegionServerObserver;
+import org.apache.yetus.audience.InterfaceAudience;
+
+import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos;
+
+@CoreCoprocessor
+@InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.CONFIG)
+public class RegionServerReadOnlyController extends AbstractReadOnlyController
+  implements RegionServerObserver, RegionServerCoprocessor {
+
+  @Override
+  public Optional<RegionServerObserver> getRegionServerObserver() {
+    return Optional.of(this);
+  }
+
+  @Override
+  public void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
+    throws IOException {
+    internalReadOnlyGuard();
+    RegionServerObserver.super.preRollWALWriterRequest(ctx);
+  }
+
+  @Override
+  public void preReplicationSinkBatchMutate(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
+    AdminProtos.WALEntry walEntry, Mutation mutation) throws IOException {
+    internalReadOnlyGuard();
+    RegionServerObserver.super.preReplicationSinkBatchMutate(ctx, walEntry, mutation);
+  }
+
+  @Override
+  public void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
+    throws IOException {
+    internalReadOnlyGuard();
+    RegionServerObserver.super.preReplicateLogEntries(ctx);
+  }
+
+}
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/TestRefreshHFilesBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/TestRefreshHFilesBase.java
index 3d9f188242d..b18503aa68c 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/TestRefreshHFilesBase.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/TestRefreshHFilesBase.java
@@ -32,7 +32,11 @@ import org.apache.hadoop.hbase.master.procedure.RefreshHFilesTableProcedure;
 import org.apache.hadoop.hbase.procedure2.ProcedureExecutor;
 import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility;
 import org.apache.hadoop.hbase.regionserver.HRegionServer;
-import org.apache.hadoop.hbase.security.access.ReadOnlyController;
+import org.apache.hadoop.hbase.security.access.BulkLoadReadOnlyController;
+import org.apache.hadoop.hbase.security.access.EndpointReadOnlyController;
+import org.apache.hadoop.hbase.security.access.MasterReadOnlyController;
+import org.apache.hadoop.hbase.security.access.RegionReadOnlyController;
+import org.apache.hadoop.hbase.security.access.RegionServerReadOnlyController;
 import org.apache.hadoop.hbase.util.Bytes;
 import org.apache.hadoop.hbase.util.JVMClusterUtil;
 import org.slf4j.Logger;
@@ -120,8 +124,14 @@ public class TestRefreshHFilesBase {
 
   private void setupReadOnlyConf(boolean addReadOnlyConf) {
     if (!addReadOnlyConf) return;
-    conf.set(CoprocessorHost.MASTER_COPROCESSOR_CONF_KEY, ReadOnlyController.class.getName());
-    conf.set(CoprocessorHost.REGION_COPROCESSOR_CONF_KEY, ReadOnlyController.class.getName());
+    // Configure the cluster with ReadOnlyControllers
+    TEST_UTIL.getConfiguration().set(CoprocessorHost.MASTER_COPROCESSOR_CONF_KEY,
+      MasterReadOnlyController.class.getName());
+    TEST_UTIL.getConfiguration().set(CoprocessorHost.REGION_COPROCESSOR_CONF_KEY,
+      String.join(",", RegionReadOnlyController.class.getName(),
+        BulkLoadReadOnlyController.class.getName(), EndpointReadOnlyController.class.getName()));
+    TEST_UTIL.getConfiguration().set(CoprocessorHost.REGIONSERVER_COPROCESSOR_CONF_KEY,
+      RegionServerReadOnlyController.class.getName());
     // Keep ReadOnly property to false at the beginning so that create table succeed.
     conf.setBoolean(HConstants.HBASE_GLOBAL_READONLY_ENABLED_KEY, false);
   }
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestRefreshMetaProcedureIntegration.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestRefreshMetaProcedureIntegration.java
index 917c12c6513..d0fced61975 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestRefreshMetaProcedureIntegration.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestRefreshMetaProcedureIntegration.java
@@ -47,7 +47,11 @@ import org.apache.hadoop.hbase.master.HMaster;
 import org.apache.hadoop.hbase.procedure2.ProcedureExecutor;
 import org.apache.hadoop.hbase.regionserver.HRegionFileSystem;
 import org.apache.hadoop.hbase.regionserver.HRegionServer;
-import org.apache.hadoop.hbase.security.access.ReadOnlyController;
+import org.apache.hadoop.hbase.security.access.BulkLoadReadOnlyController;
+import org.apache.hadoop.hbase.security.access.EndpointReadOnlyController;
+import org.apache.hadoop.hbase.security.access.MasterReadOnlyController;
+import org.apache.hadoop.hbase.security.access.RegionReadOnlyController;
+import org.apache.hadoop.hbase.security.access.RegionServerReadOnlyController;
 import org.apache.hadoop.hbase.testclassification.LargeTests;
 import org.apache.hadoop.hbase.testclassification.MasterTests;
 import org.apache.hadoop.hbase.util.Bytes;
@@ -73,13 +77,14 @@ public class TestRefreshMetaProcedureIntegration {
 
   @Before
   public void setup() throws Exception {
-    // Configure the cluster with ReadOnlyController
+    // Configure the cluster with ReadOnlyControllers
     TEST_UTIL.getConfiguration().set(CoprocessorHost.MASTER_COPROCESSOR_CONF_KEY,
-      ReadOnlyController.class.getName());
-    TEST_UTIL.getConfiguration().set(CoprocessorHost.REGIONSERVER_COPROCESSOR_CONF_KEY,
-      ReadOnlyController.class.getName());
+      MasterReadOnlyController.class.getName());
     TEST_UTIL.getConfiguration().set(CoprocessorHost.REGION_COPROCESSOR_CONF_KEY,
-      ReadOnlyController.class.getName());
+      String.join(",", RegionReadOnlyController.class.getName(),
+        BulkLoadReadOnlyController.class.getName(), EndpointReadOnlyController.class.getName()));
+    TEST_UTIL.getConfiguration().set(CoprocessorHost.REGIONSERVER_COPROCESSOR_CONF_KEY,
+      RegionServerReadOnlyController.class.getName());
 
     // Start in active mode
     TEST_UTIL.getConfiguration().setBoolean(HConstants.HBASE_GLOBAL_READONLY_ENABLED_KEY, false);
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestCanStartHBaseInReadOnlyMode.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestCanStartHBaseInReadOnlyMode.java
index ed182edbe91..8607b170808 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestCanStartHBaseInReadOnlyMode.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestCanStartHBaseInReadOnlyMode.java
@@ -37,7 +37,6 @@ public class TestCanStartHBaseInReadOnlyMode {
   public static final HBaseClassTestRule CLASS_RULE =
     HBaseClassTestRule.forClass(TestCanStartHBaseInReadOnlyMode.class);
 
-  private static final String READ_ONLY_CONTROLLER_NAME = ReadOnlyController.class.getName();
   private static final HBaseTestingUtil TEST_UTIL = new HBaseTestingUtil();
   private static Configuration conf;
 
@@ -57,9 +56,13 @@ public class TestCanStartHBaseInReadOnlyMode {
     conf.setBoolean(HConstants.HBASE_GLOBAL_READONLY_ENABLED_KEY, true);
 
     // Add ReadOnlyController coprocessors to the master, region server, and regions
-    conf.set(CoprocessorHost.REGION_COPROCESSOR_CONF_KEY, READ_ONLY_CONTROLLER_NAME);
-    conf.set(CoprocessorHost.REGIONSERVER_COPROCESSOR_CONF_KEY, READ_ONLY_CONTROLLER_NAME);
-    conf.set(CoprocessorHost.MASTER_COPROCESSOR_CONF_KEY, READ_ONLY_CONTROLLER_NAME);
+    TEST_UTIL.getConfiguration().set(CoprocessorHost.MASTER_COPROCESSOR_CONF_KEY,
+      MasterReadOnlyController.class.getName());
+    TEST_UTIL.getConfiguration().set(CoprocessorHost.REGION_COPROCESSOR_CONF_KEY,
+      String.join(",", RegionReadOnlyController.class.getName(),
+        BulkLoadReadOnlyController.class.getName(), EndpointReadOnlyController.class.getName()));
+    TEST_UTIL.getConfiguration().set(CoprocessorHost.REGIONSERVER_COPROCESSOR_CONF_KEY,
+      RegionServerReadOnlyController.class.getName());
   }
 
   @AfterClass
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyController.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyController.java
index ff60bde88e5..c7853b8adac 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyController.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyController.java
@@ -65,7 +65,6 @@ public class TestReadOnlyController {
     HBaseClassTestRule.forClass(TestReadOnlyController.class);
 
   private static final Logger LOG = LoggerFactory.getLogger(TestReadOnlyController.class);
-  private static final String READ_ONLY_CONTROLLER_NAME = ReadOnlyController.class.getName();
   private static final HBaseTestingUtil TEST_UTIL = new HBaseTestingUtil();
   private static final TableName TEST_TABLE = TableName.valueOf("read_only_test_table");
   private static final byte[] TEST_FAMILY = Bytes.toBytes("read_only_table_col_fam");
@@ -95,9 +94,13 @@ public class TestReadOnlyController {
     conf.setBoolean(HConstants.HBASE_GLOBAL_READONLY_ENABLED_KEY, false);
 
     // Add ReadOnlyController coprocessors to the master, region server, and regions
-    conf.set(CoprocessorHost.REGION_COPROCESSOR_CONF_KEY, READ_ONLY_CONTROLLER_NAME);
-    conf.set(CoprocessorHost.REGIONSERVER_COPROCESSOR_CONF_KEY, READ_ONLY_CONTROLLER_NAME);
-    conf.set(CoprocessorHost.MASTER_COPROCESSOR_CONF_KEY, READ_ONLY_CONTROLLER_NAME);
+    TEST_UTIL.getConfiguration().set(CoprocessorHost.MASTER_COPROCESSOR_CONF_KEY,
+      MasterReadOnlyController.class.getName());
+    TEST_UTIL.getConfiguration().set(CoprocessorHost.REGION_COPROCESSOR_CONF_KEY,
+      String.join(",", RegionReadOnlyController.class.getName(),
+        BulkLoadReadOnlyController.class.getName(), EndpointReadOnlyController.class.getName()));
+    TEST_UTIL.getConfiguration().set(CoprocessorHost.REGIONSERVER_COPROCESSOR_CONF_KEY,
+      RegionServerReadOnlyController.class.getName());
 
     try {
       // Start the test cluster
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerBulkLoadObserver.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerBulkLoadObserver.java
index 598fd2fb8e1..46984217282 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerBulkLoadObserver.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerBulkLoadObserver.java
@@ -42,7 +42,7 @@ public class TestReadOnlyControllerBulkLoadObserver {
   public static final HBaseClassTestRule CLASS_RULE =
     HBaseClassTestRule.forClass(TestReadOnlyControllerBulkLoadObserver.class);
 
-  ReadOnlyController readOnlyController;
+  BulkLoadReadOnlyController bulkLoadReadOnlyController;
   HBaseConfiguration readOnlyConf;
 
   // Region Server Coprocessor mocking variables
@@ -50,7 +50,7 @@ public class TestReadOnlyControllerBulkLoadObserver {
 
   @Before
   public void setup() throws Exception {
-    readOnlyController = new ReadOnlyController();
+    bulkLoadReadOnlyController = new BulkLoadReadOnlyController();
     readOnlyConf = new HBaseConfiguration();
     readOnlyConf.setBoolean(HBASE_GLOBAL_READONLY_ENABLED_KEY, true);
 
@@ -65,23 +65,23 @@ public class TestReadOnlyControllerBulkLoadObserver {
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPrePrepareBulkLoadReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.prePrepareBulkLoad(ctx);
+    bulkLoadReadOnlyController.onConfigurationChange(readOnlyConf);
+    bulkLoadReadOnlyController.prePrepareBulkLoad(ctx);
   }
 
   @Test
   public void testPrePrepareBulkLoadNoException() throws IOException {
-    readOnlyController.prePrepareBulkLoad(ctx);
+    bulkLoadReadOnlyController.prePrepareBulkLoad(ctx);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCleanupBulkLoadReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCleanupBulkLoad(ctx);
+    bulkLoadReadOnlyController.onConfigurationChange(readOnlyConf);
+    bulkLoadReadOnlyController.preCleanupBulkLoad(ctx);
   }
 
   @Test
   public void testPreCleanupBulkLoadNoException() throws IOException {
-    readOnlyController.preCleanupBulkLoad(ctx);
+    bulkLoadReadOnlyController.preCleanupBulkLoad(ctx);
   }
 }
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerEndpointObserver.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerEndpointObserver.java
index 344a02a4ecb..2ea46236426 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerEndpointObserver.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerEndpointObserver.java
@@ -45,7 +45,7 @@ public class TestReadOnlyControllerEndpointObserver {
   public static final HBaseClassTestRule CLASS_RULE =
     HBaseClassTestRule.forClass(TestReadOnlyControllerEndpointObserver.class);
 
-  ReadOnlyController readOnlyController;
+  EndpointReadOnlyController endpointReadOnlyController;
   HBaseConfiguration readOnlyConf;
 
   // Region Server Coprocessor mocking variables.
@@ -56,7 +56,7 @@ public class TestReadOnlyControllerEndpointObserver {
 
   @Before
   public void setup() throws Exception {
-    readOnlyController = new ReadOnlyController();
+    endpointReadOnlyController = new EndpointReadOnlyController();
     readOnlyConf = new HBaseConfiguration();
     readOnlyConf.setBoolean(HBASE_GLOBAL_READONLY_ENABLED_KEY, true);
 
@@ -76,12 +76,12 @@ public class TestReadOnlyControllerEndpointObserver {
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreEndpointInvocationReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preEndpointInvocation(ctx, service, methodName, request);
+    endpointReadOnlyController.onConfigurationChange(readOnlyConf);
+    endpointReadOnlyController.preEndpointInvocation(ctx, service, methodName, request);
   }
 
   @Test
   public void testPreEndpointInvocationNoException() throws IOException {
-    readOnlyController.preEndpointInvocation(ctx, service, methodName, request);
+    endpointReadOnlyController.preEndpointInvocation(ctx, service, methodName, request);
   }
 }
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerMasterObserver.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerMasterObserver.java
index 2d324f5827a..04f98e9789f 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerMasterObserver.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerMasterObserver.java
@@ -58,7 +58,7 @@ public class TestReadOnlyControllerMasterObserver {
   public static final HBaseClassTestRule CLASS_RULE =
     HBaseClassTestRule.forClass(TestReadOnlyControllerMasterObserver.class);
 
-  ReadOnlyController readOnlyController;
+  MasterReadOnlyController MasterReadOnlyController;
   HBaseConfiguration readOnlyConf;
 
   // Master Coprocessor mocking variables
@@ -97,7 +97,7 @@ public class TestReadOnlyControllerMasterObserver {
 
   @Before
   public void setup() throws Exception {
-    readOnlyController = new ReadOnlyController();
+    MasterReadOnlyController = new MasterReadOnlyController();
     readOnlyConf = new HBaseConfiguration();
     readOnlyConf.setBoolean(HBASE_GLOBAL_READONLY_ENABLED_KEY, true);
 
@@ -152,541 +152,541 @@ public class TestReadOnlyControllerMasterObserver {
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCreateTableRegionsInfosReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCreateTableRegionsInfos(ctx, desc);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preCreateTableRegionsInfos(ctx, desc);
   }
 
   @Test
   public void testPreCreateTableRegionsInfosNoException() throws IOException {
-    readOnlyController.preCreateTableRegionsInfos(ctx, desc);
+    MasterReadOnlyController.preCreateTableRegionsInfos(ctx, desc);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCreateTableReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCreateTable(ctx, desc, regions);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preCreateTable(ctx, desc, regions);
   }
 
   @Test
   public void testPreCreateTableNoException() throws IOException {
-    readOnlyController.preCreateTable(ctx, desc, regions);
+    MasterReadOnlyController.preCreateTable(ctx, desc, regions);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCreateTableActionReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCreateTableAction(ctx, desc, regions);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preCreateTableAction(ctx, desc, regions);
   }
 
   @Test
   public void testPreCreateTableActionNoException() throws IOException {
-    readOnlyController.preCreateTableAction(ctx, desc, regions);
+    MasterReadOnlyController.preCreateTableAction(ctx, desc, regions);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreDeleteTableReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preDeleteTable(ctx, tableName);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preDeleteTable(ctx, tableName);
   }
 
   @Test
   public void testPreDeleteTableNoException() throws IOException {
-    readOnlyController.preDeleteTable(ctx, tableName);
+    MasterReadOnlyController.preDeleteTable(ctx, tableName);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreDeleteTableActionReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preDeleteTableAction(ctx, tableName);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preDeleteTableAction(ctx, tableName);
   }
 
   @Test
   public void testPreDeleteTableActionNoException() throws IOException {
-    readOnlyController.preDeleteTableAction(ctx, tableName);
+    MasterReadOnlyController.preDeleteTableAction(ctx, tableName);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreTruncateTableReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preTruncateTable(ctx, tableName);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preTruncateTable(ctx, tableName);
   }
 
   @Test
   public void testPreTruncateTableNoException() throws IOException {
-    readOnlyController.preTruncateTable(ctx, tableName);
+    MasterReadOnlyController.preTruncateTable(ctx, tableName);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreTruncateTableActionReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preTruncateTableAction(ctx, tableName);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preTruncateTableAction(ctx, tableName);
   }
 
   @Test
   public void testPreTruncateTableActionNoException() throws IOException {
-    readOnlyController.preTruncateTableAction(ctx, tableName);
+    MasterReadOnlyController.preTruncateTableAction(ctx, tableName);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreModifyTableReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preModifyTable(ctx, tableName, currentDescriptor, newDescriptor);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preModifyTable(ctx, tableName, currentDescriptor, newDescriptor);
   }
 
   @Test
   public void testPreModifyTableNoException() throws IOException {
-    readOnlyController.preModifyTable(ctx, tableName, currentDescriptor, newDescriptor);
+    MasterReadOnlyController.preModifyTable(ctx, tableName, currentDescriptor, newDescriptor);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreModifyTableStoreFileTrackerReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preModifyTableStoreFileTracker(ctx, tableName, dstSFT);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preModifyTableStoreFileTracker(ctx, tableName, dstSFT);
   }
 
   @Test
   public void testPreModifyTableStoreFileTrackerNoException() throws IOException {
-    readOnlyController.preModifyTableStoreFileTracker(ctx, tableName, dstSFT);
+    MasterReadOnlyController.preModifyTableStoreFileTracker(ctx, tableName, dstSFT);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreModifyColumnFamilyStoreFileTrackerReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preModifyColumnFamilyStoreFileTracker(ctx, tableName, family, dstSFT);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preModifyColumnFamilyStoreFileTracker(ctx, tableName, family, dstSFT);
   }
 
   @Test
   public void testPreModifyColumnFamilyStoreFileTrackerNoException() throws IOException {
-    readOnlyController.preModifyColumnFamilyStoreFileTracker(ctx, tableName, family, dstSFT);
+    MasterReadOnlyController.preModifyColumnFamilyStoreFileTracker(ctx, tableName, family, dstSFT);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreModifyTableActionReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preModifyTableAction(ctx, tableName, currentDescriptor, newDescriptor);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preModifyTableAction(ctx, tableName, currentDescriptor, newDescriptor);
   }
 
   @Test
   public void testPreModifyTableActionNoException() throws IOException {
-    readOnlyController.preModifyTableAction(ctx, tableName, currentDescriptor, newDescriptor);
+    MasterReadOnlyController.preModifyTableAction(ctx, tableName, currentDescriptor, newDescriptor);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreSplitRegionReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preSplitRegion(c, tableName, splitRow);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preSplitRegion(c, tableName, splitRow);
   }
 
   @Test
   public void testPreSplitRegionNoException() throws IOException {
-    readOnlyController.preSplitRegion(c, tableName, splitRow);
+    MasterReadOnlyController.preSplitRegion(c, tableName, splitRow);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreSplitRegionActionReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preSplitRegionAction(c, tableName, splitRow);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preSplitRegionAction(c, tableName, splitRow);
   }
 
   @Test
   public void testPreSplitRegionActionNoException() throws IOException {
-    readOnlyController.preSplitRegionAction(c, tableName, splitRow);
+    MasterReadOnlyController.preSplitRegionAction(c, tableName, splitRow);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreSplitRegionBeforeMETAActionReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preSplitRegionBeforeMETAAction(ctx, splitKey, metaEntries);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preSplitRegionBeforeMETAAction(ctx, splitKey, metaEntries);
   }
 
   @Test
   public void testPreSplitRegionBeforeMETAActionNoException() throws IOException {
-    readOnlyController.preSplitRegionBeforeMETAAction(ctx, splitKey, metaEntries);
+    MasterReadOnlyController.preSplitRegionBeforeMETAAction(ctx, splitKey, metaEntries);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreSplitRegionAfterMETAActionReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preSplitRegionAfterMETAAction(ctx);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preSplitRegionAfterMETAAction(ctx);
   }
 
   @Test
   public void testPreSplitRegionAfterMETAActionNoException() throws IOException {
-    readOnlyController.preSplitRegionAfterMETAAction(ctx);
+    MasterReadOnlyController.preSplitRegionAfterMETAAction(ctx);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreMergeRegionsActionReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preMergeRegionsAction(ctx, regionsToMerge);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preMergeRegionsAction(ctx, regionsToMerge);
   }
 
   @Test
   public void testPreMergeRegionsActionNoException() throws IOException {
-    readOnlyController.preMergeRegionsAction(ctx, regionsToMerge);
+    MasterReadOnlyController.preMergeRegionsAction(ctx, regionsToMerge);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreMergeRegionsCommitActionReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preMergeRegionsCommitAction(ctx, regionsToMerge, metaEntries);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preMergeRegionsCommitAction(ctx, regionsToMerge, metaEntries);
   }
 
   @Test
   public void testPreMergeRegionsCommitActionNoException() throws IOException {
-    readOnlyController.preMergeRegionsCommitAction(ctx, regionsToMerge, metaEntries);
+    MasterReadOnlyController.preMergeRegionsCommitAction(ctx, regionsToMerge, metaEntries);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreSnapshotReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preSnapshot(ctx, snapshot, tableDescriptor);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preSnapshot(ctx, snapshot, tableDescriptor);
   }
 
   @Test
   public void testPreSnapshotNoException() throws IOException {
-    readOnlyController.preSnapshot(ctx, snapshot, tableDescriptor);
+    MasterReadOnlyController.preSnapshot(ctx, snapshot, tableDescriptor);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCloneSnapshotReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCloneSnapshot(ctx, snapshot, tableDescriptor);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preCloneSnapshot(ctx, snapshot, tableDescriptor);
   }
 
   @Test
   public void testPreCloneSnapshotNoException() throws IOException {
-    readOnlyController.preCloneSnapshot(ctx, snapshot, tableDescriptor);
+    MasterReadOnlyController.preCloneSnapshot(ctx, snapshot, tableDescriptor);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreRestoreSnapshotReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preRestoreSnapshot(ctx, snapshot, tableDescriptor);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preRestoreSnapshot(ctx, snapshot, tableDescriptor);
   }
 
   @Test
   public void testPreRestoreSnapshotNoException() throws IOException {
-    readOnlyController.preRestoreSnapshot(ctx, snapshot, tableDescriptor);
+    MasterReadOnlyController.preRestoreSnapshot(ctx, snapshot, tableDescriptor);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreDeleteSnapshotReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preDeleteSnapshot(ctx, snapshot);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preDeleteSnapshot(ctx, snapshot);
   }
 
   @Test
   public void testPreDeleteSnapshotNoException() throws IOException {
-    readOnlyController.preDeleteSnapshot(ctx, snapshot);
+    MasterReadOnlyController.preDeleteSnapshot(ctx, snapshot);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCreateNamespaceReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCreateNamespace(ctx, ns);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preCreateNamespace(ctx, ns);
   }
 
   @Test
   public void testPreCreateNamespaceNoException() throws IOException {
-    readOnlyController.preCreateNamespace(ctx, ns);
+    MasterReadOnlyController.preCreateNamespace(ctx, ns);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreModifyNamespaceReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preModifyNamespace(ctx, currentNsDescriptor, newNsDescriptor);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preModifyNamespace(ctx, currentNsDescriptor, newNsDescriptor);
   }
 
   @Test
   public void testPreModifyNamespaceNoException() throws IOException {
-    readOnlyController.preModifyNamespace(ctx, currentNsDescriptor, newNsDescriptor);
+    MasterReadOnlyController.preModifyNamespace(ctx, currentNsDescriptor, newNsDescriptor);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreDeleteNamespaceReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preDeleteNamespace(ctx, namespace);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preDeleteNamespace(ctx, namespace);
   }
 
   @Test
   public void testPreDeleteNamespaceNoException() throws IOException {
-    readOnlyController.preDeleteNamespace(ctx, namespace);
+    MasterReadOnlyController.preDeleteNamespace(ctx, namespace);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreMasterStoreFlushReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preMasterStoreFlush(ctx);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preMasterStoreFlush(ctx);
   }
 
   @Test
   public void testPreMasterStoreFlushNoException() throws IOException {
-    readOnlyController.preMasterStoreFlush(ctx);
+    MasterReadOnlyController.preMasterStoreFlush(ctx);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreSetUserQuotaReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preSetUserQuota(ctx, userName, quotas);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preSetUserQuota(ctx, userName, quotas);
   }
 
   @Test
   public void testPreSetUserQuotaNoException() throws IOException {
-    readOnlyController.preSetUserQuota(ctx, userName, quotas);
+    MasterReadOnlyController.preSetUserQuota(ctx, userName, quotas);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreSetUserQuotaOnTableReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preSetUserQuota(ctx, userName, tableName, quotas);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preSetUserQuota(ctx, userName, tableName, quotas);
   }
 
   @Test
   public void testPreSetUserQuotaOnTableNoException() throws IOException {
-    readOnlyController.preSetUserQuota(ctx, userName, tableName, quotas);
+    MasterReadOnlyController.preSetUserQuota(ctx, userName, tableName, quotas);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreSetUserQuotaOnNamespaceReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preSetUserQuota(ctx, userName, namespace, quotas);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preSetUserQuota(ctx, userName, namespace, quotas);
   }
 
   @Test
   public void testPreSetUserQuotaOnNamespaceNoException() throws IOException {
-    readOnlyController.preSetUserQuota(ctx, userName, namespace, quotas);
+    MasterReadOnlyController.preSetUserQuota(ctx, userName, namespace, quotas);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreSetTableQuotaReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preSetTableQuota(ctx, tableName, quotas);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preSetTableQuota(ctx, tableName, quotas);
   }
 
   @Test
   public void testPreSetTableQuotaNoException() throws IOException {
-    readOnlyController.preSetTableQuota(ctx, tableName, quotas);
+    MasterReadOnlyController.preSetTableQuota(ctx, tableName, quotas);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreSetNamespaceQuotaReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preSetNamespaceQuota(ctx, namespace, quotas);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preSetNamespaceQuota(ctx, namespace, quotas);
   }
 
   @Test
   public void testPreSetNamespaceQuotaNoException() throws IOException {
-    readOnlyController.preSetNamespaceQuota(ctx, namespace, quotas);
+    MasterReadOnlyController.preSetNamespaceQuota(ctx, namespace, quotas);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreSetRegionServerQuotaReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preSetRegionServerQuota(ctx, regionServer, quotas);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preSetRegionServerQuota(ctx, regionServer, quotas);
   }
 
   @Test
   public void testPreSetRegionServerQuotaNoException() throws IOException {
-    readOnlyController.preSetRegionServerQuota(ctx, regionServer, quotas);
+    MasterReadOnlyController.preSetRegionServerQuota(ctx, regionServer, quotas);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreMergeRegionsReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preMergeRegions(ctx, regionsToMerge);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preMergeRegions(ctx, regionsToMerge);
   }
 
   @Test
   public void testPreMergeRegionsNoException() throws IOException {
-    readOnlyController.preMergeRegions(ctx, regionsToMerge);
+    MasterReadOnlyController.preMergeRegions(ctx, regionsToMerge);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreMoveServersAndTablesReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preMoveServersAndTables(ctx, servers, tables, targetGroup);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preMoveServersAndTables(ctx, servers, tables, targetGroup);
   }
 
   @Test
   public void testPreMoveServersAndTablesNoException() throws IOException {
-    readOnlyController.preMoveServersAndTables(ctx, servers, tables, targetGroup);
+    MasterReadOnlyController.preMoveServersAndTables(ctx, servers, tables, targetGroup);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreMoveServersReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preMoveServers(ctx, servers, targetGroup);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preMoveServers(ctx, servers, targetGroup);
   }
 
   @Test
   public void testPreMoveServersNoException() throws IOException {
-    readOnlyController.preMoveServers(ctx, servers, targetGroup);
+    MasterReadOnlyController.preMoveServers(ctx, servers, targetGroup);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreMoveTablesReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preMoveTables(ctx, tables, targetGroup);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preMoveTables(ctx, tables, targetGroup);
   }
 
   @Test
   public void testPreMoveTablesNoException() throws IOException {
-    readOnlyController.preMoveTables(ctx, tables, targetGroup);
+    MasterReadOnlyController.preMoveTables(ctx, tables, targetGroup);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreAddRSGroupReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preAddRSGroup(ctx, name);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preAddRSGroup(ctx, name);
   }
 
   @Test
   public void testPreAddRSGroupNoException() throws IOException {
-    readOnlyController.preAddRSGroup(ctx, name);
+    MasterReadOnlyController.preAddRSGroup(ctx, name);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreRemoveRSGroupReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preRemoveRSGroup(ctx, name);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preRemoveRSGroup(ctx, name);
   }
 
   @Test
   public void testPreRemoveRSGroupNoException() throws IOException {
-    readOnlyController.preRemoveRSGroup(ctx, name);
+    MasterReadOnlyController.preRemoveRSGroup(ctx, name);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreBalanceRSGroupReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preBalanceRSGroup(ctx, groupName, request);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preBalanceRSGroup(ctx, groupName, request);
   }
 
   @Test
   public void testPreBalanceRSGroupNoException() throws IOException {
-    readOnlyController.preBalanceRSGroup(ctx, groupName, request);
+    MasterReadOnlyController.preBalanceRSGroup(ctx, groupName, request);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreRemoveServersReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preRemoveServers(ctx, servers);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preRemoveServers(ctx, servers);
   }
 
   @Test
   public void testPreRemoveServersNoException() throws IOException {
-    readOnlyController.preRemoveServers(ctx, servers);
+    MasterReadOnlyController.preRemoveServers(ctx, servers);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreRenameRSGroupReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preRenameRSGroup(ctx, oldName, newName);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preRenameRSGroup(ctx, oldName, newName);
   }
 
   @Test
   public void testPreRenameRSGroupNoException() throws IOException {
-    readOnlyController.preRenameRSGroup(ctx, oldName, newName);
+    MasterReadOnlyController.preRenameRSGroup(ctx, oldName, newName);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreUpdateRSGroupConfigReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preUpdateRSGroupConfig(ctx, groupName, configuration);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preUpdateRSGroupConfig(ctx, groupName, configuration);
   }
 
   @Test
   public void testPreUpdateRSGroupConfigNoException() throws IOException {
-    readOnlyController.preUpdateRSGroupConfig(ctx, groupName, configuration);
+    MasterReadOnlyController.preUpdateRSGroupConfig(ctx, groupName, configuration);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreAddReplicationPeerReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preAddReplicationPeer(ctx, peerId, peerConfig);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preAddReplicationPeer(ctx, peerId, peerConfig);
   }
 
   @Test
   public void testPreAddReplicationPeerNoException() throws IOException {
-    readOnlyController.preAddReplicationPeer(ctx, peerId, peerConfig);
+    MasterReadOnlyController.preAddReplicationPeer(ctx, peerId, peerConfig);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreRemoveReplicationPeerReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preRemoveReplicationPeer(ctx, peerId);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preRemoveReplicationPeer(ctx, peerId);
   }
 
   @Test
   public void testPreRemoveReplicationPeerNoException() throws IOException {
-    readOnlyController.preRemoveReplicationPeer(ctx, peerId);
+    MasterReadOnlyController.preRemoveReplicationPeer(ctx, peerId);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreEnableReplicationPeerReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preEnableReplicationPeer(ctx, peerId);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preEnableReplicationPeer(ctx, peerId);
   }
 
   @Test
   public void testPreEnableReplicationPeerNoException() throws IOException {
-    readOnlyController.preEnableReplicationPeer(ctx, peerId);
+    MasterReadOnlyController.preEnableReplicationPeer(ctx, peerId);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreDisableReplicationPeerReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preDisableReplicationPeer(ctx, peerId);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preDisableReplicationPeer(ctx, peerId);
   }
 
   @Test
   public void testPreDisableReplicationPeerNoException() throws IOException {
-    readOnlyController.preDisableReplicationPeer(ctx, peerId);
+    MasterReadOnlyController.preDisableReplicationPeer(ctx, peerId);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreUpdateReplicationPeerConfigReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preUpdateReplicationPeerConfig(ctx, peerId, peerConfig);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preUpdateReplicationPeerConfig(ctx, peerId, peerConfig);
   }
 
   @Test
   public void testPreUpdateReplicationPeerConfigNoException() throws IOException {
-    readOnlyController.preUpdateReplicationPeerConfig(ctx, peerId, peerConfig);
+    MasterReadOnlyController.preUpdateReplicationPeerConfig(ctx, peerId, peerConfig);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreTransitReplicationPeerSyncReplicationStateReadOnlyException()
     throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preTransitReplicationPeerSyncReplicationState(ctx, peerId, state);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preTransitReplicationPeerSyncReplicationState(ctx, peerId, state);
   }
 
   @Test
   public void testPreTransitReplicationPeerSyncReplicationStateNoException() throws IOException {
-    readOnlyController.preTransitReplicationPeerSyncReplicationState(ctx, peerId, state);
+    MasterReadOnlyController.preTransitReplicationPeerSyncReplicationState(ctx, peerId, state);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreGrantReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preGrant(ctx, userPermission, mergeExistingPermissions);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preGrant(ctx, userPermission, mergeExistingPermissions);
   }
 
   @Test
   public void testPreGrantNoException() throws IOException {
-    readOnlyController.preGrant(ctx, userPermission, mergeExistingPermissions);
+    MasterReadOnlyController.preGrant(ctx, userPermission, mergeExistingPermissions);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreRevokeReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preRevoke(ctx, userPermission);
+    MasterReadOnlyController.onConfigurationChange(readOnlyConf);
+    MasterReadOnlyController.preRevoke(ctx, userPermission);
   }
 
   @Test
   public void testPreRevokeNoException() throws IOException {
-    readOnlyController.preRevoke(ctx, userPermission);
+    MasterReadOnlyController.preRevoke(ctx, userPermission);
   }
 }
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerRegionObserver.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerRegionObserver.java
index cc9fa6f1a15..33f9a337cbe 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerRegionObserver.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerRegionObserver.java
@@ -76,7 +76,7 @@ public class TestReadOnlyControllerRegionObserver {
   public static final HBaseClassTestRule CLASS_RULE =
     HBaseClassTestRule.forClass(TestReadOnlyControllerRegionObserver.class);
 
-  ReadOnlyController readOnlyController;
+  RegionReadOnlyController regionReadOnlyController;
   HBaseConfiguration readOnlyConf;
 
   // Region Coprocessor mocking variables
@@ -116,7 +116,7 @@ public class TestReadOnlyControllerRegionObserver {
 
   @Before
   public void setup() throws Exception {
-    readOnlyController = new ReadOnlyController();
+    regionReadOnlyController = new RegionReadOnlyController();
     readOnlyConf = new HBaseConfiguration();
     readOnlyConf.setBoolean(HBASE_GLOBAL_READONLY_ENABLED_KEY, true);
 
@@ -183,631 +183,655 @@ public class TestReadOnlyControllerRegionObserver {
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreFlushV1ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preFlush(c, flushLifeCycleTracker);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preFlush(c, flushLifeCycleTracker);
   }
 
   @Test
   public void testPreFlushV1NoException() throws IOException {
-    readOnlyController.preFlush(c, flushLifeCycleTracker);
+    regionReadOnlyController.preFlush(c, flushLifeCycleTracker);
   }
 
   @Test
   public void testPreFlushV1ReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.preFlush(c, flushLifeCycleTracker);
+    regionReadOnlyController.preFlush(c, flushLifeCycleTracker);
   }
 
   @Test
   public void testPreFlushV1MetaNoException() throws IOException {
-    readOnlyController.preFlush(c, flushLifeCycleTracker);
+    mockOperationForMetaTable();
+    regionReadOnlyController.preFlush(c, flushLifeCycleTracker);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreFlushV2ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preFlush(c, store, scanner, flushLifeCycleTracker);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preFlush(c, store, scanner, flushLifeCycleTracker);
   }
 
   @Test
   public void testPreFlushV2NoException() throws IOException {
-    readOnlyController.preFlush(c, store, scanner, flushLifeCycleTracker);
+    regionReadOnlyController.preFlush(c, store, scanner, flushLifeCycleTracker);
   }
 
   @Test
   public void testPreFlushV2ReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.preFlush(c, store, scanner, flushLifeCycleTracker);
+    regionReadOnlyController.preFlush(c, store, scanner, flushLifeCycleTracker);
   }
 
   @Test
   public void testPreFlushV2MetaNoException() throws IOException {
-    readOnlyController.preFlush(c, store, scanner, flushLifeCycleTracker);
+    mockOperationForMetaTable();
+    regionReadOnlyController.preFlush(c, store, scanner, flushLifeCycleTracker);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreFlushScannerOpenReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preFlushScannerOpen(c, store, options, flushLifeCycleTracker);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preFlushScannerOpen(c, store, options, flushLifeCycleTracker);
   }
 
   @Test
   public void testPreFlushScannerOpenNoException() throws IOException {
-    readOnlyController.preFlushScannerOpen(c, store, options, flushLifeCycleTracker);
+    regionReadOnlyController.preFlushScannerOpen(c, store, options, flushLifeCycleTracker);
   }
 
   @Test
   public void testPreFlushScannerOpenReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.preFlushScannerOpen(c, store, options, flushLifeCycleTracker);
+    regionReadOnlyController.preFlushScannerOpen(c, store, options, flushLifeCycleTracker);
   }
 
   @Test
   public void testPreFlushScannerOpenMetaNoException() throws IOException {
-    readOnlyController.preFlushScannerOpen(c, store, options, flushLifeCycleTracker);
+    mockOperationForMetaTable();
+    regionReadOnlyController.preFlushScannerOpen(c, store, options, flushLifeCycleTracker);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreMemStoreCompactionReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preMemStoreCompaction(c, store);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preMemStoreCompaction(c, store);
   }
 
   @Test
   public void testPreMemStoreCompactionNoException() throws IOException {
-    readOnlyController.preMemStoreCompaction(c, store);
+    regionReadOnlyController.preMemStoreCompaction(c, store);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreMemStoreCompactionCompactScannerOpenReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preMemStoreCompactionCompactScannerOpen(c, store, options);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preMemStoreCompactionCompactScannerOpen(c, store, options);
   }
 
   @Test
   public void testPreMemStoreCompactionCompactScannerOpenNoException() throws IOException {
-    readOnlyController.preMemStoreCompactionCompactScannerOpen(c, store, options);
+    regionReadOnlyController.preMemStoreCompactionCompactScannerOpen(c, store, options);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreMemStoreCompactionCompactReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preMemStoreCompactionCompact(c, store, scanner);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preMemStoreCompactionCompact(c, store, scanner);
   }
 
   @Test
   public void testPreMemStoreCompactionCompactNoException() throws IOException {
-    readOnlyController.preMemStoreCompactionCompact(c, store, scanner);
+    regionReadOnlyController.preMemStoreCompactionCompact(c, store, scanner);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCompactSelectionReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCompactSelection(c, store, candidates, compactionLifeCycleTracker);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preCompactSelection(c, store, candidates, compactionLifeCycleTracker);
   }
 
   @Test
   public void testPreCompactSelectionNoException() throws IOException {
-    readOnlyController.preCompactSelection(c, store, candidates, compactionLifeCycleTracker);
+    regionReadOnlyController.preCompactSelection(c, store, candidates, compactionLifeCycleTracker);
   }
 
   @Test
   public void testPreCompactSelectionReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.preCompactSelection(c, store, candidates, compactionLifeCycleTracker);
+    regionReadOnlyController.preCompactSelection(c, store, candidates, compactionLifeCycleTracker);
   }
 
   @Test
   public void testPreCompactSelectionMetaNoException() throws IOException {
-    readOnlyController.preCompactSelection(c, store, candidates, compactionLifeCycleTracker);
+    mockOperationForMetaTable();
+    regionReadOnlyController.preCompactSelection(c, store, candidates, compactionLifeCycleTracker);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCompactScannerOpenReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCompactScannerOpen(c, store, scanType, options,
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preCompactScannerOpen(c, store, scanType, options,
       compactionLifeCycleTracker, compactionRequest);
   }
 
   @Test
   public void testPreCompactScannerOpenNoException() throws IOException {
-    readOnlyController.preCompactScannerOpen(c, store, scanType, options,
+    regionReadOnlyController.preCompactScannerOpen(c, store, scanType, options,
       compactionLifeCycleTracker, compactionRequest);
   }
 
   @Test
   public void testPreCompactScannerOpenReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.preCompactScannerOpen(c, store, scanType, options,
+    regionReadOnlyController.preCompactScannerOpen(c, store, scanType, options,
       compactionLifeCycleTracker, compactionRequest);
   }
 
   @Test
   public void testPreCompactScannerOpenMetaNoException() throws IOException {
-    readOnlyController.preCompactScannerOpen(c, store, scanType, options,
+    mockOperationForMetaTable();
+    regionReadOnlyController.preCompactScannerOpen(c, store, scanType, options,
       compactionLifeCycleTracker, compactionRequest);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCompactReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCompact(c, store, scanner, scanType, compactionLifeCycleTracker,
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preCompact(c, store, scanner, scanType, compactionLifeCycleTracker,
       compactionRequest);
   }
 
   @Test
   public void testPreCompactNoException() throws IOException {
-    readOnlyController.preCompact(c, store, scanner, scanType, compactionLifeCycleTracker,
+    regionReadOnlyController.preCompact(c, store, scanner, scanType, compactionLifeCycleTracker,
       compactionRequest);
   }
 
   @Test
   public void testPreCompactReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.preCompact(c, store, scanner, scanType, compactionLifeCycleTracker,
+    regionReadOnlyController.preCompact(c, store, scanner, scanType, compactionLifeCycleTracker,
       compactionRequest);
   }
 
   @Test
   public void testPreCompactMetaNoException() throws IOException {
-    readOnlyController.preCompact(c, store, scanner, scanType, compactionLifeCycleTracker,
+    mockOperationForMetaTable();
+    regionReadOnlyController.preCompact(c, store, scanner, scanType, compactionLifeCycleTracker,
       compactionRequest);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPrePutV1ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.prePut(c, put, edit);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.prePut(c, put, edit);
   }
 
   @Test
   public void testPrePutV1NoException() throws IOException {
-    readOnlyController.prePut(c, put, edit);
+    regionReadOnlyController.prePut(c, put, edit);
   }
 
   @Test
   public void testPrePutV1ReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.prePut(c, put, edit);
+    regionReadOnlyController.prePut(c, put, edit);
   }
 
   @Test
   public void testPrePutV1MetaNoException() throws IOException {
-    readOnlyController.prePut(c, put, edit);
+    mockOperationForMetaTable();
+    regionReadOnlyController.prePut(c, put, edit);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPrePutV2ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.prePut(c, put, edit, durability);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.prePut(c, put, edit, durability);
   }
 
   @Test
   public void testPrePutV2NoException() throws IOException {
-    readOnlyController.prePut(c, put, edit, durability);
+    regionReadOnlyController.prePut(c, put, edit, durability);
   }
 
   @Test
   public void testPrePutV2ReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.prePut(c, put, edit, durability);
+    regionReadOnlyController.prePut(c, put, edit, durability);
   }
 
   @Test
   public void testPrePutV2MetaNoException() throws IOException {
-    readOnlyController.prePut(c, put, edit, durability);
+    mockOperationForMetaTable();
+    regionReadOnlyController.prePut(c, put, edit, durability);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreDeleteV1ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preDelete(c, delete, edit);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preDelete(c, delete, edit);
   }
 
   @Test
   public void testPreDeleteV1NoException() throws IOException {
-    readOnlyController.preDelete(c, delete, edit);
+    regionReadOnlyController.preDelete(c, delete, edit);
   }
 
   @Test
   public void testPreDeleteV1ReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.preDelete(c, delete, edit);
+    regionReadOnlyController.preDelete(c, delete, edit);
   }
 
   @Test
   public void testPreDeleteV1MetaNoException() throws IOException {
-    readOnlyController.preDelete(c, delete, edit);
+    mockOperationForMetaTable();
+    regionReadOnlyController.preDelete(c, delete, edit);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreDeleteV2ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preDelete(c, delete, edit, durability);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preDelete(c, delete, edit, durability);
   }
 
   @Test
   public void testPreDeleteV2NoException() throws IOException {
-    readOnlyController.preDelete(c, delete, edit, durability);
+    regionReadOnlyController.preDelete(c, delete, edit, durability);
   }
 
   @Test
   public void testPreDeleteV2ReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.preDelete(c, delete, edit, durability);
+    regionReadOnlyController.preDelete(c, delete, edit, durability);
   }
 
   @Test
   public void testPreDeleteV2MetaNoException() throws IOException {
-    readOnlyController.preDelete(c, delete, edit, durability);
+    mockOperationForMetaTable();
+    regionReadOnlyController.preDelete(c, delete, edit, durability);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreBatchMutateReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preBatchMutate(c, miniBatchOp);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preBatchMutate(c, miniBatchOp);
   }
 
   @Test
   public void testPreBatchMutateNoException() throws IOException {
-    readOnlyController.preBatchMutate(c, miniBatchOp);
+    regionReadOnlyController.preBatchMutate(c, miniBatchOp);
   }
 
   @Test
   public void testPreBatchMutateReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.preBatchMutate(c, miniBatchOp);
+    regionReadOnlyController.preBatchMutate(c, miniBatchOp);
   }
 
   @Test
   public void testPreBatchMutateMetaNoException() throws IOException {
-    readOnlyController.preBatchMutate(c, miniBatchOp);
+    mockOperationForMetaTable();
+    regionReadOnlyController.preBatchMutate(c, miniBatchOp);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCheckAndPutV1ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCheckAndPut(c, row, family, qualifier, op, comparator, put, result);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preCheckAndPut(c, row, family, qualifier, op, comparator, put, result);
   }
 
   @Test
   public void testPreCheckAndPutV1NoException() throws IOException {
-    readOnlyController.preCheckAndPut(c, row, family, qualifier, op, comparator, put, result);
+    regionReadOnlyController.preCheckAndPut(c, row, family, qualifier, op, comparator, put, result);
   }
 
   @Test
   public void testPreCheckAndPutV1ReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.preCheckAndPut(c, row, family, qualifier, op, comparator, put, result);
+    regionReadOnlyController.preCheckAndPut(c, row, family, qualifier, op, comparator, put, result);
   }
 
   @Test
   public void testPreCheckAndPutV1MetaNoException() throws IOException {
-    readOnlyController.preCheckAndPut(c, row, family, qualifier, op, comparator, put, result);
+    mockOperationForMetaTable();
+    regionReadOnlyController.preCheckAndPut(c, row, family, qualifier, op, comparator, put, result);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCheckAndPutV2ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCheckAndPut(c, row, filter, put, result);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preCheckAndPut(c, row, filter, put, result);
   }
 
   @Test
   public void testPreCheckAndPutV2NoException() throws IOException {
-    readOnlyController.preCheckAndPut(c, row, filter, put, result);
+    regionReadOnlyController.preCheckAndPut(c, row, filter, put, result);
   }
 
   @Test
   public void testPreCheckAndPutV2ReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.preCheckAndPut(c, row, filter, put, result);
+    regionReadOnlyController.preCheckAndPut(c, row, filter, put, result);
   }
 
   @Test
   public void testPreCheckAndPutV2MetaNoException() throws IOException {
-    readOnlyController.preCheckAndPut(c, row, filter, put, result);
+    mockOperationForMetaTable();
+    regionReadOnlyController.preCheckAndPut(c, row, filter, put, result);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCheckAndPutAfterRowLockV1ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCheckAndPutAfterRowLock(c, row, family, qualifier, op, comparator, put,
-      result);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preCheckAndPutAfterRowLock(c, row, family, qualifier, op, comparator,
+      put, result);
   }
 
   @Test
   public void testPreCheckAndPutAfterRowLockV1NoException() throws IOException {
-    readOnlyController.preCheckAndPutAfterRowLock(c, row, family, qualifier, op, comparator, put,
-      result);
+    regionReadOnlyController.preCheckAndPutAfterRowLock(c, row, family, qualifier, op, comparator,
+      put, result);
   }
 
   @Test
   public void testPreCheckAndPutAfterRowLockV1ReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.preCheckAndPutAfterRowLock(c, row, family, qualifier, op, comparator, put,
-      result);
+    regionReadOnlyController.preCheckAndPutAfterRowLock(c, row, family, qualifier, op, comparator,
+      put, result);
   }
 
   @Test
   public void testPreCheckAndPutAfterRowLockV1MetaNoException() throws IOException {
-    readOnlyController.preCheckAndPutAfterRowLock(c, row, family, qualifier, op, comparator, put,
-      result);
+    mockOperationForMetaTable();
+    regionReadOnlyController.preCheckAndPutAfterRowLock(c, row, family, qualifier, op, comparator,
+      put, result);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCheckAndPutAfterRowLockV2ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCheckAndPutAfterRowLock(c, row, filter, put, result);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preCheckAndPutAfterRowLock(c, row, filter, put, result);
   }
 
   @Test
   public void testPreCheckAndPutAfterRowLockV2NoException() throws IOException {
-    readOnlyController.preCheckAndPutAfterRowLock(c, row, filter, put, result);
+    regionReadOnlyController.preCheckAndPutAfterRowLock(c, row, filter, put, result);
   }
 
   @Test
   public void testPreCheckAndPutAfterRowLockV2ReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.preCheckAndPutAfterRowLock(c, row, filter, put, result);
+    regionReadOnlyController.preCheckAndPutAfterRowLock(c, row, filter, put, result);
   }
 
   @Test
   public void testPreCheckAndPutAfterRowLockV2MetaNoException() throws IOException {
-    readOnlyController.preCheckAndPutAfterRowLock(c, row, filter, put, result);
+    mockOperationForMetaTable();
+    regionReadOnlyController.preCheckAndPutAfterRowLock(c, row, filter, put, result);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCheckAndDeleteV1ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCheckAndDelete(c, row, family, qualifier, op, comparator, delete, result);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preCheckAndDelete(c, row, family, qualifier, op, comparator, delete,
+      result);
   }
 
   @Test
   public void testPreCheckAndDeleteV1NoException() throws IOException {
-    readOnlyController.preCheckAndDelete(c, row, family, qualifier, op, comparator, delete, result);
+    regionReadOnlyController.preCheckAndDelete(c, row, family, qualifier, op, comparator, delete,
+      result);
   }
 
   @Test
   public void testPreCheckAndDeleteV1ReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.preCheckAndDelete(c, row, family, qualifier, op, comparator, delete, result);
+    regionReadOnlyController.preCheckAndDelete(c, row, family, qualifier, op, comparator, delete,
+      result);
   }
 
   @Test
   public void testPreCheckAndDeleteV1MetaNoException() throws IOException {
-    readOnlyController.preCheckAndDelete(c, row, family, qualifier, op, comparator, delete, result);
+    mockOperationForMetaTable();
+    regionReadOnlyController.preCheckAndDelete(c, row, family, qualifier, op, comparator, delete,
+      result);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCheckAndDeleteV2ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCheckAndDelete(c, row, filter, delete, result);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preCheckAndDelete(c, row, filter, delete, result);
   }
 
   @Test
   public void testPreCheckAndDeleteV2NoException() throws IOException {
-    readOnlyController.preCheckAndDelete(c, row, filter, delete, result);
+    regionReadOnlyController.preCheckAndDelete(c, row, filter, delete, result);
   }
 
   @Test
   public void testPreCheckAndDeleteV2ReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.preCheckAndDelete(c, row, filter, delete, result);
+    regionReadOnlyController.preCheckAndDelete(c, row, filter, delete, result);
   }
 
   @Test
   public void testPreCheckAndDeleteV2MetaNoException() throws IOException {
-    readOnlyController.preCheckAndDelete(c, row, filter, delete, result);
+    mockOperationForMetaTable();
+    regionReadOnlyController.preCheckAndDelete(c, row, filter, delete, result);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCheckAndDeleteAfterRowLockV1ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCheckAndDeleteAfterRowLock(c, row, family, qualifier, op, comparator,
-      delete, result);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preCheckAndDeleteAfterRowLock(c, row, family, qualifier, op,
+      comparator, delete, result);
   }
 
   @Test
   public void testPreCheckAndDeleteAfterRowLockV1NoException() throws IOException {
-    readOnlyController.preCheckAndDeleteAfterRowLock(c, row, family, qualifier, op, comparator,
-      delete, result);
+    regionReadOnlyController.preCheckAndDeleteAfterRowLock(c, row, family, qualifier, op,
+      comparator, delete, result);
   }
 
   @Test
   public void testPreCheckAndDeleteAfterRowLockV1ReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.preCheckAndDeleteAfterRowLock(c, row, family, qualifier, op, comparator,
-      delete, result);
+    regionReadOnlyController.preCheckAndDeleteAfterRowLock(c, row, family, qualifier, op,
+      comparator, delete, result);
   }
 
   @Test
   public void testPreCheckAndDeleteAfterRowLockV1MetaNoException() throws IOException {
-    readOnlyController.preCheckAndDeleteAfterRowLock(c, row, family, qualifier, op, comparator,
-      delete, result);
+    mockOperationForMetaTable();
+    regionReadOnlyController.preCheckAndDeleteAfterRowLock(c, row, family, qualifier, op,
+      comparator, delete, result);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCheckAndDeleteAfterRowLockV2ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCheckAndDeleteAfterRowLock(c, row, filter, delete, result);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preCheckAndDeleteAfterRowLock(c, row, filter, delete, result);
   }
 
   @Test
   public void testPreCheckAndDeleteAfterRowLockV2NoException() throws IOException {
-    readOnlyController.preCheckAndDeleteAfterRowLock(c, row, filter, delete, result);
+    regionReadOnlyController.preCheckAndDeleteAfterRowLock(c, row, filter, delete, result);
   }
 
   @Test
   public void testPreCheckAndDeleteAfterRowLockV2ReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     mockOperationForMetaTable();
-    readOnlyController.preCheckAndDeleteAfterRowLock(c, row, filter, delete, result);
+    regionReadOnlyController.preCheckAndDeleteAfterRowLock(c, row, filter, delete, result);
   }
 
   @Test
   public void testPreCheckAndDeleteAfterRowLockV2MetaNoException() throws IOException {
-    readOnlyController.preCheckAndDeleteAfterRowLock(c, row, filter, delete, result);
+    mockOperationForMetaTable();
+    regionReadOnlyController.preCheckAndDeleteAfterRowLock(c, row, filter, delete, result);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCheckAndMutateReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCheckAndMutate(c, checkAndMutate, checkAndMutateResult);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preCheckAndMutate(c, checkAndMutate, checkAndMutateResult);
   }
 
   @Test
   public void testPreCheckAndMutateNoException() throws IOException {
-    readOnlyController.preCheckAndMutate(c, checkAndMutate, checkAndMutateResult);
+    regionReadOnlyController.preCheckAndMutate(c, checkAndMutate, checkAndMutateResult);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCheckAndMutateAfterRowLockReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCheckAndMutateAfterRowLock(c, checkAndMutate, checkAndMutateResult);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preCheckAndMutateAfterRowLock(c, checkAndMutate, checkAndMutateResult);
   }
 
   @Test
   public void testPreCheckAndMutateAfterRowLockNoException() throws IOException {
-    readOnlyController.preCheckAndMutateAfterRowLock(c, checkAndMutate, checkAndMutateResult);
+    regionReadOnlyController.preCheckAndMutateAfterRowLock(c, checkAndMutate, checkAndMutateResult);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreAppendV1ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preAppend(c, append);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preAppend(c, append);
   }
 
   @Test
   public void testPreAppendV1NoException() throws IOException {
-    readOnlyController.preAppend(c, append);
+    regionReadOnlyController.preAppend(c, append);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreAppendV2ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preAppend(c, append, edit);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preAppend(c, append, edit);
   }
 
   @Test
   public void testPreAppendV2NoException() throws IOException {
-    readOnlyController.preAppend(c, append, edit);
+    regionReadOnlyController.preAppend(c, append, edit);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreAppendAfterRowLockReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preAppendAfterRowLock(c, append);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preAppendAfterRowLock(c, append);
   }
 
   @Test
   public void testPreAppendAfterRowLockNoException() throws IOException {
-    readOnlyController.preAppendAfterRowLock(c, append);
+    regionReadOnlyController.preAppendAfterRowLock(c, append);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreIncrementV1ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preIncrement(c, increment);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preIncrement(c, increment);
   }
 
   @Test
   public void testPreIncrementV1NoException() throws IOException {
-    readOnlyController.preIncrement(c, increment);
+    regionReadOnlyController.preIncrement(c, increment);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreIncrementV2ReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preIncrement(c, increment, edit);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preIncrement(c, increment, edit);
   }
 
   @Test
   public void testPreIncrementV2NoException() throws IOException {
-    readOnlyController.preIncrement(c, increment, edit);
+    regionReadOnlyController.preIncrement(c, increment, edit);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreIncrementAfterRowLockReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preIncrementAfterRowLock(c, increment);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preIncrementAfterRowLock(c, increment);
   }
 
   @Test
   public void testPreIncrementAfterRowLockNoException() throws IOException {
-    readOnlyController.preIncrementAfterRowLock(c, increment);
+    regionReadOnlyController.preIncrementAfterRowLock(c, increment);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreReplayWALsReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preReplayWALs(ctx, info, edits);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preReplayWALs(ctx, info, edits);
   }
 
   @Test
   public void testPreReplayWALsNoException() throws IOException {
-    readOnlyController.preReplayWALs(ctx, info, edits);
+    regionReadOnlyController.preReplayWALs(ctx, info, edits);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreBulkLoadHFileReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preBulkLoadHFile(ctx, familyPaths);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preBulkLoadHFile(ctx, familyPaths);
   }
 
   @Test
   public void testPreBulkLoadHFileNoException() throws IOException {
-    readOnlyController.preBulkLoadHFile(ctx, familyPaths);
+    regionReadOnlyController.preBulkLoadHFile(ctx, familyPaths);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreCommitStoreFileReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preCommitStoreFile(ctx, family, pairs);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preCommitStoreFile(ctx, family, pairs);
   }
 
   @Test
   public void testPreCommitStoreFileNoException() throws IOException {
-    readOnlyController.preCommitStoreFile(ctx, family, pairs);
+    regionReadOnlyController.preCommitStoreFile(ctx, family, pairs);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreWALAppendReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preWALAppend(ctx, key, edit);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.preWALAppend(ctx, key, edit);
   }
 
   @Test
   public void testPreWALAppendNoException() throws IOException {
-    readOnlyController.preWALAppend(ctx, key, edit);
+    regionReadOnlyController.preWALAppend(ctx, key, edit);
   }
 
   @Test
   public void testPreWALAppendReadOnlyMetaNoException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
+    regionReadOnlyController.onConfigurationChange(readOnlyConf);
     when(key.getTableName()).thenReturn(TableName.META_TABLE_NAME);
-    readOnlyController.preWALAppend(ctx, key, edit);
+    regionReadOnlyController.preWALAppend(ctx, key, edit);
   }
 
   @Test
   public void testPreWALAppendMetaNoException() throws IOException {
-    readOnlyController.preWALAppend(ctx, key, edit);
+    when(key.getTableName()).thenReturn(TableName.META_TABLE_NAME);
+    regionReadOnlyController.preWALAppend(ctx, key, edit);
   }
 }
diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerRegionServerObserver.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerRegionServerObserver.java
index bb35232a636..57424085504 100644
--- a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerRegionServerObserver.java
+++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestReadOnlyControllerRegionServerObserver.java
@@ -48,7 +48,7 @@ public class TestReadOnlyControllerRegionServerObserver {
   public static final HBaseClassTestRule CLASS_RULE =
     HBaseClassTestRule.forClass(TestReadOnlyControllerRegionServerObserver.class);
 
-  ReadOnlyController readOnlyController;
+  RegionServerReadOnlyController regionServerReadOnlyController;
   HBaseConfiguration readOnlyConf;
 
   // Region Server Coprocessor mocking variables
@@ -58,7 +58,7 @@ public class TestReadOnlyControllerRegionServerObserver {
 
   @Before
   public void setup() throws Exception {
-    readOnlyController = new ReadOnlyController();
+    regionServerReadOnlyController = new RegionServerReadOnlyController();
     readOnlyConf = new HBaseConfiguration();
     readOnlyConf.setBoolean(HBASE_GLOBAL_READONLY_ENABLED_KEY, true);
 
@@ -79,45 +79,34 @@ public class TestReadOnlyControllerRegionServerObserver {
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreRollWALWriterRequestReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preRollWALWriterRequest(ctx);
+    regionServerReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionServerReadOnlyController.preRollWALWriterRequest(ctx);
   }
 
   @Test
   public void testPreRollWALWriterRequestNoException() throws IOException {
-    readOnlyController.preRollWALWriterRequest(ctx);
-  }
-
-  @Test(expected = DoNotRetryIOException.class)
-  public void testPreExecuteProceduresReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preExecuteProcedures(ctx);
-  }
-
-  @Test
-  public void testPreExecuteProceduresNoException() throws IOException {
-    readOnlyController.preExecuteProcedures(ctx);
+    regionServerReadOnlyController.preRollWALWriterRequest(ctx);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreReplicationSinkBatchMutateReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preReplicationSinkBatchMutate(ctx, walEntry, mutation);
+    regionServerReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionServerReadOnlyController.preReplicationSinkBatchMutate(ctx, walEntry, mutation);
   }
 
   @Test
   public void testPreReplicationSinkBatchMutateNoException() throws IOException {
-    readOnlyController.preReplicationSinkBatchMutate(ctx, walEntry, mutation);
+    regionServerReadOnlyController.preReplicationSinkBatchMutate(ctx, walEntry, mutation);
   }
 
   @Test(expected = DoNotRetryIOException.class)
   public void testPreReplicateLogEntriesReadOnlyException() throws IOException {
-    readOnlyController.onConfigurationChange(readOnlyConf);
-    readOnlyController.preReplicateLogEntries(ctx);
+    regionServerReadOnlyController.onConfigurationChange(readOnlyConf);
+    regionServerReadOnlyController.preReplicateLogEntries(ctx);
   }
 
   @Test
   public void testPreReplicateLogEntriesNoException() throws IOException {
-    readOnlyController.preReplicateLogEntries(ctx);
+    regionServerReadOnlyController.preReplicateLogEntries(ctx);
   }
 }