You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iotdb.apache.org by yo...@apache.org on 2023/01/12 14:16:31 UTC

[iotdb] branch Move-ConfigNodeConfig-into-CommonConfig updated (16d2fdfbac -> 6b8c7295e6)

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

yongzao pushed a change to branch Move-ConfigNodeConfig-into-CommonConfig
in repository https://gitbox.apache.org/repos/asf/iotdb.git


    from 16d2fdfbac stash
     new ff1991cb17 stash
     add ee93ad4145 [IOTDB-4960]SchemaFile implements separate FileChannel for read/write operation (#8813)
     add 8224a70a41 [IOTDB-5398] Handle failure in schema query if there is exception occurs during the iteration (#8830)
     add 309206e504 [IOTDB-5392] accelerate pointPriorityReader in fast compaction
     add 3c01a93437 [IOTDB-5401] Reduce the estimated size of memory retained after calling next in SeriesAggregationScanOperator
     add b93dbfa5e6 [IOTDB-5369] Add query related panels in Grafana Dashboard (#8764)
     add 4ee81d4d68 [IOTDB-5345] Use the logical clock to identify the snapshot version of IoTConsensus (#8807)
     add a009560f26 [IOTDB-5390] Keep mqtt_host same with rpc_address (#8831)
     add 2122ae3353 [IOTDB-5404] Fix concurrency problem of metricSets in AbstractMetricService (#8841)
     add 4a73e612d3 Fix mqtt docs (#8845)
     add df26f54db3 [IOTDB-5403] Refine IT: Add ensureNodeStatus to test status after starting or stopping (#8844)
     add ed75dfcc81 finish (#8837)
     add 0e5e53ad97 [IOTDB-5370] Implement MultilevelPriorityQueue for query schedule
     add 3299f1310e Update the user guide of Flink-IoTDB sink (#8848)
     add 9d5d78285d [IOTDB-4674] Reimplement settle by compaction (#8644)
     add a7f910ffc4 Finish (#8847)
     add 0308ab6cab [IOTDB-5404] Optimize concurrency problem of metricSets in AbstractMetricService (#8855)
     new 6b8c7295e6 Merge branch 'master' into Move-ConfigNodeConfig-into-CommonConfig

The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails.  The revisions
listed as "add" were already present in the repository and have only
been added to this reference.


Summary of changes:
 .../confignode/conf/ConfigNodeDescriptor.java      |   124 +-
 .../confignode/conf/ConfigNodeStartupCheck.java    |    52 +-
 .../confignode/conf/SystemPropertiesUtils.java     |    61 +-
 .../confignode/manager/ClusterSchemaManager.java   |    93 +-
 .../iotdb/confignode/manager/ConfigManager.java    |    51 +-
 .../iotdb/confignode/manager/ConsensusManager.java |    64 +-
 .../manager/load/balancer/RouteBalancer.java       |    21 +-
 .../manager/node/ClusterNodeStartUtils.java        |     3 +-
 .../manager/partition/PartitionManager.java        |    22 +-
 .../iotdb/confignode/service/ConfigNode.java       |    41 +-
 .../thrift/ConfigNodeRPCServiceProcessor.java      |     2 +-
 .../manager/ClusterSchemaManagerTest.java          |    17 +-
 .../apache/iotdb/consensus/iot/IoTConsensus.java   |     1 +
 .../consensus/iot/IoTConsensusServerImpl.java      |    86 +-
 .../consensus/iot/IoTConsensusServerMetrics.java   |     2 +-
 .../consensus/iot/logdispatcher/LogDispatcher.java |     2 +-
 .../service/IoTConsensusRPCServiceProcessor.java   |     2 +-
 .../apache/iotdb/consensus/iot/ReplicateTest.java  |    32 +-
 .../apache/iotdb/consensus/iot/StabilityTest.java  |    55 +-
 docs/UserGuide/API/Programming-MQTT.md             |     6 +-
 .../UserGuide/Ecosystem-Integration/Flink-IoTDB.md |     3 +-
 .../Apache-IoTDB-DataNode-Dashboard.json           | 15015 +++++++++++++++----
 docs/UserGuide/Monitor-Alert/Metric-Tool.md        |    31 +
 docs/zh/UserGuide/API/Programming-MQTT.md          |     6 +-
 .../UserGuide/Ecosystem-Integration/Flink-IoTDB.md |     8 +-
 docs/zh/UserGuide/Monitor-Alert/Metric-Tool.md     |    31 +
 .../org/apache/iotdb/flink/FlinkIoTDBSink.java     |     2 +-
 .../apache/iotdb/it/env/cluster/AbstractEnv.java   |    64 +-
 .../iotdb/it/env/cluster/AbstractNodeWrapper.java  |     7 -
 .../iotdb/it/env/remote/RemoteServerEnv.java       |     7 +
 .../java/org/apache/iotdb/itbase/env/BaseEnv.java  |    13 +
 .../apache/iotdb/itbase/env/BaseNodeWrapper.java   |     2 -
 .../it/cluster/IoTDBClusterNodeErrorStartUpIT.java |    60 +-
 .../load/IoTDBClusterRegionLeaderBalancingIT.java  |    28 +-
 .../it/partition/IoTDBPartitionDurableIT.java      |    24 +-
 .../db/integration/env/StandaloneEnvConfig.java    |    20 +-
 .../iotdb/metrics/AbstractMetricService.java       |     9 +-
 .../resources/conf/iotdb-common.properties         |     2 +-
 .../iotdb/commons/client/ClientPoolFactory.java    |    58 +-
 .../apache/iotdb/commons/conf/CommonConfig.java    |    72 +-
 .../iotdb/commons/conf/CommonDescriptor.java       |    64 +-
 .../commons/schema/tree/AbstractTreeVisitor.java   |     2 +-
 .../schemaregion/rocksdb/RSchemaConfLoader.java    |     5 +-
 .../{validate-tsfile.bat => settle-tsfile.bat}     |     8 +-
 .../resources/tools/tsfile/settle-tsfile.sh        |    10 +-
 .../apache/iotdb/db/auth/BasicAuthorityCache.java  |    12 +-
 .../apache/iotdb/db/client/ConfigNodeClient.java   |     3 +-
 .../java/org/apache/iotdb/db/conf/IoTDBConfig.java |   127 +-
 .../org/apache/iotdb/db/conf/IoTDBDescriptor.java  |    48 +-
 .../org/apache/iotdb/db/conf/IoTDBStartCheck.java  |    82 +-
 .../db/consensus/DataRegionConsensusImpl.java      |    79 +-
 .../db/consensus/SchemaRegionConsensusImpl.java    |    64 +-
 .../org/apache/iotdb/db/engine/StorageEngine.java  |    27 +-
 .../impl/ReadChunkCompactionPerformer.java         |     3 +-
 .../execute/utils/reader/PointPriorityReader.java  |    14 +-
 .../writer/AbstractCrossCompactionWriter.java      |     5 +-
 .../writer/AbstractInnerCompactionWriter.java      |     5 +-
 .../iotdb/db/engine/flush/MemTableFlushTask.java   |    16 +-
 .../db/engine/flush/pool/FlushTaskPoolManager.java |     6 +-
 .../db/engine/settle/SettleRequestHandler.java     |   323 +
 .../iotdb/db/engine/storagegroup/DataRegion.java   |    46 +-
 .../db/engine/storagegroup/DataRegionInfo.java     |     8 +-
 .../engine/storagegroup/TimePartitionManager.java  |     3 +-
 .../db/engine/storagegroup/TsFileProcessor.java    |    11 +-
 .../engine/trigger/utils/MQTTConnectionPool.java   |     4 +-
 .../db/metadata/cache/DataNodeSchemaCache.java     |     8 +-
 .../db/metadata/mtree/MTreeBelowSGCachedImpl.java  |    30 +
 .../db/metadata/mtree/MTreeBelowSGMemoryImpl.java  |    30 +
 .../mtree/store/disk/schemafile/SchemaFile.java    |    21 +-
 .../disk/schemafile/pagemgr/BTreePageManager.java  |     5 +-
 .../store/disk/schemafile/pagemgr/PageManager.java |    17 +-
 .../traverser/TraverserWithLimitOffsetWrapper.java |    10 +
 .../db/metadata/query/reader/ISchemaReader.java    |    16 +-
 .../iotdb/db/metadata/rescon/MemoryStatistics.java |     3 +-
 .../db/metadata/schemaregion/SchemaEngine.java     |    12 +-
 .../schemaregion/SchemaRegionMemoryImpl.java       |    10 +
 .../schemaregion/SchemaRegionSchemaFileImpl.java   |    10 +
 .../mpp/common/schematree/ClusterSchemaTree.java   |     4 +-
 .../execution/exchange/MPPDataExchangeService.java |    10 +-
 .../mpp/execution/exchange/SharedTsBlockQueue.java |     4 +-
 .../db/mpp/execution/exchange/SinkHandle.java      |     3 +-
 .../db/mpp/execution/exchange/SourceHandle.java    |     3 +-
 .../execution/executor/RegionWriteExecutor.java    |    28 +-
 .../mpp/execution/memory/LocalMemoryManager.java   |     6 +-
 .../operator/process/TransformOperator.java        |     7 +-
 .../schema/CountGroupByLevelScanOperator.java      |     3 +
 .../operator/schema/SchemaCountOperator.java       |     3 +
 .../operator/schema/SchemaQueryScanOperator.java   |     3 +
 .../schema/source/PathsUsingTemplateSource.java    |    26 +
 .../AbstractSeriesAggregationScanOperator.java     |     8 +-
 .../db/mpp/execution/schedule/DriverScheduler.java |    32 +-
 .../mpp/execution/schedule/DriverTaskThread.java   |     8 +-
 .../mpp/execution/schedule/ExecutionContext.java   |    10 +
 .../mpp/execution/schedule/IDriverScheduler.java   |     3 +-
 .../queue/multilevelqueue/DriverTaskHandle.java    |    92 +
 .../multilevelqueue/MultilevelPriorityQueue.java   |   290 +
 .../schedule/queue/multilevelqueue/Priority.java   |    73 +
 .../db/mpp/execution/schedule/task/DriverTask.java |    71 +-
 .../org/apache/iotdb/db/mpp/plan/Coordinator.java  |    14 +-
 .../plan/planner/LocalExecutionPlanContext.java    |     3 +-
 .../db/mpp/plan/planner/LocalExecutionPlanner.java |     5 +-
 .../db/mpp/plan/planner/plan/FragmentInstance.java |     8 +-
 .../plan/planner/plan/node/write/InsertNode.java   |     3 +-
 .../planner/plan/node/write/InsertRowNode.java     |     6 +-
 .../datastructure/SerializableList.java            |     3 +-
 .../iotdb/db/protocol/mqtt/MPPPublishHandler.java  |     7 +-
 .../apache/iotdb/db/rescon/MemTableManager.java    |    17 +-
 .../iotdb/db/rescon/PrimitiveArrayManager.java     |    11 +-
 .../org/apache/iotdb/db/rescon/SystemInfo.java     |    28 +-
 .../iotdb/db/rescon/TsFileResourceManager.java     |     8 +-
 .../apache/iotdb/db/service/IoTDBShutdownHook.java |     3 +-
 .../org/apache/iotdb/db/service/MQTTService.java   |    22 +-
 .../service/thrift/impl/ClientRPCServiceImpl.java  |    28 +-
 .../impl/DataNodeInternalRPCServiceImpl.java       |     7 +
 .../tools/settle/TsFileSettleByCompactionTool.java |   123 +
 .../watermark/GroupedLSBWatermarkEncoder.java      |    12 +-
 .../org/apache/iotdb/db/utils/DateTimeUtils.java   |     9 +-
 .../iotdb/db/utils/EncodingInferenceUtils.java     |     6 +-
 .../java/org/apache/iotdb/db/wal/WALManager.java   |    50 +-
 .../iotdb/db/wal/checkpoint/CheckpointManager.java |     4 +-
 .../java/org/apache/iotdb/db/wal/node/WALNode.java |    13 +-
 .../compaction/FastAlignedCrossCompactionTest.java |   134 +
 .../FastNonAlignedCrossCompactionTest.java         |   138 +
 .../db/engine/settle/SettleRequestHandlerTest.java |   162 +
 .../storagegroup/TimePartitionManagerTest.java     |     6 +-
 .../mpp/execution/exchange/SourceHandleTest.java   |     9 +-
 .../mpp/execution/operator/OperatorMemoryTest.java |    35 +-
 .../schema/CountGroupByLevelMergeOperatorTest.java |    95 +-
 .../operator/schema/SchemaCountOperatorTest.java   |    88 +-
 .../operator/schema/SchemaOperatorTestUtil.java    |    66 +
 .../schema/SchemaQueryScanOperatorTest.java        |    79 +-
 .../schedule/DefaultDriverSchedulerTest.java       |    87 +-
 .../DriverTaskTimeoutSentinelThreadTest.java       |    18 +-
 .../iotdb/db/rescon/ResourceManagerTest.java       |    11 +-
 .../datastructure/PrimitiveArrayManagerTest.java   |    14 +-
 thrift-commons/src/main/thrift/common.thrift       |     4 +
 thrift/src/main/thrift/datanode.thrift             |     2 +
 137 files changed, 15191 insertions(+), 4180 deletions(-)
 copy service-rpc/src/test/java/org/apache/iotdb/rpc/TSStatusCodeTest.java => confignode/src/test/java/org/apache/iotdb/confignode/manager/ClusterSchemaManagerTest.java (56%)
 copy server/src/assembly/resources/tools/tsfile/{validate-tsfile.bat => settle-tsfile.bat} (90%)
 copy rewrite-tsfile-tool/src/assembly/resources/sbin/rewrite-tsfile.sh => server/src/assembly/resources/tools/tsfile/settle-tsfile.sh (80%)
 create mode 100644 server/src/main/java/org/apache/iotdb/db/engine/settle/SettleRequestHandler.java
 create mode 100644 server/src/main/java/org/apache/iotdb/db/mpp/execution/schedule/queue/multilevelqueue/DriverTaskHandle.java
 create mode 100644 server/src/main/java/org/apache/iotdb/db/mpp/execution/schedule/queue/multilevelqueue/MultilevelPriorityQueue.java
 create mode 100644 server/src/main/java/org/apache/iotdb/db/mpp/execution/schedule/queue/multilevelqueue/Priority.java
 create mode 100644 server/src/main/java/org/apache/iotdb/db/tools/settle/TsFileSettleByCompactionTool.java
 create mode 100644 server/src/test/java/org/apache/iotdb/db/engine/settle/SettleRequestHandlerTest.java
 create mode 100644 server/src/test/java/org/apache/iotdb/db/mpp/execution/operator/schema/SchemaOperatorTestUtil.java


[iotdb] 01/02: stash

Posted by yo...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

yongzao pushed a commit to branch Move-ConfigNodeConfig-into-CommonConfig
in repository https://gitbox.apache.org/repos/asf/iotdb.git

commit ff1991cb17c64ecfc461aaab1ed86dd8607e4a77
Author: YongzaoDan <53...@qq.com>
AuthorDate: Thu Jan 12 22:12:53 2023 +0800

    stash
---
 .../confignode/conf/ConfigNodeDescriptor.java      | 124 +++++++++++++-------
 .../confignode/conf/ConfigNodeStartupCheck.java    |  52 +++++----
 .../confignode/conf/SystemPropertiesUtils.java     |  61 +++++-----
 .../confignode/manager/ClusterSchemaManager.java   |  18 +--
 .../iotdb/confignode/manager/ConfigManager.java    |  51 ++++-----
 .../iotdb/confignode/manager/ConsensusManager.java |  64 ++++++-----
 .../manager/load/balancer/RouteBalancer.java       |  21 ++--
 .../manager/node/ClusterNodeStartUtils.java        |   3 +-
 .../manager/partition/PartitionManager.java        |  22 ++--
 .../iotdb/confignode/service/ConfigNode.java       |  41 ++++---
 .../thrift/ConfigNodeRPCServiceProcessor.java      |   2 +-
 .../db/integration/env/StandaloneEnvConfig.java    |  20 ++--
 .../iotdb/commons/client/ClientPoolFactory.java    |  58 +++++-----
 .../apache/iotdb/commons/conf/CommonConfig.java    |  72 +++++++++++-
 .../iotdb/commons/conf/CommonDescriptor.java       |  64 ++++-------
 .../schemaregion/rocksdb/RSchemaConfLoader.java    |   5 +-
 .../apache/iotdb/db/auth/BasicAuthorityCache.java  |  12 +-
 .../apache/iotdb/db/client/ConfigNodeClient.java   |   3 +-
 .../java/org/apache/iotdb/db/conf/IoTDBConfig.java | 127 ++++++++-------------
 .../org/apache/iotdb/db/conf/IoTDBDescriptor.java  |  48 +++++---
 .../org/apache/iotdb/db/conf/IoTDBStartCheck.java  |  82 ++++++-------
 .../db/consensus/DataRegionConsensusImpl.java      |  79 +++++++------
 .../db/consensus/SchemaRegionConsensusImpl.java    |  64 ++++++-----
 .../org/apache/iotdb/db/engine/StorageEngine.java  |  27 +++--
 .../impl/ReadChunkCompactionPerformer.java         |   3 +-
 .../writer/AbstractCrossCompactionWriter.java      |   5 +-
 .../writer/AbstractInnerCompactionWriter.java      |   5 +-
 .../iotdb/db/engine/flush/MemTableFlushTask.java   |  16 +--
 .../db/engine/flush/pool/FlushTaskPoolManager.java |   6 +-
 .../iotdb/db/engine/storagegroup/DataRegion.java   |  46 ++++----
 .../db/engine/storagegroup/DataRegionInfo.java     |   8 +-
 .../engine/storagegroup/TimePartitionManager.java  |   3 +-
 .../db/engine/storagegroup/TsFileProcessor.java    |  11 +-
 .../engine/trigger/utils/MQTTConnectionPool.java   |   4 +-
 .../db/metadata/cache/DataNodeSchemaCache.java     |   8 +-
 .../iotdb/db/metadata/rescon/MemoryStatistics.java |   3 +-
 .../db/metadata/schemaregion/SchemaEngine.java     |  12 +-
 .../mpp/common/schematree/ClusterSchemaTree.java   |   4 +-
 .../execution/exchange/MPPDataExchangeService.java |  10 +-
 .../mpp/execution/exchange/SharedTsBlockQueue.java |   4 +-
 .../db/mpp/execution/exchange/SinkHandle.java      |   3 +-
 .../db/mpp/execution/exchange/SourceHandle.java    |   3 +-
 .../execution/executor/RegionWriteExecutor.java    |  28 +++--
 .../mpp/execution/memory/LocalMemoryManager.java   |   6 +-
 .../operator/process/TransformOperator.java        |   7 +-
 .../org/apache/iotdb/db/mpp/plan/Coordinator.java  |  14 ++-
 .../plan/planner/LocalExecutionPlanContext.java    |   3 +-
 .../db/mpp/plan/planner/LocalExecutionPlanner.java |   5 +-
 .../db/mpp/plan/planner/plan/FragmentInstance.java |   8 +-
 .../plan/planner/plan/node/write/InsertNode.java   |   3 +-
 .../planner/plan/node/write/InsertRowNode.java     |   6 +-
 .../datastructure/SerializableList.java            |   3 +-
 .../iotdb/db/protocol/mqtt/MPPPublishHandler.java  |   7 +-
 .../apache/iotdb/db/rescon/MemTableManager.java    |  17 +--
 .../iotdb/db/rescon/PrimitiveArrayManager.java     |  11 +-
 .../org/apache/iotdb/db/rescon/SystemInfo.java     |  28 ++---
 .../iotdb/db/rescon/TsFileResourceManager.java     |   8 +-
 .../apache/iotdb/db/service/IoTDBShutdownHook.java |   3 +-
 .../org/apache/iotdb/db/service/MQTTService.java   |  22 ++--
 .../service/thrift/impl/ClientRPCServiceImpl.java  |  28 ++---
 .../watermark/GroupedLSBWatermarkEncoder.java      |  12 +-
 .../org/apache/iotdb/db/utils/DateTimeUtils.java   |   9 +-
 .../iotdb/db/utils/EncodingInferenceUtils.java     |   6 +-
 .../java/org/apache/iotdb/db/wal/WALManager.java   |  50 +++++---
 .../iotdb/db/wal/checkpoint/CheckpointManager.java |   4 +-
 .../java/org/apache/iotdb/db/wal/node/WALNode.java |  13 ++-
 .../storagegroup/TimePartitionManagerTest.java     |   6 +-
 .../mpp/execution/exchange/SourceHandleTest.java   |   9 +-
 .../iotdb/db/rescon/ResourceManagerTest.java       |  11 +-
 .../datastructure/PrimitiveArrayManagerTest.java   |  14 ++-
 70 files changed, 910 insertions(+), 705 deletions(-)

diff --git a/confignode/src/main/java/org/apache/iotdb/confignode/conf/ConfigNodeDescriptor.java b/confignode/src/main/java/org/apache/iotdb/confignode/conf/ConfigNodeDescriptor.java
index f39fecf220..b97312ba70 100644
--- a/confignode/src/main/java/org/apache/iotdb/confignode/conf/ConfigNodeDescriptor.java
+++ b/confignode/src/main/java/org/apache/iotdb/confignode/conf/ConfigNodeDescriptor.java
@@ -18,6 +18,8 @@
  */
 package org.apache.iotdb.confignode.conf;
 
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.conf.IoTDBConstant;
 import org.apache.iotdb.commons.exception.BadNodeUrlException;
 import org.apache.iotdb.commons.utils.NodeUrlUtils;
@@ -39,6 +41,7 @@ public class ConfigNodeDescriptor {
   private static final Logger LOGGER = LoggerFactory.getLogger(ConfigNodeDescriptor.class);
 
   private final ConfigNodeConfig CONF = new ConfigNodeConfig();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
 
   private ConfigNodeDescriptor() {
     loadProps();
@@ -48,6 +51,19 @@ public class ConfigNodeDescriptor {
     return CONF;
   }
 
+  public static ConfigNodeDescriptor getInstance() {
+    return ConfigNodeDescriptorHolder.INSTANCE;
+  }
+
+  private static class ConfigNodeDescriptorHolder {
+
+    private static final ConfigNodeDescriptor INSTANCE = new ConfigNodeDescriptor();
+
+    private ConfigNodeDescriptorHolder() {
+      // empty constructor
+    }
+  }
+
   /**
    * Get props url location
    *
@@ -98,6 +114,9 @@ public class ConfigNodeDescriptor {
         LOGGER.warn("Couldn't load ConfigNode conf file, use default config", e);
       } finally {
         CONF.formulateFolders();
+
+        CommonDescriptor.getInstance().initCommonConfigDir(CONF.getCnSystemDir());
+
         MetricConfigDescriptor.getInstance().loadProps(properties);
         MetricConfigDescriptor.getInstance()
             .getMetricConfig()
@@ -111,7 +130,41 @@ public class ConfigNodeDescriptor {
   }
 
   private void loadProperties(Properties properties) throws BadNodeUrlException, IOException {
+    /* ConfigNode RPC Configuration */
+    loadConfigNodeRPCConfiguration(properties);
+
+    /* Target ConfigNodes */
+    loadTargetConfigNodes(properties);
+
+    /* Directory Configuration */
+    loadDirectoryConfiguration(properties);
+
+    try {
+      CONF.setRegionGroupAllocatePolicy(
+          RegionBalancer.RegionGroupAllocatePolicy.valueOf(
+              properties
+                  .getProperty(
+                      "region_group_allocate_policy", CONF.getRegionGroupAllocatePolicy().name())
+                  .trim()));
+    } catch (IllegalArgumentException e) {
+      LOGGER.warn(
+          "The configured region allocate strategy does not exist, use the default: GREEDY!");
+    }
+
+    String routePriorityPolicy =
+        properties.getProperty("route_priority_policy", CONF.getRoutePriorityPolicy()).trim();
+    if (IPriorityBalancer.GREEDY_POLICY.equals(routePriorityPolicy)
+        || IPriorityBalancer.LEADER_POLICY.equals(routePriorityPolicy)) {
+      CONF.setRoutePriorityPolicy(routePriorityPolicy);
+    } else {
+      throw new IOException(
+          String.format(
+              "Unknown route_priority_policy: %s, please set to \"LEADER\" or \"GREEDY\"",
+              routePriorityPolicy));
+    }
+  }
 
+  private void loadConfigNodeRPCConfiguration(Properties properties) {
     CONF.setCnInternalAddress(
         properties
             .getProperty(IoTDBConstant.CN_INTERNAL_ADDRESS, CONF.getCnInternalAddress())
@@ -130,26 +183,25 @@ public class ConfigNodeDescriptor {
                 .getProperty(
                     IoTDBConstant.CN_CONSENSUS_PORT, String.valueOf(CONF.getCnConsensusPort()))
                 .trim()));
+  }
 
+  private void loadTargetConfigNodes(Properties properties) throws BadNodeUrlException {
     // TODO: Enable multiple target_config_node_list
     String targetConfigNodes =
         properties.getProperty(IoTDBConstant.CN_TARGET_CONFIG_NODE_LIST, null);
     if (targetConfigNodes != null) {
       CONF.setCnTargetConfigNode(NodeUrlUtils.parseTEndPointUrl(targetConfigNodes.trim()));
     }
+  }
 
-    try {
-      CONF.setRegionGroupAllocatePolicy(
-          RegionBalancer.RegionGroupAllocatePolicy.valueOf(
-              properties
-                  .getProperty(
-                      "region_group_allocate_policy", CONF.getRegionGroupAllocatePolicy().name())
-                  .trim()));
-    } catch (IllegalArgumentException e) {
-      LOGGER.warn(
-          "The configured region allocate strategy does not exist, use the default: GREEDY!");
-    }
+  private void loadDirectoryConfiguration(Properties properties) {
+    CONF.setCnSystemDir(properties.getProperty("cn_system_dir", CONF.getCnSystemDir()).trim());
+
+    CONF.setCnConsensusDir(
+        properties.getProperty("cn_consensus_dir", CONF.getCnConsensusDir()).trim());
+  }
 
+  private void loadThriftRPCConfiguration(Properties properties) {
     CONF.setCnRpcThriftCompressionEnable(
         Boolean.parseBoolean(
             properties
@@ -157,6 +209,7 @@ public class ConfigNodeDescriptor {
                     "cn_rpc_thrift_compression_enable",
                     String.valueOf(CONF.isCnRpcThriftCompressionEnable()))
                 .trim()));
+    COMMON_CONFIG.setRpcThriftCompressionEnable(CONF.isCnRpcThriftCompressionEnable());
 
     CONF.setCnRpcAdvancedCompressionEnable(
         Boolean.parseBoolean(
@@ -194,6 +247,7 @@ public class ConfigNodeDescriptor {
                 .getProperty(
                     "cn_connection_timeout_ms", String.valueOf(CONF.getCnConnectionTimeoutMs()))
                 .trim()));
+    COMMON_CONFIG.setConnectionTimeoutInMS(CONF.getCnConnectionTimeoutMs());
 
     CONF.setCnSelectorThreadNumsOfClientManager(
         Integer.parseInt(
@@ -202,23 +256,28 @@ public class ConfigNodeDescriptor {
                     "cn_selector_thread_nums_of_client_manager",
                     String.valueOf(CONF.getCnSelectorThreadNumsOfClientManager()))
                 .trim()));
+    COMMON_CONFIG.setSelectorThreadCountOfClientManager(
+        CONF.getCnSelectorThreadNumsOfClientManager());
 
-    CONF.setCnSystemDir(properties.getProperty("cn_system_dir", CONF.getCnSystemDir()).trim());
-
-    CONF.setCnConsensusDir(
-        properties.getProperty("cn_consensus_dir", CONF.getCnConsensusDir()).trim());
+    CONF.setCnCoreClientCountForEachNodeInClientManager(
+        Integer.parseInt(
+            properties
+                .getProperty(
+                    "cn_core_client_count_for_each_node_in_client_manager",
+                    String.valueOf(CONF.getCnCoreClientCountForEachNodeInClientManager()))
+                .trim()));
+    COMMON_CONFIG.setCoreClientCountForEachNodeInClientManager(
+        CONF.getCnCoreClientCountForEachNodeInClientManager());
 
-    String routePriorityPolicy =
-        properties.getProperty("route_priority_policy", CONF.getRoutePriorityPolicy()).trim();
-    if (IPriorityBalancer.GREEDY_POLICY.equals(routePriorityPolicy)
-        || IPriorityBalancer.LEADER_POLICY.equals(routePriorityPolicy)) {
-      CONF.setRoutePriorityPolicy(routePriorityPolicy);
-    } else {
-      throw new IOException(
-          String.format(
-              "Unknown route_priority_policy: %s, please set to \"LEADER\" or \"GREEDY\"",
-              routePriorityPolicy));
-    }
+    CONF.setCnMaxClientCountForEachNodeInClientManager(
+        Integer.parseInt(
+            properties
+                .getProperty(
+                    "cn_max_client_count_for_each_node_in_client_manager",
+                    String.valueOf(CONF.getCnMaxClientCountForEachNodeInClientManager()))
+                .trim()));
+    COMMON_CONFIG.setMaxClientCountForEachNodeInClientManager(
+        CONF.getCnMaxClientCountForEachNodeInClientManager());
   }
 
   /**
@@ -234,17 +293,4 @@ public class ConfigNodeDescriptor {
                 && NodeUrlUtils.isLocalAddress(CONF.getCnTargetConfigNode().getIp())))
         && CONF.getCnInternalPort() == CONF.getCnTargetConfigNode().getPort();
   }
-
-  public static ConfigNodeDescriptor getInstance() {
-    return ConfigNodeDescriptorHolder.INSTANCE;
-  }
-
-  private static class ConfigNodeDescriptorHolder {
-
-    private static final ConfigNodeDescriptor INSTANCE = new ConfigNodeDescriptor();
-
-    private ConfigNodeDescriptorHolder() {
-      // empty constructor
-    }
-  }
 }
diff --git a/confignode/src/main/java/org/apache/iotdb/confignode/conf/ConfigNodeStartupCheck.java b/confignode/src/main/java/org/apache/iotdb/confignode/conf/ConfigNodeStartupCheck.java
index 13076c073b..3e3768849a 100644
--- a/confignode/src/main/java/org/apache/iotdb/confignode/conf/ConfigNodeStartupCheck.java
+++ b/confignode/src/main/java/org/apache/iotdb/confignode/conf/ConfigNodeStartupCheck.java
@@ -18,9 +18,12 @@
  */
 package org.apache.iotdb.confignode.conf;
 
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.conf.IoTDBConstant;
 import org.apache.iotdb.commons.exception.ConfigurationException;
 import org.apache.iotdb.commons.exception.StartupException;
+import org.apache.iotdb.commons.loadbalance.LeaderDistributionPolicy;
 import org.apache.iotdb.confignode.manager.load.balancer.router.leader.ILeaderBalancer;
 import org.apache.iotdb.confignode.manager.load.balancer.router.priority.IPriorityBalancer;
 import org.apache.iotdb.consensus.ConsensusFactory;
@@ -39,7 +42,8 @@ public class ConfigNodeStartupCheck {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(ConfigNodeStartupCheck.class);
 
-  private static final ConfigNodeConfig CONF = ConfigNodeDescriptor.getInstance().getConf();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
+  private static final ConfigNodeConfig CONFIG_NODE_CONFIG = ConfigNodeDescriptor.getInstance().getConf();
 
   public void startUpCheck() throws StartupException, IOException, ConfigurationException {
     checkGlobalConfig();
@@ -53,78 +57,78 @@ public class ConfigNodeStartupCheck {
   private void checkGlobalConfig() throws ConfigurationException {
     // When the ConfigNode consensus protocol is set to SIMPLE_CONSENSUS,
     // the target_config_node_list needs to point to itself
-    if (CONF.getConfigNodeConsensusProtocolClass().equals(ConsensusFactory.SIMPLE_CONSENSUS)
-        && (!CONF.getCnInternalAddress().equals(CONF.getCnTargetConfigNode().getIp())
-            || CONF.getCnInternalPort() != CONF.getCnTargetConfigNode().getPort())) {
+    if (COMMON_CONFIG.getConfigNodeConsensusProtocolClass().getProtocol().equals(ConsensusFactory.SIMPLE_CONSENSUS)
+        && (!CONFIG_NODE_CONFIG.getCnInternalAddress().equals(CONFIG_NODE_CONFIG.getCnTargetConfigNode().getIp())
+            || CONFIG_NODE_CONFIG.getCnInternalPort() != CONFIG_NODE_CONFIG.getCnTargetConfigNode().getPort())) {
       throw new ConfigurationException(
           IoTDBConstant.CN_TARGET_CONFIG_NODE_LIST,
-          CONF.getCnTargetConfigNode().getIp() + ":" + CONF.getCnTargetConfigNode().getPort(),
-          CONF.getCnInternalAddress() + ":" + CONF.getCnInternalPort());
+          CONFIG_NODE_CONFIG.getCnTargetConfigNode().getIp() + ":" + CONFIG_NODE_CONFIG.getCnTargetConfigNode().getPort(),
+          CONFIG_NODE_CONFIG.getCnInternalAddress() + ":" + CONFIG_NODE_CONFIG.getCnInternalPort());
     }
 
     // When the data region consensus protocol is set to SIMPLE_CONSENSUS,
     // the data replication factor must be 1
-    if (CONF.getDataRegionConsensusProtocolClass().equals(ConsensusFactory.SIMPLE_CONSENSUS)
-        && CONF.getDataReplicationFactor() != 1) {
+    if (COMMON_CONFIG.getDataRegionConsensusProtocolClass().getProtocol().equals(ConsensusFactory.SIMPLE_CONSENSUS)
+        && COMMON_CONFIG.getDataReplicationFactor() != 1) {
       throw new ConfigurationException(
           "data_replication_factor",
-          String.valueOf(CONF.getDataReplicationFactor()),
+          String.valueOf(COMMON_CONFIG.getDataReplicationFactor()),
           String.valueOf(1));
     }
 
     // When the schema region consensus protocol is set to SIMPLE_CONSENSUS,
     // the schema replication factor must be 1
-    if (CONF.getSchemaRegionConsensusProtocolClass().equals(ConsensusFactory.SIMPLE_CONSENSUS)
-        && CONF.getSchemaReplicationFactor() != 1) {
+    if (COMMON_CONFIG.getSchemaRegionConsensusProtocolClass().getProtocol().equals(ConsensusFactory.SIMPLE_CONSENSUS)
+        && COMMON_CONFIG.getSchemaReplicationFactor() != 1) {
       throw new ConfigurationException(
           "schema_replication_factor",
-          String.valueOf(CONF.getSchemaReplicationFactor()),
+          String.valueOf(COMMON_CONFIG.getSchemaReplicationFactor()),
           String.valueOf(1));
     }
 
     // When the schema region consensus protocol is set to IoTConsensus,
     // we should report an error
-    if (CONF.getSchemaRegionConsensusProtocolClass().equals(ConsensusFactory.IOT_CONSENSUS)) {
+    if (COMMON_CONFIG.getSchemaRegionConsensusProtocolClass().getProtocol().equals(ConsensusFactory.IOT_CONSENSUS)) {
       throw new ConfigurationException(
           "schema_region_consensus_protocol_class",
-          String.valueOf(CONF.getSchemaRegionConsensusProtocolClass()),
+          String.valueOf(COMMON_CONFIG.getSchemaRegionConsensusProtocolClass()),
           String.format(
               "%s or %s", ConsensusFactory.SIMPLE_CONSENSUS, ConsensusFactory.RATIS_CONSENSUS));
     }
 
     // The leader distribution policy is limited
-    if (!ILeaderBalancer.GREEDY_POLICY.equals(CONF.getLeaderDistributionPolicy())
-        && !ILeaderBalancer.MIN_COST_FLOW_POLICY.equals(CONF.getLeaderDistributionPolicy())) {
+    if (!LeaderDistributionPolicy.GREEDY.equals(COMMON_CONFIG.getLeaderDistributionPolicy())
+        && !LeaderDistributionPolicy.MIN_COST_FLOW.equals(COMMON_CONFIG.getLeaderDistributionPolicy())) {
       throw new ConfigurationException(
-          "leader_distribution_policy", CONF.getRoutePriorityPolicy(), "GREEDY or MIN_COST_FLOW");
+          "leader_distribution_policy", CONFIG_NODE_CONFIG.getRoutePriorityPolicy(), "GREEDY or MIN_COST_FLOW");
     }
 
     // The route priority policy is limited
-    if (!CONF.getRoutePriorityPolicy().equals(IPriorityBalancer.LEADER_POLICY)
-        && !CONF.getRoutePriorityPolicy().equals(IPriorityBalancer.GREEDY_POLICY)) {
+    if (!CONFIG_NODE_CONFIG.getRoutePriorityPolicy().equals(IPriorityBalancer.LEADER_POLICY)
+        && !CONFIG_NODE_CONFIG.getRoutePriorityPolicy().equals(IPriorityBalancer.GREEDY_POLICY)) {
       throw new ConfigurationException(
-          "route_priority_policy", CONF.getRoutePriorityPolicy(), "LEADER or GREEDY");
+          "route_priority_policy", CONFIG_NODE_CONFIG.getRoutePriorityPolicy(), "LEADER or GREEDY");
     }
 
     // The ip of target ConfigNode couldn't be 0.0.0.0
-    if (CONF.getCnTargetConfigNode().getIp().equals("0.0.0.0")) {
+    if (CONFIG_NODE_CONFIG.getCnTargetConfigNode().getIp().equals("0.0.0.0")) {
       throw new ConfigurationException(
           "The ip address of any target_config_node_list couldn't be 0.0.0.0");
     }
 
     // The least DataRegionGroup number should be positive
-    if (CONF.getLeastDataRegionGroupNum() <= 0) {
+    if (COMMON_CONFIG.getLeastDataRegionGroupNum() <= 0) {
       throw new ConfigurationException("The least_data_region_group_num should be positive");
     }
   }
 
   private void createDirsIfNecessary() throws IOException {
     // If systemDir does not exist, create systemDir
-    File systemDir = new File(CONF.getCnSystemDir());
+    File systemDir = new File(CONFIG_NODE_CONFIG.getCnSystemDir());
     createDirIfEmpty(systemDir);
 
     // If consensusDir does not exist, create consensusDir
-    File consensusDir = new File(CONF.getCnConsensusDir());
+    File consensusDir = new File(CONFIG_NODE_CONFIG.getCnConsensusDir());
     createDirIfEmpty(consensusDir);
   }
 
diff --git a/confignode/src/main/java/org/apache/iotdb/confignode/conf/SystemPropertiesUtils.java b/confignode/src/main/java/org/apache/iotdb/confignode/conf/SystemPropertiesUtils.java
index 85c878826c..a88c8461c2 100644
--- a/confignode/src/main/java/org/apache/iotdb/confignode/conf/SystemPropertiesUtils.java
+++ b/confignode/src/main/java/org/apache/iotdb/confignode/conf/SystemPropertiesUtils.java
@@ -19,6 +19,8 @@
 package org.apache.iotdb.confignode.conf;
 
 import org.apache.iotdb.common.rpc.thrift.TConfigNodeLocation;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.exception.BadNodeUrlException;
 import org.apache.iotdb.commons.exception.ConfigurationException;
 import org.apache.iotdb.commons.utils.NodeUrlUtils;
@@ -48,7 +50,8 @@ public class SystemPropertiesUtils {
               + File.separator
               + ConfigNodeConstant.SYSTEM_FILE_NAME);
 
-  private static final ConfigNodeConfig conf = ConfigNodeDescriptor.getInstance().getConf();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
+  private static final ConfigNodeConfig CONFIG_NODE_CONFIG = ConfigNodeDescriptor.getInstance().getConf();
 
   /**
    * Check if the ConfigNode is restarted
@@ -72,26 +75,26 @@ public class SystemPropertiesUtils {
 
     // Startup configuration
     String clusterName = systemProperties.getProperty(CLUSTER_NAME, null);
-    if (clusterName != null && !clusterName.equals(conf.getClusterName())) {
-      throw new ConfigurationException(CLUSTER_NAME, conf.getClusterName(), clusterName);
+    if (clusterName != null && !clusterName.equals(COMMON_CONFIG.getClusterName())) {
+      throw new ConfigurationException(CLUSTER_NAME, COMMON_CONFIG.getClusterName(), clusterName);
     }
 
     String internalAddress = systemProperties.getProperty("cn_internal_address", null);
     if (internalAddress == null) {
       needReWrite = true;
-    } else if (!internalAddress.equals(conf.getCnInternalAddress())) {
+    } else if (!internalAddress.equals(CONFIG_NODE_CONFIG.getCnInternalAddress())) {
       throw new ConfigurationException(
-          "cn_internal_address", conf.getCnInternalAddress(), internalAddress);
+          "cn_internal_address", CONFIG_NODE_CONFIG.getCnInternalAddress(), internalAddress);
     }
 
     if (systemProperties.getProperty("cn_internal_port", null) == null) {
       needReWrite = true;
     } else {
       int internalPort = Integer.parseInt(systemProperties.getProperty("cn_internal_port"));
-      if (internalPort != conf.getCnInternalPort()) {
+      if (internalPort != CONFIG_NODE_CONFIG.getCnInternalPort()) {
         throw new ConfigurationException(
             "cn_internal_port",
-            String.valueOf(conf.getCnInternalPort()),
+            String.valueOf(CONFIG_NODE_CONFIG.getCnInternalPort()),
             String.valueOf(internalPort));
       }
     }
@@ -100,10 +103,10 @@ public class SystemPropertiesUtils {
       needReWrite = true;
     } else {
       int consensusPort = Integer.parseInt(systemProperties.getProperty("cn_consensus_port"));
-      if (consensusPort != conf.getCnConsensusPort()) {
+      if (consensusPort != CONFIG_NODE_CONFIG.getCnConsensusPort()) {
         throw new ConfigurationException(
             "cn_consensus_port",
-            String.valueOf(conf.getCnConsensusPort()),
+            String.valueOf(CONFIG_NODE_CONFIG.getCnConsensusPort()),
             String.valueOf(consensusPort));
       }
     }
@@ -114,10 +117,10 @@ public class SystemPropertiesUtils {
     if (configNodeConsensusProtocolClass == null) {
       needReWrite = true;
     } else if (!configNodeConsensusProtocolClass.equals(
-        conf.getConfigNodeConsensusProtocolClass())) {
+      COMMON_CONFIG.getConfigNodeConsensusProtocolClass().getProtocol())) {
       throw new ConfigurationException(
           "config_node_consensus_protocol_class",
-          conf.getConfigNodeConsensusProtocolClass(),
+        COMMON_CONFIG.getConfigNodeConsensusProtocolClass().getProtocol(),
           configNodeConsensusProtocolClass);
     }
 
@@ -126,10 +129,10 @@ public class SystemPropertiesUtils {
     if (dataRegionConsensusProtocolClass == null) {
       needReWrite = true;
     } else if (!dataRegionConsensusProtocolClass.equals(
-        conf.getDataRegionConsensusProtocolClass())) {
+      COMMON_CONFIG.getDataRegionConsensusProtocolClass().getProtocol())) {
       throw new ConfigurationException(
           "data_region_consensus_protocol_class",
-          conf.getDataRegionConsensusProtocolClass(),
+        COMMON_CONFIG.getDataRegionConsensusProtocolClass().getProtocol(),
           dataRegionConsensusProtocolClass);
     }
 
@@ -138,10 +141,10 @@ public class SystemPropertiesUtils {
     if (schemaRegionConsensusProtocolClass == null) {
       needReWrite = true;
     } else if (!schemaRegionConsensusProtocolClass.equals(
-        conf.getSchemaRegionConsensusProtocolClass())) {
+      COMMON_CONFIG.getSchemaRegionConsensusProtocolClass().getProtocol())) {
       throw new ConfigurationException(
           "schema_region_consensus_protocol_class",
-          conf.getSchemaRegionConsensusProtocolClass(),
+        COMMON_CONFIG.getSchemaRegionConsensusProtocolClass().getProtocol(),
           schemaRegionConsensusProtocolClass);
     }
 
@@ -151,10 +154,10 @@ public class SystemPropertiesUtils {
     } else {
       int seriesPartitionSlotNum =
           Integer.parseInt(systemProperties.getProperty("series_partition_slot_num"));
-      if (seriesPartitionSlotNum != conf.getSeriesSlotNum()) {
+      if (seriesPartitionSlotNum != COMMON_CONFIG.getSeriesSlotNum()) {
         throw new ConfigurationException(
             "series_partition_slot_num",
-            String.valueOf(conf.getSeriesSlotNum()),
+            String.valueOf(COMMON_CONFIG.getSeriesSlotNum()),
             String.valueOf(seriesPartitionSlotNum));
       }
     }
@@ -164,10 +167,10 @@ public class SystemPropertiesUtils {
     if (seriesPartitionSlotExecutorClass == null) {
       needReWrite = true;
     } else if (!Objects.equals(
-        seriesPartitionSlotExecutorClass, conf.getSeriesPartitionExecutorClass())) {
+        seriesPartitionSlotExecutorClass, COMMON_CONFIG.getSeriesPartitionExecutorClass())) {
       throw new ConfigurationException(
           "series_partition_executor_class",
-          conf.getSeriesPartitionExecutorClass(),
+        COMMON_CONFIG.getSeriesPartitionExecutorClass(),
           seriesPartitionSlotExecutorClass);
     }
 
@@ -205,31 +208,31 @@ public class SystemPropertiesUtils {
     Properties systemProperties = getSystemProperties();
 
     // Cluster configuration
-    systemProperties.setProperty("cluster_name", conf.getClusterName());
-    systemProperties.setProperty("config_node_id", String.valueOf(conf.getConfigNodeId()));
+    systemProperties.setProperty("cluster_name", COMMON_CONFIG.getClusterName());
+    systemProperties.setProperty("config_node_id", String.valueOf(CONFIG_NODE_CONFIG.getConfigNodeId()));
     systemProperties.setProperty(
         "is_seed_config_node",
         String.valueOf(ConfigNodeDescriptor.getInstance().isSeedConfigNode()));
 
     // Startup configuration
     systemProperties.setProperty(
-        "cn_internal_address", String.valueOf(conf.getCnInternalAddress()));
-    systemProperties.setProperty("cn_internal_port", String.valueOf(conf.getCnInternalPort()));
-    systemProperties.setProperty("cn_consensus_port", String.valueOf(conf.getCnConsensusPort()));
+        "cn_internal_address", String.valueOf(CONFIG_NODE_CONFIG.getCnInternalAddress()));
+    systemProperties.setProperty("cn_internal_port", String.valueOf(CONFIG_NODE_CONFIG.getCnInternalPort()));
+    systemProperties.setProperty("cn_consensus_port", String.valueOf(CONFIG_NODE_CONFIG.getCnConsensusPort()));
 
     // Consensus protocol configuration
     systemProperties.setProperty(
-        "config_node_consensus_protocol_class", conf.getConfigNodeConsensusProtocolClass());
+        "config_node_consensus_protocol_class", COMMON_CONFIG.getConfigNodeConsensusProtocolClass().getProtocol());
     systemProperties.setProperty(
-        "data_region_consensus_protocol_class", conf.getDataRegionConsensusProtocolClass());
+        "data_region_consensus_protocol_class", COMMON_CONFIG.getDataRegionConsensusProtocolClass().getProtocol());
     systemProperties.setProperty(
-        "schema_region_consensus_protocol_class", conf.getSchemaRegionConsensusProtocolClass());
+        "schema_region_consensus_protocol_class", COMMON_CONFIG.getSchemaRegionConsensusProtocolClass().getProtocol());
 
     // PartitionSlot configuration
     systemProperties.setProperty(
-        "series_partition_slot_num", String.valueOf(conf.getSeriesSlotNum()));
+        "series_partition_slot_num", String.valueOf(COMMON_CONFIG.getSeriesSlotNum()));
     systemProperties.setProperty(
-        "series_partition_executor_class", conf.getSeriesPartitionExecutorClass());
+        "series_partition_executor_class", COMMON_CONFIG.getSeriesPartitionExecutorClass());
 
     storeSystemProperties(systemProperties);
   }
diff --git a/confignode/src/main/java/org/apache/iotdb/confignode/manager/ClusterSchemaManager.java b/confignode/src/main/java/org/apache/iotdb/confignode/manager/ClusterSchemaManager.java
index 70341b82c2..ac82a02b76 100644
--- a/confignode/src/main/java/org/apache/iotdb/confignode/manager/ClusterSchemaManager.java
+++ b/confignode/src/main/java/org/apache/iotdb/confignode/manager/ClusterSchemaManager.java
@@ -23,6 +23,8 @@ import org.apache.iotdb.common.rpc.thrift.TDataNodeConfiguration;
 import org.apache.iotdb.common.rpc.thrift.TDataNodeLocation;
 import org.apache.iotdb.common.rpc.thrift.TSStatus;
 import org.apache.iotdb.common.rpc.thrift.TSetTTLReq;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.exception.IllegalPathException;
 import org.apache.iotdb.commons.exception.MetadataException;
 import org.apache.iotdb.commons.path.PartialPath;
@@ -99,11 +101,11 @@ public class ClusterSchemaManager {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(ClusterSchemaManager.class);
 
-  private static final ConfigNodeConfig CONF = ConfigNodeDescriptor.getInstance().getConf();
-  private static final int LEAST_SCHEMA_REGION_GROUP_NUM = CONF.getLeastSchemaRegionGroupNum();
-  private static final double SCHEMA_REGION_PER_DATA_NODE = CONF.getSchemaRegionPerDataNode();
-  private static final int LEAST_DATA_REGION_GROUP_NUM = CONF.getLeastDataRegionGroupNum();
-  private static final double DATA_REGION_PER_PROCESSOR = CONF.getDataRegionPerProcessor();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
+  private static final int LEAST_SCHEMA_REGION_GROUP_NUM = COMMON_CONFIG.getLeastSchemaRegionGroupNum();
+  private static final double SCHEMA_REGION_PER_DATA_NODE = COMMON_CONFIG.getSchemaRegionPerDataNode();
+  private static final int LEAST_DATA_REGION_GROUP_NUM = COMMON_CONFIG.getLeastDataRegionGroupNum();
+  private static final double DATA_REGION_PER_PROCESSOR = COMMON_CONFIG.getDataRegionPerProcessor();
 
   private final IManager configManager;
   private final ClusterSchemaInfo clusterSchemaInfo;
@@ -330,11 +332,11 @@ public class ClusterSchemaManager {
         (int)
             Math.ceil(
                 (double) totalCpuCoreNum
-                    / (double) (storageGroupNum * CONF.getDataReplicationFactor()));
-    if (leastDataRegionGroupNum < CONF.getLeastDataRegionGroupNum()) {
+                    / (double) (storageGroupNum * COMMON_CONFIG.getDataReplicationFactor()));
+    if (leastDataRegionGroupNum < COMMON_CONFIG.getLeastDataRegionGroupNum()) {
       // The leastDataRegionGroupNum should be the maximum integer that satisfy:
       // 1 <= leastDataRegionGroupNum <= 5(default)
-      CONF.setLeastDataRegionGroupNum(leastDataRegionGroupNum);
+      COMMON_CONFIG.setLeastDataRegionGroupNum(leastDataRegionGroupNum);
       LOGGER.info(
           "[AdjustRegionGroupNum] The least number of DataRegionGroups per Database is adjusted to: {}",
           leastDataRegionGroupNum);
diff --git a/confignode/src/main/java/org/apache/iotdb/confignode/manager/ConfigManager.java b/confignode/src/main/java/org/apache/iotdb/confignode/manager/ConfigManager.java
index 9d5ab17eac..47b8ad6e1e 100644
--- a/confignode/src/main/java/org/apache/iotdb/confignode/manager/ConfigManager.java
+++ b/confignode/src/main/java/org/apache/iotdb/confignode/manager/ConfigManager.java
@@ -179,7 +179,6 @@ public class ConfigManager implements IManager {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(ConfigManager.class);
 
-  private static final ConfigNodeConfig CONF = ConfigNodeDescriptor.getInstance().getConf();
   private static final CommonConfig COMMON_CONF = CommonDescriptor.getInstance().getConfig();
 
   /** Manage PartitionTable read/write requests through the ConsensusLayer */
@@ -422,24 +421,24 @@ public class ConfigManager implements IManager {
 
   public TClusterParameters getClusterParameters() {
     TClusterParameters clusterParameters = new TClusterParameters();
-    clusterParameters.setClusterName(CONF.getClusterName());
+    clusterParameters.setClusterName(COMMON_CONF.getClusterName());
     clusterParameters.setConfigNodeConsensusProtocolClass(
-        CONF.getConfigNodeConsensusProtocolClass());
+      COMMON_CONF.getConfigNodeConsensusProtocolClass().getProtocol());
     clusterParameters.setDataRegionConsensusProtocolClass(
-        CONF.getDataRegionConsensusProtocolClass());
+      COMMON_CONF.getDataRegionConsensusProtocolClass().getProtocol());
     clusterParameters.setSchemaRegionConsensusProtocolClass(
-        CONF.getSchemaRegionConsensusProtocolClass());
-    clusterParameters.setSeriesPartitionSlotNum(CONF.getSeriesSlotNum());
-    clusterParameters.setSeriesPartitionExecutorClass(CONF.getSeriesPartitionExecutorClass());
+      COMMON_CONF.getSchemaRegionConsensusProtocolClass().getProtocol());
+    clusterParameters.setSeriesPartitionSlotNum(COMMON_CONF.getSeriesSlotNum());
+    clusterParameters.setSeriesPartitionExecutorClass(COMMON_CONF.getSeriesPartitionExecutorClass());
     clusterParameters.setDefaultTTL(COMMON_CONF.getDefaultTtlInMs());
-    clusterParameters.setTimePartitionInterval(CONF.getTimePartitionInterval());
-    clusterParameters.setDataReplicationFactor(CONF.getDataReplicationFactor());
-    clusterParameters.setSchemaReplicationFactor(CONF.getSchemaReplicationFactor());
-    clusterParameters.setDataRegionPerProcessor(CONF.getDataRegionPerProcessor());
-    clusterParameters.setSchemaRegionPerDataNode(CONF.getSchemaRegionPerDataNode());
+    clusterParameters.setTimePartitionInterval(COMMON_CONF.getTimePartitionInterval());
+    clusterParameters.setDataReplicationFactor(COMMON_CONF.getDataReplicationFactor());
+    clusterParameters.setSchemaReplicationFactor(COMMON_CONF.getSchemaReplicationFactor());
+    clusterParameters.setDataRegionPerProcessor(COMMON_CONF.getDataRegionPerProcessor());
+    clusterParameters.setSchemaRegionPerDataNode(COMMON_CONF.getSchemaRegionPerDataNode());
     clusterParameters.setDiskSpaceWarningThreshold(COMMON_CONF.getDiskSpaceWarningThreshold());
-    clusterParameters.setReadConsistencyLevel(CONF.getReadConsistencyLevel());
-    clusterParameters.setLeastDataRegionGroupNum(CONF.getLeastDataRegionGroupNum());
+    clusterParameters.setReadConsistencyLevel(COMMON_CONF.getReadConsistencyLevel());
+    clusterParameters.setLeastDataRegionGroupNum(COMMON_CONF.getLeastDataRegionGroupNum());
     return clusterParameters;
   }
 
@@ -879,29 +878,29 @@ public class ConfigManager implements IManager {
 
     if (!clusterParameters
         .getConfigNodeConsensusProtocolClass()
-        .equals(CONF.getConfigNodeConsensusProtocolClass())) {
+        .equals(COMMON_CONF.getConfigNodeConsensusProtocolClass().getProtocol())) {
       return errorStatus.setMessage(
           errorPrefix + "config_node_consensus_protocol_class" + errorSuffix);
     }
     if (!clusterParameters
         .getDataRegionConsensusProtocolClass()
-        .equals(CONF.getDataRegionConsensusProtocolClass())) {
+        .equals(COMMON_CONF.getDataRegionConsensusProtocolClass().getProtocol())) {
       return errorStatus.setMessage(
           errorPrefix + "data_region_consensus_protocol_class" + errorSuffix);
     }
     if (!clusterParameters
         .getSchemaRegionConsensusProtocolClass()
-        .equals(CONF.getSchemaRegionConsensusProtocolClass())) {
+        .equals(COMMON_CONF.getSchemaRegionConsensusProtocolClass().getProtocol())) {
       return errorStatus.setMessage(
           errorPrefix + "schema_region_consensus_protocol_class" + errorSuffix);
     }
 
-    if (clusterParameters.getSeriesPartitionSlotNum() != CONF.getSeriesSlotNum()) {
+    if (clusterParameters.getSeriesPartitionSlotNum() != COMMON_CONF.getSeriesSlotNum()) {
       return errorStatus.setMessage(errorPrefix + "series_partition_slot_num" + errorSuffix);
     }
     if (!clusterParameters
         .getSeriesPartitionExecutorClass()
-        .equals(CONF.getSeriesPartitionExecutorClass())) {
+        .equals(COMMON_CONF.getSeriesPartitionExecutorClass())) {
       return errorStatus.setMessage(errorPrefix + "series_partition_executor_class" + errorSuffix);
     }
 
@@ -909,25 +908,25 @@ public class ConfigManager implements IManager {
         != CommonDescriptor.getInstance().getConfig().getDefaultTtlInMs()) {
       return errorStatus.setMessage(errorPrefix + "default_ttl" + errorSuffix);
     }
-    if (clusterParameters.getTimePartitionInterval() != CONF.getTimePartitionInterval()) {
+    if (clusterParameters.getTimePartitionInterval() != COMMON_CONF.getTimePartitionInterval()) {
       return errorStatus.setMessage(errorPrefix + "time_partition_interval" + errorSuffix);
     }
 
-    if (clusterParameters.getSchemaReplicationFactor() != CONF.getSchemaReplicationFactor()) {
+    if (clusterParameters.getSchemaReplicationFactor() != COMMON_CONF.getSchemaReplicationFactor()) {
       return errorStatus.setMessage(errorPrefix + "schema_replication_factor" + errorSuffix);
     }
-    if (clusterParameters.getDataReplicationFactor() != CONF.getDataReplicationFactor()) {
+    if (clusterParameters.getDataReplicationFactor() != COMMON_CONF.getDataReplicationFactor()) {
       return errorStatus.setMessage(errorPrefix + "data_replication_factor" + errorSuffix);
     }
 
-    if (clusterParameters.getSchemaRegionPerDataNode() != CONF.getSchemaRegionPerDataNode()) {
+    if (clusterParameters.getSchemaRegionPerDataNode() != COMMON_CONF.getSchemaRegionPerDataNode()) {
       return errorStatus.setMessage(errorPrefix + "schema_region_per_data_node" + errorSuffix);
     }
-    if (clusterParameters.getDataRegionPerProcessor() != CONF.getDataRegionPerProcessor()) {
+    if (clusterParameters.getDataRegionPerProcessor() != COMMON_CONF.getDataRegionPerProcessor()) {
       return errorStatus.setMessage(errorPrefix + "data_region_per_processor" + errorSuffix);
     }
 
-    if (!clusterParameters.getReadConsistencyLevel().equals(CONF.getReadConsistencyLevel())) {
+    if (!clusterParameters.getReadConsistencyLevel().equals(COMMON_CONF.getReadConsistencyLevel())) {
       return errorStatus.setMessage(errorPrefix + "read_consistency_level" + errorSuffix);
     }
 
@@ -936,7 +935,7 @@ public class ConfigManager implements IManager {
       return errorStatus.setMessage(errorPrefix + "disk_space_warning_threshold" + errorSuffix);
     }
 
-    if (clusterParameters.getLeastDataRegionGroupNum() != CONF.getLeastDataRegionGroupNum()) {
+    if (clusterParameters.getLeastDataRegionGroupNum() != COMMON_CONF.getLeastDataRegionGroupNum()) {
       return errorStatus.setMessage(errorPrefix + "least_data_region_group_num" + errorSuffix);
     }
 
diff --git a/confignode/src/main/java/org/apache/iotdb/confignode/manager/ConsensusManager.java b/confignode/src/main/java/org/apache/iotdb/confignode/manager/ConsensusManager.java
index 3e77084f15..443b80971c 100644
--- a/confignode/src/main/java/org/apache/iotdb/confignode/manager/ConsensusManager.java
+++ b/confignode/src/main/java/org/apache/iotdb/confignode/manager/ConsensusManager.java
@@ -21,6 +21,8 @@ package org.apache.iotdb.confignode.manager;
 import org.apache.iotdb.common.rpc.thrift.TConfigNodeLocation;
 import org.apache.iotdb.common.rpc.thrift.TEndPoint;
 import org.apache.iotdb.common.rpc.thrift.TSStatus;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.consensus.ConfigNodeRegionId;
 import org.apache.iotdb.commons.consensus.ConsensusGroupId;
 import org.apache.iotdb.commons.exception.BadNodeUrlException;
@@ -58,7 +60,9 @@ import static org.apache.iotdb.consensus.ConsensusFactory.SIMPLE_CONSENSUS;
 public class ConsensusManager {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(ConsensusManager.class);
-  private static final ConfigNodeConfig CONF = ConfigNodeDescriptor.getInstance().getConf();
+
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
+  private static final ConfigNodeConfig CONFIG_NODE_CONFIG = ConfigNodeDescriptor.getInstance().getConf();
   private static final int SEED_CONFIG_NODE_ID = 0;
 
   private final IManager configManager;
@@ -79,15 +83,15 @@ public class ConsensusManager {
   /** ConsensusLayer local implementation */
   private void setConsensusLayer(ConfigNodeRegionStateMachine stateMachine) throws IOException {
     // There is only one ConfigNodeGroup
-    consensusGroupId = new ConfigNodeRegionId(CONF.getConfigNodeRegionId());
+    consensusGroupId = new ConfigNodeRegionId(CONFIG_NODE_CONFIG.getConfigNodeRegionId());
 
-    if (SIMPLE_CONSENSUS.equals(CONF.getConfigNodeConsensusProtocolClass())) {
+    if (SIMPLE_CONSENSUS.equals(COMMON_CONFIG.getConfigNodeConsensusProtocolClass().getProtocol())) {
       consensusImpl =
           ConsensusFactory.getConsensusImpl(
                   SIMPLE_CONSENSUS,
                   ConsensusConfig.newBuilder()
                       .setThisNode(
-                          new TEndPoint(CONF.getCnInternalAddress(), CONF.getCnConsensusPort()))
+                          new TEndPoint(CONFIG_NODE_CONFIG.getCnInternalAddress(), CONFIG_NODE_CONFIG.getCnConsensusPort()))
                       .setStorageDir("target" + java.io.File.separator + "simple")
                       .build(),
                   gid -> stateMachine)
@@ -99,84 +103,84 @@ public class ConsensusManager {
       // Implement local ConsensusLayer by ConfigNodeConfig
       consensusImpl =
           ConsensusFactory.getConsensusImpl(
-                  CONF.getConfigNodeConsensusProtocolClass(),
+              COMMON_CONFIG.getConfigNodeConsensusProtocolClass().getProtocol(),
                   ConsensusConfig.newBuilder()
-                      .setThisNodeId(CONF.getConfigNodeId())
+                      .setThisNodeId(CONFIG_NODE_CONFIG.getConfigNodeId())
                       .setThisNode(
-                          new TEndPoint(CONF.getCnInternalAddress(), CONF.getCnConsensusPort()))
+                          new TEndPoint(CONFIG_NODE_CONFIG.getCnInternalAddress(), CONFIG_NODE_CONFIG.getCnConsensusPort()))
                       .setRatisConfig(
                           RatisConfig.newBuilder()
                               .setLeaderLogAppender(
                                   RatisConfig.LeaderLogAppender.newBuilder()
                                       .setBufferByteLimit(
-                                          CONF.getConfigNodeRatisConsensusLogAppenderBufferSize())
+                                        COMMON_CONFIG.getConfigNodeRatisConsensusLogAppenderBufferSize())
                                       .build())
                               .setSnapshot(
                                   RatisConfig.Snapshot.newBuilder()
                                       .setAutoTriggerThreshold(
-                                          CONF.getConfigNodeRatisSnapshotTriggerThreshold())
+                                        COMMON_CONFIG.getConfigNodeRatisSnapshotTriggerThreshold())
                                       .build())
                               .setLog(
                                   RatisConfig.Log.newBuilder()
                                       .setUnsafeFlushEnabled(
-                                          CONF.isConfigNodeRatisLogUnsafeFlushEnable())
+                                        COMMON_CONFIG.isConfigNodeRatisLogUnsafeFlushEnable())
                                       .setSegmentCacheSizeMax(
                                           SizeInBytes.valueOf(
-                                              CONF.getConfigNodeRatisLogSegmentSizeMax()))
+                                            COMMON_CONFIG.getConfigNodeRatisLogSegmentSizeMax()))
                                       .setPreserveNumsWhenPurge(
-                                          CONF.getConfigNodeRatisPreserveLogsWhenPurge())
+                                        COMMON_CONFIG.getConfigNodeRatisPreserveLogsWhenPurge())
                                       .build())
                               .setGrpc(
                                   RatisConfig.Grpc.newBuilder()
                                       .setFlowControlWindow(
                                           SizeInBytes.valueOf(
-                                              CONF.getConfigNodeRatisGrpcFlowControlWindow()))
+                                            COMMON_CONFIG.getConfigNodeRatisGrpcFlowControlWindow()))
                                       .build())
                               .setRpc(
                                   RatisConfig.Rpc.newBuilder()
                                       .setTimeoutMin(
                                           TimeDuration.valueOf(
-                                              CONF
+                                            COMMON_CONFIG
                                                   .getConfigNodeRatisRpcLeaderElectionTimeoutMinMs(),
                                               TimeUnit.MILLISECONDS))
                                       .setTimeoutMax(
                                           TimeDuration.valueOf(
-                                              CONF
+                                            COMMON_CONFIG
                                                   .getConfigNodeRatisRpcLeaderElectionTimeoutMaxMs(),
                                               TimeUnit.MILLISECONDS))
                                       .setRequestTimeout(
                                           TimeDuration.valueOf(
-                                              CONF.getConfigNodeRatisRequestTimeoutMs(),
+                                            COMMON_CONFIG.getConfigNodeRatisRequestTimeoutMs(),
                                               TimeUnit.MILLISECONDS))
                                       .setFirstElectionTimeoutMin(
                                           TimeDuration.valueOf(
-                                              CONF.getRatisFirstElectionTimeoutMinMs(),
+                                            COMMON_CONFIG.getRatisFirstElectionTimeoutMinMs(),
                                               TimeUnit.MILLISECONDS))
                                       .setFirstElectionTimeoutMax(
                                           TimeDuration.valueOf(
-                                              CONF.getRatisFirstElectionTimeoutMaxMs(),
+                                            COMMON_CONFIG.getRatisFirstElectionTimeoutMaxMs(),
                                               TimeUnit.MILLISECONDS))
                                       .build())
                               .setClient(
                                   RatisConfig.Client.newBuilder()
                                       .setClientRequestTimeoutMillis(
-                                          CONF.getConfigNodeRatisRequestTimeoutMs())
+                                        COMMON_CONFIG.getConfigNodeRatisRequestTimeoutMs())
                                       .setClientMaxRetryAttempt(
-                                          CONF.getConfigNodeRatisMaxRetryAttempts())
+                                        COMMON_CONFIG.getConfigNodeRatisMaxRetryAttempts())
                                       .setClientRetryInitialSleepTimeMs(
-                                          CONF.getConfigNodeRatisInitialSleepTimeMs())
+                                        COMMON_CONFIG.getConfigNodeRatisInitialSleepTimeMs())
                                       .setClientRetryMaxSleepTimeMs(
-                                          CONF.getConfigNodeRatisMaxSleepTimeMs())
+                                        COMMON_CONFIG.getConfigNodeRatisMaxSleepTimeMs())
                                       .setCoreClientNumForEachNode(
-                                          CONF.getCoreClientNumForEachNode())
-                                      .setMaxClientNumForEachNode(CONF.getMaxClientNumForEachNode())
+                                        CONFIG_NODE_CONFIG.getCnCoreClientCountForEachNodeInClientManager())
+                                      .setMaxClientNumForEachNode(CONFIG_NODE_CONFIG.getCnMaxClientCountForEachNodeInClientManager())
                                       .build())
                               .setImpl(
                                   RatisConfig.Impl.newBuilder()
-                                      .setTriggerSnapshotFileSize(CONF.getConfigNodeRatisLogMax())
+                                      .setTriggerSnapshotFileSize(COMMON_CONFIG.getConfigNodeRatisLogMax())
                                       .build())
                               .build())
-                      .setStorageDir(CONF.getCnConsensusDir())
+                      .setStorageDir(CONFIG_NODE_CONFIG.getCnConsensusDir())
                       .build(),
                   gid -> stateMachine)
               .orElseThrow(
@@ -184,13 +188,13 @@ public class ConsensusManager {
                       new IllegalArgumentException(
                           String.format(
                               ConsensusFactory.CONSTRUCT_FAILED_MSG,
-                              CONF.getConfigNodeConsensusProtocolClass())));
+                            COMMON_CONFIG.getConfigNodeConsensusProtocolClass())));
     }
     consensusImpl.start();
     if (SystemPropertiesUtils.isRestarted()) {
       // TODO: @Itami-Sho Check and notify if current ConfigNode's ip or port has changed
 
-      if (SIMPLE_CONSENSUS.equals(CONF.getConfigNodeConsensusProtocolClass())) {
+      if (SIMPLE_CONSENSUS.equals(COMMON_CONFIG.getConfigNodeConsensusProtocolClass().getProtocol())) {
         // Only SIMPLE_CONSENSUS need invoking `createPeerForConsensusGroup` when restarted,
         // but RATIS_CONSENSUS doesn't need it
         try {
@@ -207,8 +211,8 @@ public class ConsensusManager {
           Collections.singletonList(
               new TConfigNodeLocation(
                   SEED_CONFIG_NODE_ID,
-                  new TEndPoint(CONF.getCnInternalAddress(), CONF.getCnInternalPort()),
-                  new TEndPoint(CONF.getCnInternalAddress(), CONF.getCnConsensusPort()))));
+                  new TEndPoint(CONFIG_NODE_CONFIG.getCnInternalAddress(), CONFIG_NODE_CONFIG.getCnInternalPort()),
+                  new TEndPoint(CONFIG_NODE_CONFIG.getCnInternalAddress(), CONFIG_NODE_CONFIG.getCnConsensusPort()))));
     }
   }
 
diff --git a/confignode/src/main/java/org/apache/iotdb/confignode/manager/load/balancer/RouteBalancer.java b/confignode/src/main/java/org/apache/iotdb/confignode/manager/load/balancer/RouteBalancer.java
index 960c0a38fc..56bb87f033 100644
--- a/confignode/src/main/java/org/apache/iotdb/confignode/manager/load/balancer/RouteBalancer.java
+++ b/confignode/src/main/java/org/apache/iotdb/confignode/manager/load/balancer/RouteBalancer.java
@@ -27,6 +27,8 @@ import org.apache.iotdb.common.rpc.thrift.TSStatus;
 import org.apache.iotdb.commons.cluster.NodeStatus;
 import org.apache.iotdb.commons.concurrent.IoTDBThreadPoolFactory;
 import org.apache.iotdb.commons.concurrent.threadpool.ScheduledExecutorUtil;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.loadbalance.LeaderDistributionPolicy;
 import org.apache.iotdb.confignode.client.DataNodeRequestType;
 import org.apache.iotdb.confignode.client.async.AsyncDataNodeClientPool;
@@ -72,21 +74,22 @@ public class RouteBalancer {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(RouteBalancer.class);
 
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
   private static final ConfigNodeConfig CONF = ConfigNodeDescriptor.getInstance().getConf();
   private static final String SCHEMA_REGION_CONSENSUS_PROTOCOL_CLASS =
-      CONF.getSchemaRegionConsensusProtocolClass();
+    COMMON_CONFIG.getSchemaRegionConsensusProtocolClass().getProtocol();
   private static final String DATA_REGION_CONSENSUS_PROTOCOL_CLASS =
-      CONF.getDataRegionConsensusProtocolClass();
+    COMMON_CONFIG.getDataRegionConsensusProtocolClass().getProtocol();
 
   private static final boolean IS_ENABLE_AUTO_LEADER_BALANCE_FOR_DATA_REGION =
-      (CONF.isEnableAutoLeaderBalanceForRatisConsensus()
+      (COMMON_CONFIG.isEnableAutoLeaderBalanceForRatisConsensus()
               && ConsensusFactory.RATIS_CONSENSUS.equals(DATA_REGION_CONSENSUS_PROTOCOL_CLASS))
-          || (CONF.isEnableAutoLeaderBalanceForIoTConsensus()
+          || (COMMON_CONFIG.isEnableAutoLeaderBalanceForIoTConsensus()
               && ConsensusFactory.IOT_CONSENSUS.equals(DATA_REGION_CONSENSUS_PROTOCOL_CLASS));
   private static final boolean IS_ENABLE_AUTO_LEADER_BALANCE_FOR_SCHEMA_REGION =
-      (CONF.isEnableAutoLeaderBalanceForRatisConsensus()
+      (COMMON_CONFIG.isEnableAutoLeaderBalanceForRatisConsensus()
               && ConsensusFactory.RATIS_CONSENSUS.equals(SCHEMA_REGION_CONSENSUS_PROTOCOL_CLASS))
-          || (CONF.isEnableAutoLeaderBalanceForIoTConsensus()
+          || (COMMON_CONFIG.isEnableAutoLeaderBalanceForIoTConsensus()
               && ConsensusFactory.IOT_CONSENSUS.equals(SCHEMA_REGION_CONSENSUS_PROTOCOL_CLASS));
 
   private static final boolean IS_DATA_REGION_IOT_CONSENSUS =
@@ -120,11 +123,11 @@ public class RouteBalancer {
     this.leaderCache = new ConcurrentHashMap<>();
     this.regionRouteMap = new RegionRouteMap();
 
-    switch (CONF.getLeaderDistributionPolicy()) {
-      case LeaderDistributionPolicy.GREEDY_POLICY:
+    switch (COMMON_CONFIG.getLeaderDistributionPolicy()) {
+      case GREEDY:
         this.leaderBalancer = new GreedyLeaderBalancer();
         break;
-      case LeaderDistributionPolicy.MIN_COST_FLOW_POLICY:
+      case MIN_COST_FLOW:
       default:
         this.leaderBalancer = new MinCostFlowLeaderBalancer();
         break;
diff --git a/confignode/src/main/java/org/apache/iotdb/confignode/manager/node/ClusterNodeStartUtils.java b/confignode/src/main/java/org/apache/iotdb/confignode/manager/node/ClusterNodeStartUtils.java
index d1a118a9f2..8e660cbed7 100644
--- a/confignode/src/main/java/org/apache/iotdb/confignode/manager/node/ClusterNodeStartUtils.java
+++ b/confignode/src/main/java/org/apache/iotdb/confignode/manager/node/ClusterNodeStartUtils.java
@@ -25,6 +25,7 @@ import org.apache.iotdb.common.rpc.thrift.TEndPoint;
 import org.apache.iotdb.common.rpc.thrift.TSStatus;
 import org.apache.iotdb.commons.cluster.NodeStatus;
 import org.apache.iotdb.commons.cluster.NodeType;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.conf.IoTDBConstant;
 import org.apache.iotdb.confignode.conf.ConfigNodeConstant;
 import org.apache.iotdb.confignode.conf.ConfigNodeDescriptor;
@@ -41,7 +42,7 @@ import java.util.Set;
 public class ClusterNodeStartUtils {
 
   private static final String CLUSTER_NAME =
-      ConfigNodeDescriptor.getInstance().getConf().getClusterName();
+      CommonDescriptor.getInstance().getConfig().getClusterName();
 
   private static final String POSSIBLE_SOLUTIONS = " Possible solutions are as follows:\r\n";
 
diff --git a/confignode/src/main/java/org/apache/iotdb/confignode/manager/partition/PartitionManager.java b/confignode/src/main/java/org/apache/iotdb/confignode/manager/partition/PartitionManager.java
index 7b01530848..384b4adf24 100644
--- a/confignode/src/main/java/org/apache/iotdb/confignode/manager/partition/PartitionManager.java
+++ b/confignode/src/main/java/org/apache/iotdb/confignode/manager/partition/PartitionManager.java
@@ -29,6 +29,8 @@ import org.apache.iotdb.commons.cluster.RegionRoleType;
 import org.apache.iotdb.commons.cluster.RegionStatus;
 import org.apache.iotdb.commons.concurrent.IoTDBThreadPoolFactory;
 import org.apache.iotdb.commons.concurrent.threadpool.ScheduledExecutorUtil;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.loadbalance.RegionGroupExtensionPolicy;
 import org.apache.iotdb.commons.partition.DataPartitionTable;
 import org.apache.iotdb.commons.partition.SchemaPartitionTable;
@@ -105,14 +107,14 @@ public class PartitionManager {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(PartitionManager.class);
 
-  private static final ConfigNodeConfig CONF = ConfigNodeDescriptor.getInstance().getConf();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
   private static final RegionGroupExtensionPolicy SCHEMA_REGION_GROUP_EXTENSION_POLICY =
-      CONF.getSchemaRegionGroupExtensionPolicy();
+    COMMON_CONFIG.getSchemaRegionGroupExtensionPolicy();
   private static final int SCHEMA_REGION_GROUP_PER_DATABASE =
-      CONF.getSchemaRegionGroupPerDatabase();
+    COMMON_CONFIG.getSchemaRegionGroupPerDatabase();
   private static final RegionGroupExtensionPolicy DATA_REGION_GROUP_EXTENSION_POLICY =
-      CONF.getDataRegionGroupExtensionPolicy();
-  private static final int DATA_REGION_GROUP_PER_DATABASE = CONF.getDataRegionGroupPerDatabase();
+    COMMON_CONFIG.getDataRegionGroupExtensionPolicy();
+  private static final int DATA_REGION_GROUP_PER_DATABASE = COMMON_CONFIG.getDataRegionGroupPerDatabase();
 
   private final IManager configManager;
   private final PartitionInfo partitionInfo;
@@ -143,7 +145,7 @@ public class PartitionManager {
   private void setSeriesPartitionExecutor() {
     this.executor =
         SeriesPartitionExecutor.getSeriesPartitionExecutor(
-            CONF.getSeriesPartitionExecutorClass(), CONF.getSeriesSlotNum());
+          COMMON_CONFIG.getSeriesPartitionExecutorClass(), COMMON_CONFIG.getSeriesSlotNum());
   }
 
   // ======================================================
@@ -420,14 +422,14 @@ public class PartitionManager {
               + unassignedPartitionSlotsCount;
       float maxRegionGroupCount =
           getClusterSchemaManager().getMaxRegionGroupNum(storageGroup, consensusGroupType);
-      float maxSlotCount = CONF.getSeriesSlotNum();
+      float maxSlotCount = COMMON_CONFIG.getSeriesSlotNum();
 
       /* RegionGroup extension is required in the following cases */
       // 1. The number of current RegionGroup of the StorageGroup is less than the least number
       int leastRegionGroupNum =
           TConsensusGroupType.SchemaRegion.equals(consensusGroupType)
-              ? CONF.getLeastSchemaRegionGroupNum()
-              : CONF.getLeastDataRegionGroupNum();
+              ? COMMON_CONFIG.getLeastSchemaRegionGroupNum()
+              : COMMON_CONFIG.getLeastDataRegionGroupNum();
       if (allocatedRegionGroupCount < leastRegionGroupNum) {
         // Let the sum of unassignedPartitionSlotsCount and allocatedRegionGroupCount
         // no less than the leastRegionGroupNum
@@ -702,7 +704,7 @@ public class PartitionManager {
                 ? req.getTimeSlotId()
                 : (req.isSetTimeStamp()
                     ? new TTimePartitionSlot(
-                        req.getTimeStamp() - req.getTimeStamp() % CONF.getTimePartitionInterval())
+                        req.getTimeStamp() - req.getTimeStamp() % COMMON_CONFIG.getTimePartitionInterval())
                     : null));
     return (GetRegionIdResp) getConsensusManager().read(plan).getDataset();
   }
diff --git a/confignode/src/main/java/org/apache/iotdb/confignode/service/ConfigNode.java b/confignode/src/main/java/org/apache/iotdb/confignode/service/ConfigNode.java
index deb6ffaaae..931b6966ef 100644
--- a/confignode/src/main/java/org/apache/iotdb/confignode/service/ConfigNode.java
+++ b/confignode/src/main/java/org/apache/iotdb/confignode/service/ConfigNode.java
@@ -21,6 +21,8 @@ package org.apache.iotdb.confignode.service;
 import org.apache.iotdb.common.rpc.thrift.TConfigNodeLocation;
 import org.apache.iotdb.common.rpc.thrift.TEndPoint;
 import org.apache.iotdb.common.rpc.thrift.TSStatus;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.exception.StartupException;
 import org.apache.iotdb.commons.service.JMXService;
 import org.apache.iotdb.commons.service.RegisterManager;
@@ -55,7 +57,8 @@ public class ConfigNode implements ConfigNodeMBean {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(ConfigNode.class);
 
-  private static final ConfigNodeConfig CONF = ConfigNodeDescriptor.getInstance().getConf();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
+  private static final ConfigNodeConfig CONFIG_NODE_CONFIG = ConfigNodeDescriptor.getInstance().getConf();
 
   private static final int STARTUP_RETRY_NUM = 10;
   private static final int SCHEDULE_WAITING_RETRY_NUM = 20;
@@ -96,8 +99,8 @@ public class ConfigNode implements ConfigNodeMBean {
         LOGGER.info("{} is in restarting process...", ConfigNodeConstant.GLOBAL_NAME);
 
         /* Always restore ClusterName and ConfigNodeId first */
-        CONF.setClusterName(SystemPropertiesUtils.loadClusterNameWhenRestarted());
-        CONF.setConfigNodeId(SystemPropertiesUtils.loadConfigNodeIdWhenRestarted());
+        COMMON_CONFIG.setClusterName(SystemPropertiesUtils.loadClusterNameWhenRestarted());
+        CONFIG_NODE_CONFIG.setConfigNodeId(SystemPropertiesUtils.loadConfigNodeIdWhenRestarted());
 
         if (!SystemPropertiesUtils.isSeedConfigNode()) {
           // The non-seed-ConfigNodes should send restart request
@@ -109,7 +112,7 @@ public class ConfigNode implements ConfigNodeMBean {
         LOGGER.info(
             "{} has successfully restarted and joined the cluster: {}.",
             ConfigNodeConstant.GLOBAL_NAME,
-            CONF.getClusterName());
+          COMMON_CONFIG.getClusterName());
         return;
       }
 
@@ -120,7 +123,7 @@ public class ConfigNode implements ConfigNodeMBean {
             ConfigNodeConstant.GLOBAL_NAME);
 
         /* Always set ClusterId and ConfigNodeId before initConsensusManager */
-        CONF.setConfigNodeId(SEED_CONFIG_NODE_ID);
+        CONFIG_NODE_CONFIG.setConfigNodeId(SEED_CONFIG_NODE_ID);
         configManager.initConsensusManager();
 
         // Persistence system parameters after the consensusGroup is built,
@@ -133,8 +136,8 @@ public class ConfigNode implements ConfigNodeMBean {
             .applyConfigNode(
                 new TConfigNodeLocation(
                     SEED_CONFIG_NODE_ID,
-                    new TEndPoint(CONF.getCnInternalAddress(), CONF.getCnInternalPort()),
-                    new TEndPoint(CONF.getCnInternalAddress(), CONF.getCnConsensusPort())));
+                    new TEndPoint(CONFIG_NODE_CONFIG.getCnInternalAddress(), CONFIG_NODE_CONFIG.getCnInternalPort()),
+                    new TEndPoint(CONFIG_NODE_CONFIG.getCnInternalAddress(), CONFIG_NODE_CONFIG.getCnConsensusPort())));
         // We always set up Seed-ConfigNode's RPC service lastly to ensure that
         // the external service is not provided until Seed-ConfigNode is fully initialized
         setUpRPCService();
@@ -143,7 +146,7 @@ public class ConfigNode implements ConfigNodeMBean {
         LOGGER.info(
             "{} has successfully started and joined the cluster: {}.",
             ConfigNodeConstant.GLOBAL_NAME,
-            CONF.getClusterName());
+          COMMON_CONFIG.getClusterName());
         return;
       }
 
@@ -157,8 +160,8 @@ public class ConfigNode implements ConfigNodeMBean {
       LOGGER.info(
           "{} {} has registered successfully. Waiting for the leader's scheduling to join the cluster: {}.",
           ConfigNodeConstant.GLOBAL_NAME,
-          CONF.getConfigNodeId(),
-          CONF.getClusterName());
+          CONFIG_NODE_CONFIG.getConfigNodeId(),
+        COMMON_CONFIG.getClusterName());
 
       boolean isJoinedCluster = false;
       for (int retry = 0; retry < SCHEDULE_WAITING_RETRY_NUM; retry++) {
@@ -237,11 +240,11 @@ public class ConfigNode implements ConfigNodeMBean {
         new TConfigNodeRegisterReq(
             new TConfigNodeLocation(
                 INIT_NON_SEED_CONFIG_NODE_ID,
-                new TEndPoint(CONF.getCnInternalAddress(), CONF.getCnInternalPort()),
-                new TEndPoint(CONF.getCnInternalAddress(), CONF.getCnConsensusPort())),
+                new TEndPoint(CONFIG_NODE_CONFIG.getCnInternalAddress(), CONFIG_NODE_CONFIG.getCnInternalPort()),
+                new TEndPoint(CONFIG_NODE_CONFIG.getCnInternalAddress(), CONFIG_NODE_CONFIG.getCnConsensusPort())),
             configManager.getClusterParameters());
 
-    TEndPoint targetConfigNode = CONF.getCnTargetConfigNode();
+    TEndPoint targetConfigNode = CONFIG_NODE_CONFIG.getCnTargetConfigNode();
     if (targetConfigNode == null) {
       LOGGER.error(
           "Please set the cn_target_config_node_list parameter in iotdb-confignode.properties file.");
@@ -269,7 +272,7 @@ public class ConfigNode implements ConfigNodeMBean {
           throw new StartupException("The result of register ConfigNode is empty!");
         }
         /* Always set ConfigNodeId before initConsensusManager */
-        CONF.setConfigNodeId(resp.getConfigNodeId());
+        CONFIG_NODE_CONFIG.setConfigNodeId(resp.getConfigNodeId());
         configManager.initConsensusManager();
         return;
       } else if (status.getCode() == TSStatusCode.REDIRECTION_RECOMMEND.getStatusCode()) {
@@ -294,13 +297,13 @@ public class ConfigNode implements ConfigNodeMBean {
   private void sendRestartConfigNodeRequest() throws IOException, StartupException {
     TConfigNodeRestartReq req =
         new TConfigNodeRestartReq(
-            CONF.getClusterName(),
+          COMMON_CONFIG.getClusterName(),
             new TConfigNodeLocation(
-                CONF.getConfigNodeId(),
-                new TEndPoint(CONF.getCnInternalAddress(), CONF.getCnInternalPort()),
-                new TEndPoint(CONF.getCnInternalAddress(), CONF.getCnConsensusPort())));
+                CONFIG_NODE_CONFIG.getConfigNodeId(),
+                new TEndPoint(CONFIG_NODE_CONFIG.getCnInternalAddress(), CONFIG_NODE_CONFIG.getCnInternalPort()),
+                new TEndPoint(CONFIG_NODE_CONFIG.getCnInternalAddress(), CONFIG_NODE_CONFIG.getCnConsensusPort())));
 
-    TEndPoint targetConfigNode = CONF.getCnTargetConfigNode();
+    TEndPoint targetConfigNode = CONFIG_NODE_CONFIG.getCnTargetConfigNode();
     if (targetConfigNode == null) {
       LOGGER.error(
           "Please set the cn_target_config_node_list parameter in iotdb-confignode.properties file.");
diff --git a/confignode/src/main/java/org/apache/iotdb/confignode/service/thrift/ConfigNodeRPCServiceProcessor.java b/confignode/src/main/java/org/apache/iotdb/confignode/service/thrift/ConfigNodeRPCServiceProcessor.java
index f5247a39ab..1c98553867 100644
--- a/confignode/src/main/java/org/apache/iotdb/confignode/service/thrift/ConfigNodeRPCServiceProcessor.java
+++ b/confignode/src/main/java/org/apache/iotdb/confignode/service/thrift/ConfigNodeRPCServiceProcessor.java
@@ -487,7 +487,7 @@ public class ConfigNodeRPCServiceProcessor implements IConfigNodeRPCService.Ifac
     LOGGER.info(
         "{} has successfully started and joined the cluster: {}.",
         ConfigNodeConstant.GLOBAL_NAME,
-        ConfigNodeDescriptor.getInstance().getConf().getClusterName());
+        CommonDescriptor.getInstance().getConfig().getClusterName());
     return StatusUtils.OK;
   }
 
diff --git a/integration/src/test/java/org/apache/iotdb/db/integration/env/StandaloneEnvConfig.java b/integration/src/test/java/org/apache/iotdb/db/integration/env/StandaloneEnvConfig.java
index 7bf97ccb59..fd67267428 100644
--- a/integration/src/test/java/org/apache/iotdb/db/integration/env/StandaloneEnvConfig.java
+++ b/integration/src/test/java/org/apache/iotdb/db/integration/env/StandaloneEnvConfig.java
@@ -18,6 +18,7 @@
  */
 package org.apache.iotdb.db.integration.env;
 
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.itbase.env.BaseConfig;
 import org.apache.iotdb.tsfile.common.conf.TSFileDescriptor;
@@ -41,12 +42,7 @@ public class StandaloneEnvConfig implements BaseConfig {
   }
 
   public BaseConfig setMemtableSizeThreshold(long memtableSizeThreshold) {
-    IoTDBDescriptor.getInstance().getConfig().setMemtableSizeThreshold(memtableSizeThreshold);
-    return this;
-  }
-
-  public BaseConfig setDataRegionNum(int dataRegionNum) {
-    IoTDBDescriptor.getInstance().getConfig().setDataRegionNum(dataRegionNum);
+    CommonDescriptor.getInstance().getConfig().setMemtableSizeThreshold(memtableSizeThreshold);
     return this;
   }
 
@@ -61,9 +57,9 @@ public class StandaloneEnvConfig implements BaseConfig {
   }
 
   public BaseConfig setMaxQueryDeduplicatedPathNum(int maxQueryDeduplicatedPathNum) {
-    IoTDBDescriptor.getInstance()
+    CommonDescriptor.getInstance()
         .getConfig()
-        .setMaxQueryDeduplicatedPathNum(maxQueryDeduplicatedPathNum);
+        .setMaxDeduplicatedPathNum(maxQueryDeduplicatedPathNum);
     return this;
   }
 
@@ -82,21 +78,21 @@ public class StandaloneEnvConfig implements BaseConfig {
   }
 
   public BaseConfig setUdfCollectorMemoryBudgetInMB(float udfCollectorMemoryBudgetInMB) {
-    IoTDBDescriptor.getInstance()
+    CommonDescriptor.getInstance()
         .getConfig()
         .setUdfCollectorMemoryBudgetInMB(udfCollectorMemoryBudgetInMB);
     return this;
   }
 
   public BaseConfig setUdfTransformerMemoryBudgetInMB(float udfTransformerMemoryBudgetInMB) {
-    IoTDBDescriptor.getInstance()
+    CommonDescriptor.getInstance()
         .getConfig()
         .setUdfTransformerMemoryBudgetInMB(udfTransformerMemoryBudgetInMB);
     return this;
   }
 
   public BaseConfig setUdfReaderMemoryBudgetInMB(float udfReaderMemoryBudgetInMB) {
-    IoTDBDescriptor.getInstance()
+    CommonDescriptor.getInstance()
         .getConfig()
         .setUdfReaderMemoryBudgetInMB(udfReaderMemoryBudgetInMB);
     return this;
@@ -134,7 +130,7 @@ public class StandaloneEnvConfig implements BaseConfig {
   }
 
   public BaseConfig setAutoCreateSchemaEnabled(boolean enableAutoCreateSchema) {
-    IoTDBDescriptor.getInstance().getConfig().setAutoCreateSchemaEnabled(enableAutoCreateSchema);
+    CommonDescriptor.getInstance().getConfig().setEnableAutoCreateSchema(enableAutoCreateSchema);
     return this;
   }
 }
diff --git a/node-commons/src/main/java/org/apache/iotdb/commons/client/ClientPoolFactory.java b/node-commons/src/main/java/org/apache/iotdb/commons/client/ClientPoolFactory.java
index b30620f8be..8142f5a51d 100644
--- a/node-commons/src/main/java/org/apache/iotdb/commons/client/ClientPoolFactory.java
+++ b/node-commons/src/main/java/org/apache/iotdb/commons/client/ClientPoolFactory.java
@@ -54,11 +54,11 @@ public class ClientPoolFactory {
               manager,
               new ThriftClientProperty.Builder()
                   .setConnectionTimeoutMs(conf.getConnectionTimeoutInMS())
-                  .setRpcThriftCompressionEnabled(conf.isRpcThriftCompressionEnabled())
+                  .setRpcThriftCompressionEnabled(conf.isRpcThriftCompressionEnable())
                   .build()),
           new ClientPoolProperty.Builder<SyncConfigNodeIServiceClient>()
-              .setCoreClientNumForEachNode(conf.getCoreClientNumForEachNode())
-              .setMaxClientNumForEachNode(conf.getMaxClientNumForEachNode())
+              .setCoreClientNumForEachNode(conf.getCoreClientCountForEachNodeInClientManager())
+              .setMaxClientNumForEachNode(conf.getMaxClientCountForEachNodeInClientManager())
               .build()
               .getConfig());
     }
@@ -75,13 +75,13 @@ public class ClientPoolFactory {
               manager,
               new ThriftClientProperty.Builder()
                   .setConnectionTimeoutMs(conf.getConnectionTimeoutInMS())
-                  .setRpcThriftCompressionEnabled(conf.isRpcThriftCompressionEnabled())
-                  .setSelectorNumOfAsyncClientManager(conf.getSelectorNumOfClientManager())
+                  .setRpcThriftCompressionEnabled(conf.isRpcThriftCompressionEnable())
+                  .setSelectorNumOfAsyncClientManager(conf.getSelectorThreadCountOfClientManager())
                   .build(),
               ThreadName.ASYNC_CONFIGNODE_CLIENT_POOL.getName()),
           new ClientPoolProperty.Builder<AsyncConfigNodeIServiceClient>()
-              .setCoreClientNumForEachNode(conf.getCoreClientNumForEachNode())
-              .setMaxClientNumForEachNode(conf.getMaxClientNumForEachNode())
+              .setCoreClientNumForEachNode(conf.getCoreClientCountForEachNodeInClientManager())
+              .setMaxClientNumForEachNode(conf.getMaxClientCountForEachNodeInClientManager())
               .build()
               .getConfig());
     }
@@ -98,11 +98,11 @@ public class ClientPoolFactory {
               manager,
               new ThriftClientProperty.Builder()
                   .setConnectionTimeoutMs(conf.getConnectionTimeoutInMS())
-                  .setRpcThriftCompressionEnabled(conf.isRpcThriftCompressionEnabled())
+                  .setRpcThriftCompressionEnabled(conf.isRpcThriftCompressionEnable())
                   .build()),
           new ClientPoolProperty.Builder<SyncDataNodeInternalServiceClient>()
-              .setCoreClientNumForEachNode(conf.getCoreClientNumForEachNode())
-              .setMaxClientNumForEachNode(conf.getMaxClientNumForEachNode())
+              .setCoreClientNumForEachNode(conf.getCoreClientCountForEachNodeInClientManager())
+              .setMaxClientNumForEachNode(conf.getMaxClientCountForEachNodeInClientManager())
               .build()
               .getConfig());
     }
@@ -119,13 +119,13 @@ public class ClientPoolFactory {
               manager,
               new ThriftClientProperty.Builder()
                   .setConnectionTimeoutMs(conf.getConnectionTimeoutInMS())
-                  .setRpcThriftCompressionEnabled(conf.isRpcThriftCompressionEnabled())
-                  .setSelectorNumOfAsyncClientManager(conf.getSelectorNumOfClientManager())
+                  .setRpcThriftCompressionEnabled(conf.isRpcThriftCompressionEnable())
+                  .setSelectorNumOfAsyncClientManager(conf.getSelectorThreadCountOfClientManager())
                   .build(),
               ThreadName.ASYNC_DATANODE_CLIENT_POOL.getName()),
           new ClientPoolProperty.Builder<AsyncDataNodeInternalServiceClient>()
-              .setCoreClientNumForEachNode(conf.getCoreClientNumForEachNode())
-              .setMaxClientNumForEachNode(conf.getMaxClientNumForEachNode())
+              .setCoreClientNumForEachNode(conf.getCoreClientCountForEachNodeInClientManager())
+              .setMaxClientNumForEachNode(conf.getMaxClientCountForEachNodeInClientManager())
               .build()
               .getConfig());
     }
@@ -142,13 +142,13 @@ public class ClientPoolFactory {
               manager,
               new ThriftClientProperty.Builder()
                   .setConnectionTimeoutMs(conf.getConnectionTimeoutInMS())
-                  .setRpcThriftCompressionEnabled(conf.isRpcThriftCompressionEnabled())
-                  .setSelectorNumOfAsyncClientManager(conf.getSelectorNumOfClientManager())
+                  .setRpcThriftCompressionEnabled(conf.isRpcThriftCompressionEnable())
+                  .setSelectorNumOfAsyncClientManager(conf.getSelectorThreadCountOfClientManager())
                   .build(),
               ThreadName.ASYNC_CONFIGNODE_HEARTBEAT_CLIENT_POOL.getName()),
           new ClientPoolProperty.Builder<AsyncConfigNodeHeartbeatServiceClient>()
-              .setCoreClientNumForEachNode(conf.getCoreClientNumForEachNode())
-              .setMaxClientNumForEachNode(conf.getMaxClientNumForEachNode())
+              .setCoreClientNumForEachNode(conf.getCoreClientCountForEachNodeInClientManager())
+              .setMaxClientNumForEachNode(conf.getMaxClientCountForEachNodeInClientManager())
               .build()
               .getConfig());
     }
@@ -165,13 +165,13 @@ public class ClientPoolFactory {
               manager,
               new ThriftClientProperty.Builder()
                   .setConnectionTimeoutMs(conf.getConnectionTimeoutInMS())
-                  .setRpcThriftCompressionEnabled(conf.isRpcThriftCompressionEnabled())
-                  .setSelectorNumOfAsyncClientManager(conf.getSelectorNumOfClientManager())
+                  .setRpcThriftCompressionEnabled(conf.isRpcThriftCompressionEnable())
+                  .setSelectorNumOfAsyncClientManager(conf.getSelectorThreadCountOfClientManager())
                   .build(),
               ThreadName.ASYNC_DATANODE_HEARTBEAT_CLIENT_POOL.getName()),
           new ClientPoolProperty.Builder<AsyncDataNodeHeartbeatServiceClient>()
-              .setCoreClientNumForEachNode(conf.getCoreClientNumForEachNode())
-              .setMaxClientNumForEachNode(conf.getMaxClientNumForEachNode())
+              .setCoreClientNumForEachNode(conf.getCoreClientCountForEachNodeInClientManager())
+              .setMaxClientNumForEachNode(conf.getMaxClientCountForEachNodeInClientManager())
               .build()
               .getConfig());
     }
@@ -188,11 +188,11 @@ public class ClientPoolFactory {
               manager,
               new ThriftClientProperty.Builder()
                   .setConnectionTimeoutMs(conf.getConnectionTimeoutInMS())
-                  .setRpcThriftCompressionEnabled(conf.isRpcThriftCompressionEnabled())
+                  .setRpcThriftCompressionEnabled(conf.isRpcThriftCompressionEnable())
                   .build()),
           new ClientPoolProperty.Builder<SyncDataNodeMPPDataExchangeServiceClient>()
-              .setCoreClientNumForEachNode(conf.getCoreClientNumForEachNode())
-              .setMaxClientNumForEachNode(conf.getMaxClientNumForEachNode())
+              .setCoreClientNumForEachNode(conf.getCoreClientCountForEachNodeInClientManager())
+              .setMaxClientNumForEachNode(conf.getMaxClientCountForEachNodeInClientManager())
               .build()
               .getConfig());
     }
@@ -209,13 +209,13 @@ public class ClientPoolFactory {
               manager,
               new ThriftClientProperty.Builder()
                   .setConnectionTimeoutMs(conf.getConnectionTimeoutInMS())
-                  .setRpcThriftCompressionEnabled(conf.isRpcThriftCompressionEnabled())
-                  .setSelectorNumOfAsyncClientManager(conf.getSelectorNumOfClientManager())
+                  .setRpcThriftCompressionEnabled(conf.isRpcThriftCompressionEnable())
+                  .setSelectorNumOfAsyncClientManager(conf.getSelectorThreadCountOfClientManager())
                   .build(),
               ThreadName.ASYNC_DATANODE_MPP_DATA_EXCHANGE_CLIENT_POOL.getName()),
           new ClientPoolProperty.Builder<AsyncDataNodeMPPDataExchangeServiceClient>()
-              .setCoreClientNumForEachNode(conf.getCoreClientNumForEachNode())
-              .setMaxClientNumForEachNode(conf.getMaxClientNumForEachNode())
+              .setCoreClientNumForEachNode(conf.getCoreClientCountForEachNodeInClientManager())
+              .setMaxClientNumForEachNode(conf.getMaxClientCountForEachNodeInClientManager())
               .build()
               .getConfig());
     }
diff --git a/node-commons/src/main/java/org/apache/iotdb/commons/conf/CommonConfig.java b/node-commons/src/main/java/org/apache/iotdb/commons/conf/CommonConfig.java
index 8606e80bfd..bbbd3562ed 100644
--- a/node-commons/src/main/java/org/apache/iotdb/commons/conf/CommonConfig.java
+++ b/node-commons/src/main/java/org/apache/iotdb/commons/conf/CommonConfig.java
@@ -34,6 +34,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.File;
+import java.util.concurrent.TimeUnit;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -611,6 +612,10 @@ public class CommonConfig {
           + File.separator
           + "procedure";
 
+  // Sync directory, including the log and hardlink tsfiles
+  private String syncDir =
+      IoTDBConstant.DEFAULT_BASE_DIR + File.separator + IoTDBConstant.SYNC_FOLDER_NAME;
+
   /** Internal Configurations(Unconfigurable in .properties file) */
   // NodeStatus
   private volatile NodeStatus status = NodeStatus.Running;
@@ -623,7 +628,18 @@ public class CommonConfig {
   // Max bytes of each FragmentInstance for DataExchange
   private long maxBytesPerFragmentInstance = allocateMemoryForDataExchange / queryThreadCount;
 
-  CommonConfig() {
+  private boolean rpcThriftCompressionEnable = false;
+  private int connectionTimeoutInMS = (int) TimeUnit.SECONDS.toMillis(20);
+  // ClientManager will have so many selector threads (TAsyncClientManager) to distribute to its
+  // clients
+  private int selectorThreadCountOfClientManager =
+      Runtime.getRuntime().availableProcessors() / 4 > 0
+          ? Runtime.getRuntime().availableProcessors() / 4
+          : 1;
+  private int coreClientCountForEachNodeInClientManager = 200;
+  private int maxClientCountForEachNodeInClientManager = 300;
+
+  public CommonConfig() {
     // Empty constructor
   }
 
@@ -1518,6 +1534,14 @@ public class CommonConfig {
     this.procedureWalFolder = procedureWalFolder;
   }
 
+  public String getSyncDir() {
+    return syncDir;
+  }
+
+  public void setSyncDir(String syncDir) {
+    this.syncDir = syncDir;
+  }
+
   public FSType getSystemFileStorageFs() {
     return systemFileStorageFs;
   }
@@ -1534,6 +1558,10 @@ public class CommonConfig {
     this.handleSystemErrorStrategy = handleSystemErrorStrategy;
   }
 
+  public void handleUnrecoverableError() {
+    handleSystemErrorStrategy.handle();
+  }
+
   public boolean isEnableMemControl() {
     return enableMemControl;
   }
@@ -2498,4 +2526,46 @@ public class CommonConfig {
   public void setStatusReason(String statusReason) {
     this.statusReason = statusReason;
   }
+
+  public boolean isRpcThriftCompressionEnable() {
+    return rpcThriftCompressionEnable;
+  }
+
+  public void setRpcThriftCompressionEnable(boolean rpcThriftCompressionEnable) {
+    this.rpcThriftCompressionEnable = rpcThriftCompressionEnable;
+  }
+
+  public int getConnectionTimeoutInMS() {
+    return connectionTimeoutInMS;
+  }
+
+  public void setConnectionTimeoutInMS(int connectionTimeoutInMS) {
+    this.connectionTimeoutInMS = connectionTimeoutInMS;
+  }
+
+  public int getSelectorThreadCountOfClientManager() {
+    return selectorThreadCountOfClientManager;
+  }
+
+  public void setSelectorThreadCountOfClientManager(int selectorThreadCountOfClientManager) {
+    this.selectorThreadCountOfClientManager = selectorThreadCountOfClientManager;
+  }
+
+  public int getCoreClientCountForEachNodeInClientManager() {
+    return coreClientCountForEachNodeInClientManager;
+  }
+
+  public void setCoreClientCountForEachNodeInClientManager(
+      int coreClientCountForEachNodeInClientManager) {
+    this.coreClientCountForEachNodeInClientManager = coreClientCountForEachNodeInClientManager;
+  }
+
+  public int getMaxClientCountForEachNodeInClientManager() {
+    return maxClientCountForEachNodeInClientManager;
+  }
+
+  public void setMaxClientCountForEachNodeInClientManager(
+      int maxClientCountForEachNodeInClientManager) {
+    this.maxClientCountForEachNodeInClientManager = maxClientCountForEachNodeInClientManager;
+  }
 }
diff --git a/node-commons/src/main/java/org/apache/iotdb/commons/conf/CommonDescriptor.java b/node-commons/src/main/java/org/apache/iotdb/commons/conf/CommonDescriptor.java
index 2f99153fcc..4fae241b26 100644
--- a/node-commons/src/main/java/org/apache/iotdb/commons/conf/CommonDescriptor.java
+++ b/node-commons/src/main/java/org/apache/iotdb/commons/conf/CommonDescriptor.java
@@ -121,7 +121,7 @@ public class CommonDescriptor {
     }
   }
 
-  private void loadCommonProps(Properties properties) {
+  private void loadCommonProps(Properties properties) throws IOException {
 
     /* Cluster Configuration */
     CONF.setClusterName(
@@ -196,20 +196,14 @@ public class CommonDescriptor {
     loadInfluxDBRPCServiceConfiguration(properties);
   }
 
-  private void loadReplicationConfiguration(Properties properties) {
-    try {
-      CONF.setConfigNodeConsensusProtocolClass(
-          ConsensusProtocolClass.parse(
-              properties
-                  .getProperty(
-                      "config_node_consensus_protocol_class",
-                      CONF.getConfigNodeConsensusProtocolClass().getProtocol())
-                  .trim()));
-    } catch (IOException e) {
-      LOGGER.warn(
-          "Unknown config_node_consensus_protocol_class in iotdb-common.properties file, use default config",
-          e);
-    }
+  private void loadReplicationConfiguration(Properties properties) throws IOException {
+    CONF.setConfigNodeConsensusProtocolClass(
+        ConsensusProtocolClass.parse(
+            properties
+                .getProperty(
+                    "config_node_consensus_protocol_class",
+                    CONF.getConfigNodeConsensusProtocolClass().getProtocol())
+                .trim()));
 
     CONF.setSchemaReplicationFactor(
         Integer.parseInt(
@@ -218,19 +212,13 @@ public class CommonDescriptor {
                     "schema_replication_factor", String.valueOf(CONF.getSchemaReplicationFactor()))
                 .trim()));
 
-    try {
-      CONF.setSchemaRegionConsensusProtocolClass(
-          ConsensusProtocolClass.parse(
-              properties
-                  .getProperty(
-                      "schema_region_consensus_protocol_class",
-                      CONF.getSchemaRegionConsensusProtocolClass().getProtocol())
-                  .trim()));
-    } catch (IOException e) {
-      LOGGER.warn(
-          "Unknown schema_region_consensus_protocol_class in iotdb-common.properties file, use default config",
-          e);
-    }
+    CONF.setSchemaRegionConsensusProtocolClass(
+        ConsensusProtocolClass.parse(
+            properties
+                .getProperty(
+                    "schema_region_consensus_protocol_class",
+                    CONF.getSchemaRegionConsensusProtocolClass().getProtocol())
+                .trim()));
 
     CONF.setDataReplicationFactor(
         Integer.parseInt(
@@ -239,19 +227,13 @@ public class CommonDescriptor {
                     "data_replication_factor", String.valueOf(CONF.getDataReplicationFactor()))
                 .trim()));
 
-    try {
-      CONF.setDataRegionConsensusProtocolClass(
-          ConsensusProtocolClass.parse(
-              properties
-                  .getProperty(
-                      "data_region_consensus_protocol_class",
-                      CONF.getDataRegionConsensusProtocolClass().getProtocol())
-                  .trim()));
-    } catch (IOException e) {
-      LOGGER.warn(
-          "Unknown data_region_consensus_protocol_class in iotdb-common.properties file, use default config",
-          e);
-    }
+    CONF.setDataRegionConsensusProtocolClass(
+        ConsensusProtocolClass.parse(
+            properties
+                .getProperty(
+                    "data_region_consensus_protocol_class",
+                    CONF.getDataRegionConsensusProtocolClass().getProtocol())
+                .trim()));
   }
 
   private void loadLoadBalancingConfiguration(Properties properties) {
diff --git a/schema-engine-rocksdb/src/main/java/org/apache/iotdb/db/metadata/schemaregion/rocksdb/RSchemaConfLoader.java b/schema-engine-rocksdb/src/main/java/org/apache/iotdb/db/metadata/schemaregion/rocksdb/RSchemaConfLoader.java
index 6fede5e624..caee88cd9c 100644
--- a/schema-engine-rocksdb/src/main/java/org/apache/iotdb/db/metadata/schemaregion/rocksdb/RSchemaConfLoader.java
+++ b/schema-engine-rocksdb/src/main/java/org/apache/iotdb/db/metadata/schemaregion/rocksdb/RSchemaConfLoader.java
@@ -18,6 +18,7 @@
  */
 package org.apache.iotdb.db.metadata.schemaregion.rocksdb;
 
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.conf.IoTDBConstant;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 
@@ -46,9 +47,9 @@ public class RSchemaConfLoader {
   private long writeBufferSize = 64 * SizeUnit.KB;
   private long maxTotalWalSize = 64 * SizeUnit.KB;
   private long blockCache =
-      IoTDBDescriptor.getInstance().getConfig().getAllocateMemoryForSchemaRegion() * 2 / 3;
+      CommonDescriptor.getInstance().getConfig().getAllocateMemoryForSchemaRegion() * 2 / 3;
   private long blockCacheCompressed =
-      IoTDBDescriptor.getInstance().getConfig().getAllocateMemoryForSchemaRegion() / 3;
+    CommonDescriptor.getInstance().getConfig().getAllocateMemoryForSchemaRegion() / 3;
 
   private static final String ROCKSDB_CONFIG_FILE_NAME = "schema-rocksdb.properties";
   private static final Logger logger = LoggerFactory.getLogger(RSchemaConfLoader.class);
diff --git a/server/src/main/java/org/apache/iotdb/db/auth/BasicAuthorityCache.java b/server/src/main/java/org/apache/iotdb/db/auth/BasicAuthorityCache.java
index 49e5a7596e..c57f572299 100644
--- a/server/src/main/java/org/apache/iotdb/db/auth/BasicAuthorityCache.java
+++ b/server/src/main/java/org/apache/iotdb/db/auth/BasicAuthorityCache.java
@@ -21,6 +21,8 @@ package org.apache.iotdb.db.auth;
 
 import org.apache.iotdb.commons.auth.entity.Role;
 import org.apache.iotdb.commons.auth.entity.User;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 
 import com.github.benmanes.caffeine.cache.Cache;
@@ -34,18 +36,18 @@ import java.util.concurrent.TimeUnit;
 public class BasicAuthorityCache implements IAuthorCache {
   private static final Logger logger = LoggerFactory.getLogger(BasicAuthorityCache.class);
 
-  private IoTDBDescriptor conf = IoTDBDescriptor.getInstance();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
 
   private Cache<String, User> userCache =
       Caffeine.newBuilder()
-          .maximumSize(conf.getConfig().getAuthorCacheSize())
-          .expireAfterAccess(conf.getConfig().getAuthorCacheExpireTime(), TimeUnit.MINUTES)
+          .maximumSize(COMMON_CONFIG.getAuthorCacheSize())
+          .expireAfterAccess(COMMON_CONFIG.getAuthorCacheExpireTime(), TimeUnit.MINUTES)
           .build();
 
   private Cache<String, Role> roleCache =
       Caffeine.newBuilder()
-          .maximumSize(conf.getConfig().getAuthorCacheSize())
-          .expireAfterAccess(conf.getConfig().getAuthorCacheExpireTime(), TimeUnit.MINUTES)
+          .maximumSize(COMMON_CONFIG.getAuthorCacheSize())
+          .expireAfterAccess(COMMON_CONFIG.getAuthorCacheExpireTime(), TimeUnit.MINUTES)
           .build();
 
   @Override
diff --git a/server/src/main/java/org/apache/iotdb/db/client/ConfigNodeClient.java b/server/src/main/java/org/apache/iotdb/db/client/ConfigNodeClient.java
index 2d7b8a26ac..c7b5b30026 100644
--- a/server/src/main/java/org/apache/iotdb/db/client/ConfigNodeClient.java
+++ b/server/src/main/java/org/apache/iotdb/db/client/ConfigNodeClient.java
@@ -30,7 +30,6 @@ import org.apache.iotdb.commons.client.factory.ThriftClientFactory;
 import org.apache.iotdb.commons.client.property.ClientPoolProperty;
 import org.apache.iotdb.commons.client.property.ThriftClientProperty;
 import org.apache.iotdb.commons.client.sync.SyncThriftClientWithErrorHandler;
-import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.consensus.ConfigNodeRegionId;
 import org.apache.iotdb.confignode.rpc.thrift.IConfigNodeRPCService;
 import org.apache.iotdb.confignode.rpc.thrift.TAddConsensusGroupReq;
@@ -176,7 +175,7 @@ public class ConfigNodeClient implements IConfigNodeRPCService.Iface, ThriftClie
     // Read config nodes from configuration
     configNodes = ConfigNodeInfo.getInstance().getLatestConfigNodes();
     protocolFactory =
-        CommonDescriptor.getInstance().getConfig().isRpcThriftCompressionEnabled()
+        IoTDBDescriptor.getInstance().getConfig().isDnRpcThriftCompressionEnable()
             ? new TCompactProtocol.Factory()
             : new TBinaryProtocol.Factory();
 
diff --git a/server/src/main/java/org/apache/iotdb/db/conf/IoTDBConfig.java b/server/src/main/java/org/apache/iotdb/db/conf/IoTDBConfig.java
index c70e13c0f7..2bd00e8d04 100644
--- a/server/src/main/java/org/apache/iotdb/db/conf/IoTDBConfig.java
+++ b/server/src/main/java/org/apache/iotdb/db/conf/IoTDBConfig.java
@@ -276,22 +276,20 @@ public class IoTDBConfig {
   // Default HDFS port is 9000
   private String hdfsPort = "9000";
 
-  /* Names of Watermark methods */
-
-  /** The proportion of write memory for loading TsFile */
+  // The proportion of write memory for loading TsFile
   private final double loadTsFileProportion = 0.125;
 
-  /** Size threshold of each checkpoint file. Unit: byte */
+  // Size threshold of each checkpoint file. Unit: byte
   private volatile long checkpointFileSizeThresholdInByte = 3 * 1024 * 1024L;
 
-  /** Buffer entry size of each wal buffer. Unit: byte */
+  // Buffer entry size of each wal buffer. Unit: byte
   private int walBufferEntrySize = 16 * 1024;
 
-  /** External lib directory for ext Pipe plugins, stores user-defined JAR files */
+  // External lib directory for ext Pipe plugins, stores user-defined JAR files
   private String extPipeDir =
       IoTDBConstant.EXT_FOLDER_NAME + File.separator + IoTDBConstant.EXT_PIPE_FOLDER_NAME;
 
-  /** External lib directory for MQTT, stores user-uploaded JAR files */
+  // External lib directory for MQTT, stores user-uploaded JAR files
   private String mqttDir =
       IoTDBConstant.EXT_FOLDER_NAME + File.separator + IoTDBConstant.MQTT_FOLDER_NAME;
 
@@ -309,163 +307,136 @@ public class IoTDBConfig {
 
   private String schemaRegionConsensusDir = dnConsensusDir + File.separator + "schema_region";
 
-  /** Maximum MemTable number. Invalid when enableMemControl is true. */
+  // Maximum MemTable number. Invalid when enableMemControl is true
   private int maxMemtableNumber = 0;
 
-  /** How many threads can concurrently evaluate windows. When <= 0, use CPU core number. */
+  // How many threads can concurrently evaluate windows. When <= 0, use CPU core number
   private int windowEvaluationThreadCount = Runtime.getRuntime().availableProcessors();
 
-  /**
-   * Max number of window evaluation tasks that can be pending for execution. When <= 0, the value
-   * is 64 by default.
-   */
+  // Max number of window evaluation tasks that can be pending for execution. When <= 0, the value is 64 by default
   private int maxPendingWindowEvaluationTasks = 64;
 
-  /** When a unSequence TsFile's file size (in byte) exceed this, the TsFile is forced closed. */
+  // When a unSequence TsFile's file size (in byte) exceed this, the TsFile is forced closed
   private long unSeqTsFileSize = 0L;
 
-  /** When a sequence TsFile's file size (in byte) exceed this, the TsFile is forced closed. */
+  // When a sequence TsFile's file size (in byte) exceed this, the TsFile is forced closed
   private long seqTsFileSize = 0L;
 
-  /** Set true to enable statistics monitor service, false to disable statistics service. */
-  private boolean enableStatMonitor = false;
-
-  /** Set true to enable writing monitor time series. */
-  private boolean enableMonitorSeriesWrite = false;
-
-  /** Examining period of cache file reader : 100 seconds. Unit: millisecond */
+  // Examining period of cache file reader : 100 seconds. Unit: millisecond
   private long cacheFileReaderClearPeriod = 100000;
 
-  /** Replace implementation class of JDBC service */
+  // Replace implementation class of JDBC service
   private String rpcImplClassName = ClientRPCServiceImpl.class.getName();
 
-  /** indicate whether current mode is cluster */
+  // indicate whether current mode is cluster
   private boolean isClusterMode = false;
 
-  /**
-   * The cluster name that this DataNode joined in the cluster mode. The default value
-   * "defaultCluster" will be changed after join cluster
-   */
+  // The cluster name that this DataNode joined in the cluster mode. The default value "defaultCluster" will be changed after join cluster
   private String clusterName = "defaultCluster";
 
-  /**
-   * The DataNodeId of this DataNode for cluster mode. The default value -1 will be changed after
-   * join cluster
-   */
+  // The DataNodeId of this DataNode for cluster mode. The default value -1 will be changed after join cluster
   private int dataNodeId = -1;
 
-  /** Replace implementation class of influxdb protocol service */
-  private String influxdbImplClassName = NewInfluxDBServiceImpl.class.getName();
+  // Replace implementation class of influxdb protocol service
+  private final String influxdbImplClassName = NewInfluxDBServiceImpl.class.getName();
 
-  /** How many threads will be set up to perform settle tasks. */
+  // How many threads will be set up to perform settle tasks
   private int settleThreadNum = 1;
 
-  /** The limit of compaction merge can reach per second */
+  // The limit of compaction merge can reach per second
   private int compactionWriteThroughputMbPerSec = 16;
 
-  /**
-   * How many thread will be set up to perform compaction, 10 by default. Set to 1 when less than or
-   * equal to 0.
-   */
+  // How many thread will be set up to perform compaction, 10 by default. Set to 1 when less than or equal to 0
   private int compactionThreadCount = 10;
 
-  /** Default DFS NameServices is hdfsnamespace */
+  // Default DFS NameServices is hdfsnamespace
   private String dfsNameServices = "hdfsnamespace";
 
-  /** Default DFS HA name nodes are nn1 and nn2 */
+  // Default DFS HA name nodes are nn1 and nn2
   private String dfsHaNamenodes = "nn1,nn2";
 
-  /** Default DFS HA automatic failover is enabled */
+  // Default DFS HA automatic failover is enabled
   private boolean dfsHaAutomaticFailoverEnabled = true;
 
-  /**
-   * Default DFS client failover proxy provider is
-   * "org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider"
-   */
+  // Default DFS client failover proxy provider is "org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider"
   private String dfsClientFailoverProxyProvider =
       "org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider";
 
-  /** whether use kerberos to authenticate hdfs */
+  // Whether use kerberos to authenticate hdfs
   private boolean useKerberos = false;
 
-  /** full path of kerberos keytab file */
+  // full path of kerberos keytab file
   private String kerberosKeytabFilePath = "/path";
 
-  /** kerberos principal */
+  // kerberos principal
   private String kerberosPrincipal = "your principal";
 
-  /** Time partition interval in milliseconds */
+  // Time partition interval in milliseconds
   private long dnTimePartitionInterval = 604_800_000;
 
-  /**
-   * Level of TimeIndex, which records the start time and end time of TsFileResource. Currently,
-   * DEVICE_TIME_INDEX and FILE_TIME_INDEX are supported, and could not be changed after first set.
-   */
+  // Level of TimeIndex, which records the start time and end time of TsFileResource. Currently,
+  // DEVICE_TIME_INDEX and FILE_TIME_INDEX are supported, and could not be changed after first set
   private TimeIndexLevel timeIndexLevel = TimeIndexLevel.DEVICE_TIME_INDEX;
 
-  // just for test
-  // wait for 60 second by default.
+  // Just for test wait for 60 second by default.
   private int thriftServerAwaitTimeForStopService = 60;
 
-  /** The cached record size (in MB) of each series in group by fill query */
+  // The cached record size (in MB) of each series in group by fill query
   private float groupByFillCacheSizeInMB = (float) 1.0;
 
   // time in nanosecond precision when starting up
-  private long startUpNanosecond = System.nanoTime();
+  private final long startUpNanosecond = System.nanoTime();
 
-  /**
-   * whether enable the rpc service. This parameter has no a corresponding field in the
-   * iotdb-common.properties
-   */
+  // Whether enable the rpc service. This parameter has no a corresponding field in the iotdb-common.properties
   private boolean enableRpcService = true;
 
-  /** the method to transform device path to device id, can be 'Plain' or 'SHA256' */
+  // The method to transform device path to device id, can be 'Plain' or 'SHA256'
   private String deviceIDTransformationMethod = "Plain";
 
-  /** whether to use id table. ATTENTION: id table is not compatible with alias */
+  // Whether to use id table. ATTENTION: id table is not compatible with alias
   private boolean enableIDTable = false;
 
-  /**
-   * whether create mapping file of id table. This file can map device id in tsfile to device path
-   */
+  // Whether create mapping file of id table. This file can map device id in tsfile to device path
   private boolean enableIDTableLogFile = false;
 
-  /** whether to use persistent schema mode */
+  // Whether to use persistent schema mode
   private String schemaEngineMode = "Memory";
 
-  /** the memory used for metadata cache when using persistent schema */
+  // The memory used for metadata cache when using persistent schema
   private int cachedMNodeSizeInSchemaFileMode = -1;
 
-  /** the minimum size (in bytes) of segment inside a schema file page */
+  // The minimum size (in bytes) of segment inside a schema file page
   private short minimumSegmentInSchemaFile = 0;
 
-  /** cache size for pages in one schema file */
+  // Cache size for pages in one schema file
   private int pageCacheSizeInSchemaFile = 1024;
 
-  /** maximum number of logged pages before log erased */
+  // Maximum number of logged pages before log erased
   private int schemaFileLogSize = 16384;
 
   /** CQ related */
   private long cqMinEveryIntervalInMs = 1_000;
 
-  /** whether to enable the audit log * */
+  // Whether to enable the audit log
   private boolean enableAuditLog = false;
 
-  /** Output location of audit logs * */
+  // Output location of audit logs
   private List<AuditLogStorage> auditLogStorage =
       Arrays.asList(AuditLogStorage.IOTDB, AuditLogStorage.LOGGER);
 
-  /** Indicates the category collection of audit logs * */
+  // Indicates the category collection of audit logs
   private List<AuditLogOperation> auditLogOperation =
       Arrays.asList(AuditLogOperation.DML, AuditLogOperation.DDL, AuditLogOperation.QUERY);
 
-  /** whether the local write api records audit logs * */
+  // whether the local write api records audit logs
   private boolean enableAuditLogForNativeInsertApi = true;
 
   // customizedProperties, this should be empty by default.
   private Properties customizedProperties = new Properties();
 
-  IoTDBConfig() {}
+  IoTDBConfig() {
+    // Empty constructor
+  }
 
   public float getGroupByFillCacheSizeInMB() {
     return groupByFillCacheSizeInMB;
diff --git a/server/src/main/java/org/apache/iotdb/db/conf/IoTDBDescriptor.java b/server/src/main/java/org/apache/iotdb/db/conf/IoTDBDescriptor.java
index bc56a6a739..7516d9e7bd 100644
--- a/server/src/main/java/org/apache/iotdb/db/conf/IoTDBDescriptor.java
+++ b/server/src/main/java/org/apache/iotdb/db/conf/IoTDBDescriptor.java
@@ -62,7 +62,7 @@ import java.util.ServiceLoader;
 
 public class IoTDBDescriptor {
 
-  private static final Logger logger = LoggerFactory.getLogger(IoTDBDescriptor.class);
+  private static final Logger LOGGER = LoggerFactory.getLogger(IoTDBDescriptor.class);
   private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
 
   private final IoTDBConfig CONF = new IoTDBConfig();
@@ -72,7 +72,7 @@ public class IoTDBDescriptor {
     ServiceLoader<IPropertiesLoader> propertiesLoaderServiceLoader =
         ServiceLoader.load(IPropertiesLoader.class);
     for (IPropertiesLoader loader : propertiesLoaderServiceLoader) {
-      logger.info("Will reload properties from {} ", loader.getClass().getName());
+      LOGGER.info("Will reload properties from {} ", loader.getClass().getName());
       Properties properties = loader.loadProperties();
       loadProperties(properties);
       CONF.setCustomizedProperties(loader.getCustomizedProperties());
@@ -116,7 +116,7 @@ public class IoTDBDescriptor {
     if (uri != null) {
       return uri;
     }
-    logger.warn(
+    LOGGER.warn(
         "Cannot find IOTDB_HOME, IOTDB_CONF, CONFIGNODE_HOME and CONFIGNODE_CONF environment variable when loading "
             + "config file {}, use default configuration",
         CommonConfig.CONF_FILE_NAME);
@@ -130,44 +130,47 @@ public class IoTDBDescriptor {
     Properties commonProperties = new Properties();
     if (url != null) {
       try (InputStream inputStream = url.openStream()) {
-        logger.info("Start to read config file {}", url);
+        LOGGER.info("Start to read config file {}", url);
         commonProperties.load(inputStream);
       } catch (FileNotFoundException e) {
-        logger.warn("Fail to find config file {}", url, e);
+        LOGGER.warn("Fail to find config file {}", url, e);
       } catch (IOException e) {
-        logger.warn("Cannot load config file, use default configuration", e);
+        LOGGER.warn("Cannot load config file, use default configuration", e);
       } catch (Exception e) {
-        logger.warn("Incorrect format in config file, use default configuration", e);
+        LOGGER.warn("Incorrect format in config file, use default configuration", e);
       }
     } else {
-      logger.warn(
+      LOGGER.warn(
           "Couldn't load the configuration {} from any of the known sources.",
           CommonConfig.CONF_FILE_NAME);
     }
     url = getPropsUrl(IoTDBConfig.CONFIG_NAME);
     if (url != null) {
       try (InputStream inputStream = url.openStream()) {
-        logger.info("Start to read config file {}", url);
+        LOGGER.info("Start to read config file {}", url);
         Properties properties = new Properties();
         properties.load(inputStream);
         commonProperties.putAll(properties);
         loadProperties(commonProperties);
       } catch (FileNotFoundException e) {
-        logger.warn("Fail to find config file {}", url, e);
+        LOGGER.warn("Fail to find config file {}", url, e);
       } catch (IOException e) {
-        logger.warn("Cannot load config file, use default configuration", e);
+        LOGGER.warn("Cannot load config file, use default configuration", e);
       } catch (Exception e) {
-        logger.warn("Incorrect format in config file, use default configuration", e);
+        LOGGER.warn("Incorrect format in config file, use default configuration", e);
       } finally {
         // update all data seriesPath
         CONF.updatePath();
+
+        CommonDescriptor.getInstance().initCommonConfigDir(CONF.getDnSystemDir());
+
         MetricConfigDescriptor.getInstance().loadProps(commonProperties);
         MetricConfigDescriptor.getInstance()
             .getMetricConfig()
             .updateRpcInstance(CONF.getDnInternalAddress(), CONF.getDnInternalPort());
       }
     } else {
-      logger.warn(
+      LOGGER.warn(
           "Couldn't load the configuration {} from any of the known sources.",
           IoTDBConfig.CONFIG_NAME);
     }
@@ -250,7 +253,7 @@ public class IoTDBDescriptor {
       try {
         CONF.setDnTargetConfigNodeList(NodeUrlUtils.parseTEndPointUrls(configNodeUrls));
       } catch (BadNodeUrlException e) {
-        logger.error(
+        LOGGER.error(
             "ConfigNodes are set in wrong format, please set them like 127.0.0.1:10710,127.0.0.1:10712");
       }
     }
@@ -270,6 +273,7 @@ public class IoTDBDescriptor {
                     "dn_rpc_thrift_compression_enable",
                     Boolean.toString(CONF.isDnRpcThriftCompressionEnable()))
                 .trim()));
+    COMMON_CONFIG.setRpcThriftCompressionEnable(CONF.isDnRpcThriftCompressionEnable());
 
     CONF.setDnRpcAdvancedCompressionEnable(
         Boolean.parseBoolean(
@@ -325,6 +329,7 @@ public class IoTDBDescriptor {
                 .getProperty(
                     "dn_connection_timeout_ms", String.valueOf(CONF.getDnConnectionTimeoutInMS()))
                 .trim()));
+    COMMON_CONFIG.setConnectionTimeoutInMS(CONF.getDnConnectionTimeoutInMS());
 
     CONF.setDnSelectorThreadCountOfClientManager(
         Integer.parseInt(
@@ -333,6 +338,8 @@ public class IoTDBDescriptor {
                     "dn_selector_thread_count_of_client_manager",
                     String.valueOf(CONF.getDnSelectorThreadCountOfClientManager()))
                 .trim()));
+    COMMON_CONFIG.setSelectorThreadCountOfClientManager(
+        CONF.getDnSelectorThreadCountOfClientManager());
 
     CONF.setDnCoreClientCountForEachNodeInClientManager(
         Integer.parseInt(
@@ -341,6 +348,8 @@ public class IoTDBDescriptor {
                     "dn_core_client_count_for_each_node_in_client_manager",
                     String.valueOf(CONF.getDnCoreClientCountForEachNodeInClientManager()))
                 .trim()));
+    COMMON_CONFIG.setCoreClientCountForEachNodeInClientManager(
+        CONF.getDnCoreClientCountForEachNodeInClientManager());
 
     CONF.setDnMaxClientCountForEachNodeInClientManager(
         Integer.parseInt(
@@ -349,6 +358,8 @@ public class IoTDBDescriptor {
                     "dn_max_client_count_for_each_node_in_client_manager",
                     String.valueOf(CONF.getDnMaxClientCountForEachNodeInClientManager()))
                 .trim()));
+    COMMON_CONFIG.setMaxClientCountForEachNodeInClientManager(
+        CONF.getDnMaxClientCountForEachNodeInClientManager());
   }
 
   private void loadDirectoryConfiguration(Properties properties) {
@@ -392,6 +403,7 @@ public class IoTDBDescriptor {
     CONF.setDnTracingDir(properties.getProperty("dn_tracing_dir", CONF.getDnTracingDir()));
 
     CONF.setDnSyncDir(properties.getProperty("dn_sync_dir", CONF.getDnSyncDir()).trim());
+    COMMON_CONFIG.setSyncDir(CONF.getDnSyncDir());
   }
 
   private void loadCompactionConfigurations(Properties properties) {
@@ -709,21 +721,21 @@ public class IoTDBDescriptor {
     Properties properties = new Properties();
 
     if (url == null) {
-      logger.warn("Couldn't load the configuration from any of the known sources.");
+      LOGGER.warn("Couldn't load the configuration from any of the known sources.");
       return;
     }
     try (InputStream inputStream = url.openStream()) {
-      logger.info("Start to reload config file {}", url);
+      LOGGER.info("Start to reload config file {}", url);
       properties.load(inputStream);
       loadHotModifiedProps(properties);
     } catch (Exception e) {
-      logger.warn("Fail to reload config file {}", url, e);
+      LOGGER.warn("Fail to reload config file {}", url, e);
       throw new QueryProcessException(
           String.format("Fail to reload config file %s because %s", url, e.getMessage()));
     }
 
     ReloadLevel reloadLevel = MetricConfigDescriptor.getInstance().loadHotProps(properties);
-    logger.info("Reload metric service in level {}", reloadLevel);
+    LOGGER.info("Reload metric service in level {}", reloadLevel);
     if (reloadLevel == ReloadLevel.RESTART_INTERNAL_REPORTER) {
       IoTDBInternalReporter internalReporter;
       if (MetricConfigDescriptor.getInstance().getMetricConfig().getInternalReportType()
diff --git a/server/src/main/java/org/apache/iotdb/db/conf/IoTDBStartCheck.java b/server/src/main/java/org/apache/iotdb/db/conf/IoTDBStartCheck.java
index be73577905..05d5860f98 100644
--- a/server/src/main/java/org/apache/iotdb/db/conf/IoTDBStartCheck.java
+++ b/server/src/main/java/org/apache/iotdb/db/conf/IoTDBStartCheck.java
@@ -22,6 +22,7 @@ import org.apache.iotdb.common.rpc.thrift.TConsensusGroupType;
 import org.apache.iotdb.commons.conf.CommonConfig;
 import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.conf.IoTDBConstant;
+import org.apache.iotdb.commons.consensus.ConsensusProtocolClass;
 import org.apache.iotdb.commons.exception.ConfigurationException;
 import org.apache.iotdb.commons.file.SystemFileFactory;
 import org.apache.iotdb.commons.wal.WALMode;
@@ -52,13 +53,13 @@ public class IoTDBStartCheck {
 
   private static final Logger logger = LoggerFactory.getLogger(IoTDBStartCheck.class);
 
-  private static final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
-  private static final CommonConfig commonConfig = CommonDescriptor.getInstance().getConfig();
+  private static final IoTDBConfig IOTDB_CONFIG = IoTDBDescriptor.getInstance().getConfig();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
 
   // this file is located in data/system/schema/system.properties
   // If user delete folder "data", system.properties can reset.
   public static final String PROPERTIES_FILE_NAME = "system.properties";
-  private static final String SCHEMA_DIR = config.getSchemaDir();
+  private static final String SCHEMA_DIR = IOTDB_CONFIG.getSchemaDir();
 
   private boolean isFirstStart = false;
 
@@ -86,24 +87,23 @@ public class IoTDBStartCheck {
   private static final Map<String, Supplier<String>> constantParamValueTable = new HashMap<>();
 
   static {
-    constantParamValueTable.put(TIMESTAMP_PRECISION_STRING, config::getTimestampPrecision);
+    constantParamValueTable.put(TIMESTAMP_PRECISION_STRING, COMMON_CONFIG::getTimestampPrecision);
     constantParamValueTable.put(
-        PARTITION_INTERVAL_STRING, () -> String.valueOf(config.getDnTimePartitionInterval()));
+        PARTITION_INTERVAL_STRING, () -> String.valueOf(IOTDB_CONFIG.getDnTimePartitionInterval()));
     constantParamValueTable.put(
-        TSFILE_FILE_SYSTEM_STRING, () -> config.getTsFileStorageFs().toString());
+        TSFILE_FILE_SYSTEM_STRING, () -> IOTDB_CONFIG.getTsFileStorageFs().toString());
     constantParamValueTable.put(
-        TAG_ATTRIBUTE_SIZE_STRING, () -> String.valueOf(config.getTagAttributeTotalSize()));
+        TAG_ATTRIBUTE_SIZE_STRING, () -> String.valueOf(COMMON_CONFIG.getTagAttributeTotalSize()));
     constantParamValueTable.put(
-        TAG_ATTRIBUTE_FLUSH_INTERVAL, () -> String.valueOf(config.getTagAttributeFlushInterval()));
+        TAG_ATTRIBUTE_FLUSH_INTERVAL, () -> String.valueOf(COMMON_CONFIG.getTagAttributeFlushInterval()));
     constantParamValueTable.put(
         MAX_DEGREE_OF_INDEX_STRING,
         () -> String.valueOf(TSFileDescriptor.getInstance().getConfig().getMaxDegreeOfIndexNode()));
-    constantParamValueTable.put(DATA_REGION_NUM, () -> String.valueOf(config.getDataRegionNum()));
-    constantParamValueTable.put(ENABLE_ID_TABLE, () -> String.valueOf(config.isEnableIDTable()));
+    constantParamValueTable.put(ENABLE_ID_TABLE, () -> String.valueOf(IOTDB_CONFIG.isEnableIDTable()));
     constantParamValueTable.put(
-        ENABLE_ID_TABLE_LOG_FILE, () -> String.valueOf(config.isEnableIDTableLogFile()));
+        ENABLE_ID_TABLE_LOG_FILE, () -> String.valueOf(IOTDB_CONFIG.isEnableIDTableLogFile()));
     constantParamValueTable.put(
-        SCHEMA_ENGINE_MODE, () -> String.valueOf(config.getSchemaEngineMode()));
+        SCHEMA_ENGINE_MODE, () -> String.valueOf(IOTDB_CONFIG.getSchemaEngineMode()));
     constantParamValueTable.put(
         TIME_ENCODER_KEY, TSFileDescriptor.getInstance().getConfig()::getTimeEncoder);
   }
@@ -120,17 +120,17 @@ public class IoTDBStartCheck {
 
   static {
     variableParamValueTable.put(
-        INTERNAL_ADDRESS, () -> String.valueOf(config.getDnInternalAddress()));
-    variableParamValueTable.put(INTERNAL_PORT, () -> String.valueOf(config.getDnInternalPort()));
-    variableParamValueTable.put(RPC_ADDRESS, () -> String.valueOf(config.getDnRpcAddress()));
-    variableParamValueTable.put(RPC_PORT, () -> String.valueOf(config.getDnRpcPort()));
+        INTERNAL_ADDRESS, () -> String.valueOf(IOTDB_CONFIG.getDnInternalAddress()));
+    variableParamValueTable.put(INTERNAL_PORT, () -> String.valueOf(IOTDB_CONFIG.getDnInternalPort()));
+    variableParamValueTable.put(RPC_ADDRESS, () -> String.valueOf(IOTDB_CONFIG.getDnRpcAddress()));
+    variableParamValueTable.put(RPC_PORT, () -> String.valueOf(IOTDB_CONFIG.getDnRpcPort()));
     variableParamValueTable.put(
-        MPP_DATA_EXCHANGE_PORT, () -> String.valueOf(config.getDnMppDataExchangePort()));
+        MPP_DATA_EXCHANGE_PORT, () -> String.valueOf(IOTDB_CONFIG.getDnMppDataExchangePort()));
     variableParamValueTable.put(
         SCHEMA_REGION_CONSENSUS_PORT,
-        () -> String.valueOf(config.getDnSchemaRegionConsensusPort()));
+        () -> String.valueOf(IOTDB_CONFIG.getDnSchemaRegionConsensusPort()));
     variableParamValueTable.put(
-        DATA_REGION_CONSENSUS_PORT, () -> String.valueOf(config.getDnDataRegionConsensusPort()));
+        DATA_REGION_CONSENSUS_PORT, () -> String.valueOf(IOTDB_CONFIG.getDnDataRegionConsensusPort()));
   }
   // endregion
   // region params don't need checking, determined by the system
@@ -255,31 +255,31 @@ public class IoTDBStartCheck {
    */
   public void checkDirectory() throws ConfigurationException, IOException {
     // check data dirs
-    for (String dataDir : config.getDnDataDirs()) {
+    for (String dataDir : IOTDB_CONFIG.getDnDataDirs()) {
       DirectoryChecker.getInstance().registerDirectory(new File(dataDir));
     }
-    if (config.isClusterMode()
-        && config.getDataRegionConsensusProtocolClass().equals(ConsensusFactory.RATIS_CONSENSUS)) {
-      if (DirectoryChecker.getInstance().isCrossDisk(config.getDnDataDirs())) {
+    if (IOTDB_CONFIG.isClusterMode()
+        && COMMON_CONFIG.getDataRegionConsensusProtocolClass().getProtocol().equals(ConsensusFactory.RATIS_CONSENSUS)) {
+      if (DirectoryChecker.getInstance().isCrossDisk(IOTDB_CONFIG.getDnDataDirs())) {
         throw new ConfigurationException(
             "Configuring the data directories as cross-disk directories is not supported under RatisConsensus(it will be supported in a later version).");
       }
     }
     // check system dir
-    DirectoryChecker.getInstance().registerDirectory(new File(config.getDnSystemDir()));
+    DirectoryChecker.getInstance().registerDirectory(new File(IOTDB_CONFIG.getDnSystemDir()));
     // check WAL dir
-    if (!(config.isClusterMode()
-            && config
-                .getDataRegionConsensusProtocolClass()
+    if (!(IOTDB_CONFIG.isClusterMode()
+            && COMMON_CONFIG
+                .getDataRegionConsensusProtocolClass().getProtocol()
                 .equals(ConsensusFactory.RATIS_CONSENSUS))
-        && !config.getWalMode().equals(WALMode.DISABLE)) {
-      for (String walDir : commonConfig.getWalDirs()) {
+        && !COMMON_CONFIG.getWalMode().equals(WALMode.DISABLE)) {
+      for (String walDir : IOTDB_CONFIG.getDnWalDirs()) {
         DirectoryChecker.getInstance().registerDirectory(new File(walDir));
       }
     }
     // in cluster mode, check consensus dir
-    if (config.isClusterMode()) {
-      DirectoryChecker.getInstance().registerDirectory(new File(config.getDnConsensusDir()));
+    if (IOTDB_CONFIG.isClusterMode()) {
+      DirectoryChecker.getInstance().registerDirectory(new File(IOTDB_CONFIG.getDnConsensusDir()));
     }
   }
 
@@ -305,9 +305,9 @@ public class IoTDBStartCheck {
         systemProperties.forEach((k, v) -> properties.setProperty(k, v.get()));
         properties.store(outputStream, SYSTEM_PROPERTIES_STRING);
       }
-      if (config.isClusterMode()
-          && config.getDataRegionConsensusProtocolClass().equals(ConsensusFactory.IOT_CONSENSUS)
-          && config.getWalMode().equals(WALMode.DISABLE)) {
+      if (IOTDB_CONFIG.isClusterMode()
+          && COMMON_CONFIG.getDataRegionConsensusProtocolClass().getProtocol().equals(ConsensusFactory.IOT_CONSENSUS)
+          && COMMON_CONFIG.getWalMode().equals(WALMode.DISABLE)) {
         throw new ConfigurationException(
             "Configuring the WALMode as disable is not supported under IoTConsensus");
       }
@@ -333,7 +333,7 @@ public class IoTDBStartCheck {
   }
 
   private void checkWALNotExists() {
-    for (String walDir : commonConfig.getWalDirs()) {
+    for (String walDir : IOTDB_CONFIG.getDnWalDirs()) {
       if (SystemFileFactory.INSTANCE.getFile(walDir).isDirectory()) {
         File[] sgWALs = SystemFileFactory.INSTANCE.getFile(walDir).listFiles();
         if (sgWALs != null) {
@@ -429,20 +429,20 @@ public class IoTDBStartCheck {
 
     // load configuration from system properties only when start as Data node
     if (properties.containsKey(IoTDBConstant.CLUSTER_NAME)) {
-      config.setClusterName(properties.getProperty(IoTDBConstant.CLUSTER_NAME));
+      IOTDB_CONFIG.setClusterName(properties.getProperty(IoTDBConstant.CLUSTER_NAME));
     }
     if (properties.containsKey(DATA_NODE_ID)) {
-      config.setDataNodeId(Integer.parseInt(properties.getProperty(DATA_NODE_ID)));
+      IOTDB_CONFIG.setDataNodeId(Integer.parseInt(properties.getProperty(DATA_NODE_ID)));
     }
 
     if (properties.containsKey(SCHEMA_REGION_CONSENSUS_PROTOCOL)) {
-      config.setSchemaRegionConsensusProtocolClass(
-          properties.getProperty(SCHEMA_REGION_CONSENSUS_PROTOCOL));
+      COMMON_CONFIG.setSchemaRegionConsensusProtocolClass(ConsensusProtocolClass.parse(
+          properties.getProperty(SCHEMA_REGION_CONSENSUS_PROTOCOL)));
     }
 
     if (properties.containsKey(DATA_REGION_CONSENSUS_PROTOCOL)) {
-      config.setDataRegionConsensusProtocolClass(
-          properties.getProperty(DATA_REGION_CONSENSUS_PROTOCOL));
+      COMMON_CONFIG.setDataRegionConsensusProtocolClass(ConsensusProtocolClass.parse(
+          properties.getProperty(DATA_REGION_CONSENSUS_PROTOCOL)));
     }
   }
 
diff --git a/server/src/main/java/org/apache/iotdb/db/consensus/DataRegionConsensusImpl.java b/server/src/main/java/org/apache/iotdb/db/consensus/DataRegionConsensusImpl.java
index 535ffc1960..1f5c1d42cd 100644
--- a/server/src/main/java/org/apache/iotdb/db/consensus/DataRegionConsensusImpl.java
+++ b/server/src/main/java/org/apache/iotdb/db/consensus/DataRegionConsensusImpl.java
@@ -20,6 +20,8 @@
 package org.apache.iotdb.db.consensus;
 
 import org.apache.iotdb.common.rpc.thrift.TEndPoint;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.consensus.DataRegionId;
 import org.apache.iotdb.consensus.ConsensusFactory;
 import org.apache.iotdb.consensus.IConsensus;
@@ -44,7 +46,8 @@ import java.util.concurrent.TimeUnit;
  */
 public class DataRegionConsensusImpl {
 
-  private static final IoTDBConfig conf = IoTDBDescriptor.getInstance().getConfig();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
+  private static final IoTDBConfig IOTDB_CONFIG = IoTDBDescriptor.getInstance().getConfig();
 
   private static IConsensus INSTANCE = null;
 
@@ -59,39 +62,39 @@ public class DataRegionConsensusImpl {
     if (INSTANCE == null) {
       INSTANCE =
           ConsensusFactory.getConsensusImpl(
-                  conf.getDataRegionConsensusProtocolClass(),
+              COMMON_CONFIG.getDataRegionConsensusProtocolClass().getProtocol(),
                   ConsensusConfig.newBuilder()
-                      .setThisNodeId(conf.getDataNodeId())
+                      .setThisNodeId(IOTDB_CONFIG.getDataNodeId())
                       .setThisNode(
                           new TEndPoint(
-                              conf.getDnInternalAddress(), conf.getDnDataRegionConsensusPort()))
-                      .setStorageDir(conf.getDataRegionConsensusDir())
+                              IOTDB_CONFIG.getDnInternalAddress(), IOTDB_CONFIG.getDnDataRegionConsensusPort()))
+                      .setStorageDir(IOTDB_CONFIG.getDataRegionConsensusDir())
                       .setIoTConsensusConfig(
                           IoTConsensusConfig.newBuilder()
                               .setRpc(
                                   RPC.newBuilder()
-                                      .setConnectionTimeoutInMs(conf.getDnConnectionTimeoutInMS())
-                                      .setRpcSelectorThreadNum(conf.getDnRpcSelectorThreadCount())
+                                      .setConnectionTimeoutInMs(IOTDB_CONFIG.getDnConnectionTimeoutInMS())
+                                      .setRpcSelectorThreadNum(IOTDB_CONFIG.getDnRpcSelectorThreadCount())
                                       .setRpcMinConcurrentClientNum(
-                                          conf.getDnRpcMinConcurrentClientNum())
+                                          IOTDB_CONFIG.getDnRpcMinConcurrentClientNum())
                                       .setRpcMaxConcurrentClientNum(
-                                          conf.getDnRpcMaxConcurrentClientNum())
+                                          IOTDB_CONFIG.getDnRpcMaxConcurrentClientNum())
                                       .setRpcThriftCompressionEnabled(
-                                          conf.isDnRpcThriftCompressionEnable())
+                                          IOTDB_CONFIG.isDnRpcThriftCompressionEnable())
                                       .setSelectorNumOfClientManager(
-                                          conf.getDnSelectorThreadCountOfClientManager())
+                                          IOTDB_CONFIG.getDnSelectorThreadCountOfClientManager())
                                       .setThriftServerAwaitTimeForStopService(
-                                          conf.getThriftServerAwaitTimeForStopService())
-                                      .setThriftMaxFrameSize(conf.getThriftMaxFrameSize())
+                                          IOTDB_CONFIG.getThriftServerAwaitTimeForStopService())
+                                      .setThriftMaxFrameSize(IOTDB_CONFIG.getDnThriftMaxFrameSize())
                                       .setCoreClientNumForEachNode(
-                                          conf.getCoreClientNumForEachNode())
-                                      .setMaxClientNumForEachNode(conf.getMaxClientNumForEachNode())
+                                          IOTDB_CONFIG.getDnCoreClientCountForEachNodeInClientManager())
+                                      .setMaxClientNumForEachNode(IOTDB_CONFIG.getDnMaxClientCountForEachNodeInClientManager())
                                       .build())
                               .setReplication(
                                   IoTConsensusConfig.Replication.newBuilder()
-                                      .setWalThrottleThreshold(conf.getThrottleThreshold())
+                                      .setWalThrottleThreshold(COMMON_CONFIG.getIotConsensusThrottleThresholdInByte())
                                       .setAllocateMemoryForConsensus(
-                                          conf.getAllocateMemoryForConsensus())
+                                        COMMON_CONFIG.getAllocateMemoryForConsensus())
                                       .build())
                               .build())
                       .setRatisConfig(
@@ -103,71 +106,71 @@ public class DataRegionConsensusImpl {
                                   Snapshot.newBuilder()
                                       .setCreationGap(1)
                                       .setAutoTriggerThreshold(
-                                          conf.getDataRatisConsensusSnapshotTriggerThreshold())
+                                        COMMON_CONFIG.getDataRegionRatisSnapshotTriggerThreshold())
                                       .build())
                               .setLog(
                                   RatisConfig.Log.newBuilder()
                                       .setUnsafeFlushEnabled(
-                                          conf.isDataRatisConsensusLogUnsafeFlushEnable())
+                                        COMMON_CONFIG.isDataRegionRatisLogUnsafeFlushEnable())
                                       .setSegmentSizeMax(
                                           SizeInBytes.valueOf(
-                                              conf.getDataRatisConsensusLogSegmentSizeMax()))
+                                            COMMON_CONFIG.getDataRegionRatisLogSegmentSizeMax()))
                                       .setPreserveNumsWhenPurge(
-                                          conf.getDataRatisConsensusPreserveWhenPurge())
+                                        COMMON_CONFIG.getDataRegionRatisPreserveLogsWhenPurge())
                                       .build())
                               .setGrpc(
                                   RatisConfig.Grpc.newBuilder()
                                       .setFlowControlWindow(
                                           SizeInBytes.valueOf(
-                                              conf.getDataRatisConsensusGrpcFlowControlWindow()))
+                                            COMMON_CONFIG.getDataRegionRatisGrpcFlowControlWindow()))
                                       .build())
                               .setRpc(
                                   RatisConfig.Rpc.newBuilder()
                                       .setTimeoutMin(
                                           TimeDuration.valueOf(
-                                              conf
-                                                  .getDataRatisConsensusLeaderElectionTimeoutMinMs(),
+                                            COMMON_CONFIG
+                                                  .getDataRegionRatisRpcLeaderElectionTimeoutMinMs(),
                                               TimeUnit.MILLISECONDS))
                                       .setTimeoutMax(
                                           TimeDuration.valueOf(
-                                              conf
-                                                  .getDataRatisConsensusLeaderElectionTimeoutMaxMs(),
+                                            COMMON_CONFIG
+                                                  .getDataRegionRatisRpcLeaderElectionTimeoutMaxMs(),
                                               TimeUnit.MILLISECONDS))
                                       .setRequestTimeout(
                                           TimeDuration.valueOf(
-                                              conf.getDataRatisConsensusRequestTimeoutMs(),
+                                            COMMON_CONFIG.getDataRegionRatisRequestTimeoutMs(),
                                               TimeUnit.MILLISECONDS))
                                       .setFirstElectionTimeoutMin(
                                           TimeDuration.valueOf(
-                                              conf.getRatisFirstElectionTimeoutMinMs(),
+                                            COMMON_CONFIG.getRatisFirstElectionTimeoutMinMs(),
                                               TimeUnit.MILLISECONDS))
                                       .setFirstElectionTimeoutMax(
                                           TimeDuration.valueOf(
-                                              conf.getRatisFirstElectionTimeoutMaxMs(),
+                                            COMMON_CONFIG.getRatisFirstElectionTimeoutMaxMs(),
                                               TimeUnit.MILLISECONDS))
                                       .build())
                               .setClient(
                                   RatisConfig.Client.newBuilder()
                                       .setClientRequestTimeoutMillis(
-                                          conf.getDataRatisConsensusRequestTimeoutMs())
+                                        COMMON_CONFIG.getDataRegionRatisRequestTimeoutMs())
                                       .setClientMaxRetryAttempt(
-                                          conf.getDataRatisConsensusMaxRetryAttempts())
+                                        COMMON_CONFIG.getDataRegionRatisMaxRetryAttempts())
                                       .setClientRetryInitialSleepTimeMs(
-                                          conf.getDataRatisConsensusInitialSleepTimeMs())
+                                        COMMON_CONFIG.getDataRegionRatisInitialSleepTimeMs())
                                       .setClientRetryMaxSleepTimeMs(
-                                          conf.getDataRatisConsensusMaxSleepTimeMs())
+                                        COMMON_CONFIG.getDataRegionRatisMaxSleepTimeMs())
                                       .setCoreClientNumForEachNode(
-                                          conf.getCoreClientNumForEachNode())
-                                      .setMaxClientNumForEachNode(conf.getMaxClientNumForEachNode())
+                                        IOTDB_CONFIG.getDnCoreClientCountForEachNodeInClientManager())
+                                      .setMaxClientNumForEachNode(IOTDB_CONFIG.getDnMaxClientCountForEachNodeInClientManager())
                                       .build())
                               .setImpl(
                                   RatisConfig.Impl.newBuilder()
-                                      .setTriggerSnapshotFileSize(conf.getDataRatisLogMax())
+                                      .setTriggerSnapshotFileSize(COMMON_CONFIG.getDataRegionRatisLogMax())
                                       .build())
                               .setLeaderLogAppender(
                                   RatisConfig.LeaderLogAppender.newBuilder()
                                       .setBufferByteLimit(
-                                          conf.getDataRatisConsensusLogAppenderBufferSizeMax())
+                                        COMMON_CONFIG.getDataRegionRatisConsensusLogAppenderBufferSize())
                                       .build())
                               .build())
                       .build(),
@@ -179,7 +182,7 @@ public class DataRegionConsensusImpl {
                       new IllegalArgumentException(
                           String.format(
                               ConsensusFactory.CONSTRUCT_FAILED_MSG,
-                              conf.getDataRegionConsensusProtocolClass())));
+                            COMMON_CONFIG.getDataRegionConsensusProtocolClass())));
     }
     return INSTANCE;
   }
diff --git a/server/src/main/java/org/apache/iotdb/db/consensus/SchemaRegionConsensusImpl.java b/server/src/main/java/org/apache/iotdb/db/consensus/SchemaRegionConsensusImpl.java
index d37db2437e..bcd8a20e3c 100644
--- a/server/src/main/java/org/apache/iotdb/db/consensus/SchemaRegionConsensusImpl.java
+++ b/server/src/main/java/org/apache/iotdb/db/consensus/SchemaRegionConsensusImpl.java
@@ -27,6 +27,8 @@ import org.apache.iotdb.consensus.ConsensusFactory;
 import org.apache.iotdb.consensus.IConsensus;
 import org.apache.iotdb.consensus.config.ConsensusConfig;
 import org.apache.iotdb.consensus.config.RatisConfig;
+import org.apache.iotdb.db.conf.IoTDBConfig;
+import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.consensus.statemachine.SchemaRegionStateMachine;
 import org.apache.iotdb.db.metadata.schemaregion.SchemaEngine;
 
@@ -41,7 +43,8 @@ import java.util.concurrent.TimeUnit;
  */
 public class SchemaRegionConsensusImpl {
 
-  private static final CommonConfig conf = CommonDescriptor.getInstance().getConfig();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
+  private static final IoTDBConfig IOTDB_CONFIG = IoTDBDescriptor.getInstance().getConfig();
 
   private static IConsensus INSTANCE = null;
 
@@ -56,85 +59,94 @@ public class SchemaRegionConsensusImpl {
     if (INSTANCE == null) {
       INSTANCE =
           ConsensusFactory.getConsensusImpl(
-                  conf.getSchemaRegionConsensusProtocolClass(),
+                  COMMON_CONFIG.getSchemaRegionConsensusProtocolClass().getProtocol(),
                   ConsensusConfig.newBuilder()
-                      .setThisNodeId(conf.getDataNodeId())
+                      .setThisNodeId(IOTDB_CONFIG.getDataNodeId())
                       .setThisNode(
                           new TEndPoint(
-                              conf.getDnInternalAddress(), conf.getDnSchemaRegionConsensusPort()))
+                              IOTDB_CONFIG.getDnInternalAddress(),
+                              IOTDB_CONFIG.getDnSchemaRegionConsensusPort()))
                       .setRatisConfig(
                           RatisConfig.newBuilder()
                               .setSnapshot(
                                   RatisConfig.Snapshot.newBuilder()
                                       .setAutoTriggerThreshold(
-                                          conf.getSchemaRatisConsensusSnapshotTriggerThreshold())
+                                          COMMON_CONFIG
+                                              .getSchemaRegionRatisSnapshotTriggerThreshold())
                                       .build())
                               .setLog(
                                   RatisConfig.Log.newBuilder()
                                       .setUnsafeFlushEnabled(
-                                          conf.isSchemaRatisConsensusLogUnsafeFlushEnable())
+                                          COMMON_CONFIG.isSchemaRegionRatisLogUnsafeFlushEnable())
                                       .setSegmentSizeMax(
                                           SizeInBytes.valueOf(
-                                              conf.getSchemaRatisConsensusLogSegmentSizeMax()))
+                                              COMMON_CONFIG
+                                                  .getSchemaRegionRatisLogSegmentSizeMax()))
                                       .setPreserveNumsWhenPurge(
-                                          conf.getSchemaRatisConsensusPreserveWhenPurge())
+                                          COMMON_CONFIG.getSchemaRegionRatisPreserveLogsWhenPurge())
                                       .build())
                               .setGrpc(
                                   RatisConfig.Grpc.newBuilder()
                                       .setFlowControlWindow(
                                           SizeInBytes.valueOf(
-                                              conf.getSchemaRatisConsensusGrpcFlowControlWindow()))
+                                              COMMON_CONFIG
+                                                  .getSchemaRegionRatisGrpcFlowControlWindow()))
                                       .build())
                               .setRpc(
                                   RatisConfig.Rpc.newBuilder()
                                       .setTimeoutMin(
                                           TimeDuration.valueOf(
-                                              conf
-                                                  .getSchemaRatisConsensusLeaderElectionTimeoutMinMs(),
+                                              COMMON_CONFIG
+                                                  .getSchemaRegionRatisRpcLeaderElectionTimeoutMinMs(),
                                               TimeUnit.MILLISECONDS))
                                       .setTimeoutMax(
                                           TimeDuration.valueOf(
-                                              conf
-                                                  .getSchemaRatisConsensusLeaderElectionTimeoutMaxMs(),
+                                              COMMON_CONFIG
+                                                  .getSchemaRegionRatisRpcLeaderElectionTimeoutMaxMs(),
                                               TimeUnit.MILLISECONDS))
                                       .setRequestTimeout(
                                           TimeDuration.valueOf(
-                                              conf.getSchemaRatisConsensusRequestTimeoutMs(),
+                                              COMMON_CONFIG.getSchemaRegionRatisRequestTimeoutMs(),
                                               TimeUnit.MILLISECONDS))
                                       .setFirstElectionTimeoutMin(
                                           TimeDuration.valueOf(
-                                              conf.getRatisFirstElectionTimeoutMinMs(),
+                                              COMMON_CONFIG.getRatisFirstElectionTimeoutMinMs(),
                                               TimeUnit.MILLISECONDS))
                                       .setFirstElectionTimeoutMax(
                                           TimeDuration.valueOf(
-                                              conf.getRatisFirstElectionTimeoutMaxMs(),
+                                              COMMON_CONFIG.getRatisFirstElectionTimeoutMaxMs(),
                                               TimeUnit.MILLISECONDS))
                                       .build())
                               .setClient(
                                   RatisConfig.Client.newBuilder()
                                       .setClientRequestTimeoutMillis(
-                                          conf.getDataRatisConsensusRequestTimeoutMs())
+                                          COMMON_CONFIG.getSchemaRegionRatisRequestTimeoutMs())
                                       .setClientMaxRetryAttempt(
-                                          conf.getDataRatisConsensusMaxRetryAttempts())
+                                          COMMON_CONFIG.getSchemaRegionRatisMaxRetryAttempts())
                                       .setClientRetryInitialSleepTimeMs(
-                                          conf.getDataRatisConsensusInitialSleepTimeMs())
+                                          COMMON_CONFIG.getSchemaRegionRatisInitialSleepTimeMs())
                                       .setClientRetryMaxSleepTimeMs(
-                                          conf.getDataRatisConsensusMaxSleepTimeMs())
+                                          COMMON_CONFIG.getSchemaRegionRatisMaxSleepTimeMs())
                                       .setCoreClientNumForEachNode(
-                                          conf.getCoreClientNumForEachNode())
-                                      .setMaxClientNumForEachNode(conf.getMaxClientNumForEachNode())
+                                          IOTDB_CONFIG
+                                              .getDnCoreClientCountForEachNodeInClientManager())
+                                      .setMaxClientNumForEachNode(
+                                          IOTDB_CONFIG
+                                              .getDnMaxClientCountForEachNodeInClientManager())
                                       .build())
                               .setImpl(
                                   RatisConfig.Impl.newBuilder()
-                                      .setTriggerSnapshotFileSize(conf.getSchemaRatisLogMax())
+                                      .setTriggerSnapshotFileSize(
+                                          COMMON_CONFIG.getSchemaRegionRatisLogMax())
                                       .build())
                               .setLeaderLogAppender(
                                   RatisConfig.LeaderLogAppender.newBuilder()
                                       .setBufferByteLimit(
-                                          conf.getSchemaRatisConsensusLogAppenderBufferSizeMax())
+                                          COMMON_CONFIG
+                                              .getSchemaRegionRatisConsensusLogAppenderBufferSize())
                                       .build())
                               .build())
-                      .setStorageDir(conf.getSchemaRegionConsensusDir())
+                      .setStorageDir(IOTDB_CONFIG.getSchemaRegionConsensusDir())
                       .build(),
                   gid ->
                       new SchemaRegionStateMachine(
@@ -144,7 +156,7 @@ public class SchemaRegionConsensusImpl {
                       new IllegalArgumentException(
                           String.format(
                               ConsensusFactory.CONSTRUCT_FAILED_MSG,
-                              conf.getSchemaRegionConsensusProtocolClass())));
+                              COMMON_CONFIG.getSchemaRegionConsensusProtocolClass())));
     }
     return INSTANCE;
   }
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/StorageEngine.java b/server/src/main/java/org/apache/iotdb/db/engine/StorageEngine.java
index 250f1b36b5..52f59aa841 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/StorageEngine.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/StorageEngine.java
@@ -24,6 +24,7 @@ import org.apache.iotdb.common.rpc.thrift.TSetTTLReq;
 import org.apache.iotdb.commons.concurrent.IoTDBThreadPoolFactory;
 import org.apache.iotdb.commons.concurrent.ThreadName;
 import org.apache.iotdb.commons.concurrent.threadpool.ScheduledExecutorUtil;
+import org.apache.iotdb.commons.conf.CommonConfig;
 import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.conf.IoTDBConstant;
 import org.apache.iotdb.commons.consensus.DataRegionId;
@@ -96,6 +97,7 @@ import static org.apache.iotdb.commons.conf.IoTDBConstant.FILE_NAME_SEPARATOR;
 public class StorageEngine implements IService {
   private static final Logger logger = LoggerFactory.getLogger(StorageEngine.class);
 
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
   private static final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
   private static final long TTL_CHECK_INTERVAL = 60 * 1000L;
 
@@ -172,8 +174,9 @@ public class StorageEngine implements IService {
         break;
       }
       try {
-        TimeUnit.MILLISECONDS.sleep(config.getCheckPeriodWhenInsertBlocked());
-        if (System.currentTimeMillis() - startTime > config.getMaxWaitingTimeWhenInsertBlocked()) {
+        TimeUnit.MILLISECONDS.sleep(COMMON_CONFIG.getCheckPeriodWhenInsertBlocked());
+        if (System.currentTimeMillis() - startTime
+            > COMMON_CONFIG.getMaxWaitingTimeWhenInsertBlockedInMs()) {
           throw new WriteProcessRejectException(
               "System rejected over " + (System.currentTimeMillis() - startTime) + "ms");
         }
@@ -215,7 +218,10 @@ public class StorageEngine implements IService {
 
     // wait until wal is recovered
     if (!config.isClusterMode()
-        || !config.getDataRegionConsensusProtocolClass().equals(ConsensusFactory.RATIS_CONSENSUS)) {
+        || !COMMON_CONFIG
+            .getDataRegionConsensusProtocolClass()
+            .getProtocol()
+            .equals(ConsensusFactory.RATIS_CONSENSUS)) {
       try {
         WALRecoverManager.getInstance().recover();
       } catch (WALException e) {
@@ -338,28 +344,28 @@ public class StorageEngine implements IService {
 
   private void startTimedService() {
     // timed flush sequence memtable
-    if (config.isEnableTimedFlushSeqMemtable()) {
+    if (COMMON_CONFIG.isEnableTimedFlushSeqMemtable()) {
       seqMemtableTimedFlushCheckThread =
           IoTDBThreadPoolFactory.newSingleThreadScheduledExecutor(
               ThreadName.TIMED_FLUSH_SEQ_MEMTABLE.getName());
       ScheduledExecutorUtil.safelyScheduleAtFixedRate(
           seqMemtableTimedFlushCheckThread,
           this::timedFlushSeqMemTable,
-          config.getSeqMemtableFlushCheckInterval(),
-          config.getSeqMemtableFlushCheckInterval(),
+          COMMON_CONFIG.getSeqMemtableFlushCheckInterval(),
+          COMMON_CONFIG.getSeqMemtableFlushCheckInterval(),
           TimeUnit.MILLISECONDS);
       logger.info("start sequence memtable timed flush check thread successfully.");
     }
     // timed flush unsequence memtable
-    if (config.isEnableTimedFlushUnseqMemtable()) {
+    if (COMMON_CONFIG.isEnableTimedFlushUnseqMemtable()) {
       unseqMemtableTimedFlushCheckThread =
           IoTDBThreadPoolFactory.newSingleThreadScheduledExecutor(
               ThreadName.TIMED_FLUSH_UNSEQ_MEMTABLE.getName());
       ScheduledExecutorUtil.safelyScheduleAtFixedRate(
           unseqMemtableTimedFlushCheckThread,
           this::timedFlushUnseqMemTable,
-          config.getUnseqMemtableFlushCheckInterval(),
-          config.getUnseqMemtableFlushCheckInterval(),
+          COMMON_CONFIG.getUnseqMemtableFlushCheckInterval(),
+          COMMON_CONFIG.getUnseqMemtableFlushCheckInterval(),
           TimeUnit.MILLISECONDS);
       logger.info("start unsequence memtable timed flush check thread successfully.");
     }
@@ -651,8 +657,9 @@ public class StorageEngine implements IService {
         region.syncDeleteDataFiles();
         region.deleteFolder(systemDir);
         if (config.isClusterMode()
-            && config
+            && COMMON_CONFIG
                 .getDataRegionConsensusProtocolClass()
+                .getProtocol()
                 .equals(ConsensusFactory.IOT_CONSENSUS)) {
           // delete wal
           WALManager.getInstance()
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/performer/impl/ReadChunkCompactionPerformer.java b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/performer/impl/ReadChunkCompactionPerformer.java
index 238224f8b6..ba13ce09ca 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/performer/impl/ReadChunkCompactionPerformer.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/performer/impl/ReadChunkCompactionPerformer.java
@@ -18,6 +18,7 @@
  */
 package org.apache.iotdb.db.engine.compaction.execute.performer.impl;
 
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.conf.IoTDBConstant;
 import org.apache.iotdb.commons.exception.MetadataException;
 import org.apache.iotdb.commons.path.PartialPath;
@@ -71,7 +72,7 @@ public class ReadChunkCompactionPerformer implements ISeqCompactionPerformer {
         (long)
             ((double) SystemInfo.getInstance().getMemorySizeForCompaction()
                 / IoTDBDescriptor.getInstance().getConfig().getCompactionThreadCount()
-                * IoTDBDescriptor.getInstance().getConfig().getChunkMetadataSizeProportion());
+                * CommonDescriptor.getInstance().getConfig().getChunkMetadataSizeProportion());
     TsFileMetricManager.getInstance().addCompactionTempFileNum(true, true, 1);
     try (MultiTsFileDeviceIterator deviceIterator = new MultiTsFileDeviceIterator(seqFiles);
         TsFileIOWriter writer =
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/writer/AbstractCrossCompactionWriter.java b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/writer/AbstractCrossCompactionWriter.java
index c781363966..70658d4a58 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/writer/AbstractCrossCompactionWriter.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/writer/AbstractCrossCompactionWriter.java
@@ -18,6 +18,7 @@
  */
 package org.apache.iotdb.db.engine.compaction.execute.utils.writer;
 
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.conf.IoTDBConstant;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.engine.compaction.execute.utils.CompactionUtils;
@@ -72,9 +73,9 @@ public abstract class AbstractCrossCompactionWriter extends AbstractCompactionWr
         (long)
             (SystemInfo.getInstance().getMemorySizeForCompaction()
                 / IoTDBDescriptor.getInstance().getConfig().getCompactionThreadCount()
-                * IoTDBDescriptor.getInstance().getConfig().getChunkMetadataSizeProportion()
+                * CommonDescriptor.getInstance().getConfig().getChunkMetadataSizeProportion()
                 / targetResources.size());
-    boolean enableMemoryControl = IoTDBDescriptor.getInstance().getConfig().isEnableMemControl();
+    boolean enableMemoryControl = CommonDescriptor.getInstance().getConfig().isEnableMemControl();
     for (int i = 0; i < targetResources.size(); i++) {
       this.targetFileWriters.add(
           new TsFileIOWriter(
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/writer/AbstractInnerCompactionWriter.java b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/writer/AbstractInnerCompactionWriter.java
index e8d816b2ef..f31de93e6f 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/writer/AbstractInnerCompactionWriter.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/compaction/execute/utils/writer/AbstractInnerCompactionWriter.java
@@ -18,6 +18,7 @@
  */
 package org.apache.iotdb.db.engine.compaction.execute.utils.writer;
 
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.engine.compaction.execute.utils.CompactionUtils;
 import org.apache.iotdb.db.engine.storagegroup.TsFileResource;
@@ -47,8 +48,8 @@ public abstract class AbstractInnerCompactionWriter extends AbstractCompactionWr
         (long)
             (SystemInfo.getInstance().getMemorySizeForCompaction()
                 / IoTDBDescriptor.getInstance().getConfig().getCompactionThreadCount()
-                * IoTDBDescriptor.getInstance().getConfig().getChunkMetadataSizeProportion());
-    boolean enableMemoryControl = IoTDBDescriptor.getInstance().getConfig().isEnableMemControl();
+                * CommonDescriptor.getInstance().getConfig().getChunkMetadataSizeProportion());
+    boolean enableMemoryControl = CommonDescriptor.getInstance().getConfig().isEnableMemControl();
     this.fileWriter =
         new TsFileIOWriter(targetFileResource.getTsFile(), enableMemoryControl, sizeForFileWriter);
     this.targetResource = targetFileResource;
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/flush/MemTableFlushTask.java b/server/src/main/java/org/apache/iotdb/db/engine/flush/MemTableFlushTask.java
index 138af6962e..9206e679e3 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/flush/MemTableFlushTask.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/flush/MemTableFlushTask.java
@@ -18,11 +18,11 @@
  */
 package org.apache.iotdb.db.engine.flush;
 
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.service.metric.MetricService;
 import org.apache.iotdb.commons.service.metric.enums.Metric;
 import org.apache.iotdb.commons.service.metric.enums.Tag;
-import org.apache.iotdb.db.conf.IoTDBConfig;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.engine.flush.pool.FlushSubTaskPoolManager;
 import org.apache.iotdb.db.engine.memtable.IMemTable;
 import org.apache.iotdb.db.engine.memtable.IWritableMemChunk;
@@ -58,15 +58,15 @@ public class MemTableFlushTask {
   private static final Logger LOGGER = LoggerFactory.getLogger(MemTableFlushTask.class);
   private static final FlushSubTaskPoolManager SUB_TASK_POOL_MANAGER =
       FlushSubTaskPoolManager.getInstance();
-  private static IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
+  private static CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
   private final Future<?> encodingTaskFuture;
   private final Future<?> ioTaskFuture;
   private RestorableTsFileIOWriter writer;
 
   private final LinkedBlockingQueue<Object> encodingTaskQueue = new LinkedBlockingQueue<>();
   private final LinkedBlockingQueue<Object> ioTaskQueue =
-      (config.isEnableMemControl() && SystemInfo.getInstance().isEncodingFasterThanIo())
-          ? new LinkedBlockingQueue<>(config.getIoTaskQueueSizeForFlushing())
+      (COMMON_CONFIG.isEnableMemControl() && SystemInfo.getInstance().isEncodingFasterThanIo())
+          ? new LinkedBlockingQueue<>(COMMON_CONFIG.getIoTaskQueueSizeForFlushing())
           : new LinkedBlockingQueue<>();
 
   private String storageGroup;
@@ -106,13 +106,13 @@ public class MemTableFlushTask {
         memTable.getSeriesNumber());
 
     long estimatedTemporaryMemSize = 0L;
-    if (config.isEnableMemControl() && SystemInfo.getInstance().isEncodingFasterThanIo()) {
+    if (COMMON_CONFIG.isEnableMemControl() && SystemInfo.getInstance().isEncodingFasterThanIo()) {
       estimatedTemporaryMemSize =
           memTable.getSeriesNumber() == 0
               ? 0
               : memTable.memSize()
                   / memTable.getSeriesNumber()
-                  * config.getIoTaskQueueSizeForFlushing();
+                  * COMMON_CONFIG.getIoTaskQueueSizeForFlushing();
       SystemInfo.getInstance().applyTemporaryMemoryForFlushing(estimatedTemporaryMemSize);
     }
     long start = System.currentTimeMillis();
@@ -170,7 +170,7 @@ public class MemTableFlushTask {
       throw new ExecutionException(e);
     }
 
-    if (config.isEnableMemControl()) {
+    if (COMMON_CONFIG.isEnableMemControl()) {
       if (estimatedTemporaryMemSize != 0) {
         SystemInfo.getInstance().releaseTemporaryMemoryForFlushing(estimatedTemporaryMemSize);
       }
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/flush/pool/FlushTaskPoolManager.java b/server/src/main/java/org/apache/iotdb/db/engine/flush/pool/FlushTaskPoolManager.java
index 2d67223aa1..dd63d1bfa0 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/flush/pool/FlushTaskPoolManager.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/flush/pool/FlushTaskPoolManager.java
@@ -20,7 +20,7 @@ package org.apache.iotdb.db.engine.flush.pool;
 
 import org.apache.iotdb.commons.concurrent.IoTDBThreadPoolFactory;
 import org.apache.iotdb.commons.concurrent.ThreadName;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.db.rescon.AbstractPoolManager;
 
 import org.slf4j.Logger;
@@ -31,7 +31,7 @@ public class FlushTaskPoolManager extends AbstractPoolManager {
   private static final Logger LOGGER = LoggerFactory.getLogger(FlushTaskPoolManager.class);
 
   private FlushTaskPoolManager() {
-    int threadCnt = IoTDBDescriptor.getInstance().getConfig().getFlushThreadCount();
+    int threadCnt = CommonDescriptor.getInstance().getConfig().getFlushThreadCount();
     pool = IoTDBThreadPoolFactory.newFixedThreadPool(threadCnt, ThreadName.FLUSH_SERVICE.getName());
   }
 
@@ -52,7 +52,7 @@ public class FlushTaskPoolManager extends AbstractPoolManager {
   @Override
   public void start() {
     if (pool == null) {
-      int threadCnt = IoTDBDescriptor.getInstance().getConfig().getFlushThreadCount();
+      int threadCnt = CommonDescriptor.getInstance().getConfig().getFlushThreadCount();
       pool =
           IoTDBThreadPoolFactory.newFixedThreadPool(threadCnt, ThreadName.FLUSH_SERVICE.getName());
     }
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/DataRegion.java b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/DataRegion.java
index 931094480d..aef98c79e0 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/DataRegion.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/DataRegion.java
@@ -23,6 +23,7 @@ import org.apache.iotdb.commons.cluster.NodeStatus;
 import org.apache.iotdb.commons.concurrent.IoTDBThreadPoolFactory;
 import org.apache.iotdb.commons.concurrent.ThreadName;
 import org.apache.iotdb.commons.concurrent.threadpool.ScheduledExecutorUtil;
+import org.apache.iotdb.commons.conf.CommonConfig;
 import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.conf.IoTDBConstant;
 import org.apache.iotdb.commons.consensus.DataRegionId;
@@ -162,6 +163,7 @@ import static org.apache.iotdb.tsfile.common.constant.TsFileConstant.TSFILE_SUFF
 public class DataRegion implements IDataRegionForQuery {
 
   private static final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
   private static final Logger DEBUG_LOGGER = LoggerFactory.getLogger("QUERY_DEBUG");
 
   /**
@@ -175,7 +177,7 @@ public class DataRegion implements IDataRegionForQuery {
   /** indicating the file to be loaded overlap with some files. */
   private static final int POS_OVERLAP = -3;
 
-  private final boolean enableMemControl = config.isEnableMemControl();
+  private final boolean enableMemControl = COMMON_CONFIG.isEnableMemControl();
   /**
    * a read write lock for guaranteeing concurrent safety when accessing all fields in this class
    * (i.e., schema, (un)sequenceFileList, work(un)SequenceTsFileProcessor,
@@ -308,7 +310,10 @@ public class DataRegion implements IDataRegionForQuery {
 
     // recover tsfiles unless consensus protocol is ratis and storage engine is not ready
     if (config.isClusterMode()
-        && config.getDataRegionConsensusProtocolClass().equals(ConsensusFactory.RATIS_CONSENSUS)
+        && COMMON_CONFIG
+            .getDataRegionConsensusProtocolClass()
+            .getProtocol()
+            .equals(ConsensusFactory.RATIS_CONSENSUS)
         && !StorageEngine.getInstance().isAllSgReady()) {
       logger.debug(
           "Skip recovering data region {}[{}] when consensus protocol is ratis and storage engine is not ready.",
@@ -410,7 +415,7 @@ public class DataRegion implements IDataRegionForQuery {
       if (lastLogCheckFilesNum + filesNumLogCheckTrigger < recoveredFilesNum) {
         lastLogCheckFilesNum = recoveredFilesNum;
         // log only when log interval exceeds recovery log interval
-        if (lastLogTime + config.getRecoveryLogIntervalInMs() < System.currentTimeMillis()) {
+        if (lastLogTime + COMMON_CONFIG.getRecoveryLogIntervalInMs() < System.currentTimeMillis()) {
           logger.info(
               "The data region {}[{}] has recovered {}%, please wait a moment.",
               databaseName, dataRegionId, recoveredFilesNum * 1.0 / numOfFilesToRecover);
@@ -928,8 +933,7 @@ public class DataRegion implements IDataRegionForQuery {
                   timePartitionId, insertRowNode.getDevicePath().getFullPath());
 
       // is unsequence and user set config to discard out of order data
-      if (!isSequence
-          && IoTDBDescriptor.getInstance().getConfig().isEnableDiscardOutOfOrderData()) {
+      if (!isSequence && COMMON_CONFIG.isEnableDiscardOutOfOrderData()) {
         return;
       }
 
@@ -1019,7 +1023,7 @@ public class DataRegion implements IDataRegionForQuery {
         // judge if we should insert sequence
         if (!isSequence && time > lastFlushTime) {
           // insert into unsequence and then start sequence
-          if (!IoTDBDescriptor.getInstance().getConfig().isEnableDiscardOutOfOrderData()) {
+          if (!COMMON_CONFIG.isEnableDiscardOutOfOrderData()) {
             noFailure =
                 insertTabletToTsFileProcessor(
                         insertTabletNode, before, loc, false, results, beforeTimePartition)
@@ -1032,9 +1036,7 @@ public class DataRegion implements IDataRegionForQuery {
       }
 
       // do not forget last part
-      if (before < loc
-          && (isSequence
-              || !IoTDBDescriptor.getInstance().getConfig().isEnableDiscardOutOfOrderData())) {
+      if (before < loc && (isSequence || !COMMON_CONFIG.isEnableDiscardOutOfOrderData())) {
         noFailure =
             insertTabletToTsFileProcessor(
                     insertTabletNode, before, loc, isSequence, results, beforeTimePartition)
@@ -1115,7 +1117,7 @@ public class DataRegion implements IDataRegionForQuery {
   }
 
   private void tryToUpdateBatchInsertLastCache(InsertTabletNode node, long latestFlushedTime) {
-    if (!IoTDBDescriptor.getInstance().getConfig().isLastCacheEnabled()) {
+    if (!COMMON_CONFIG.isEnableLastCache()) {
       return;
     }
     for (int i = 0; i < node.getColumns().length; i++) {
@@ -1154,7 +1156,7 @@ public class DataRegion implements IDataRegionForQuery {
   }
 
   private void tryToUpdateInsertLastCache(InsertRowNode node, long latestFlushedTime) {
-    if (!IoTDBDescriptor.getInstance().getConfig().isLastCacheEnabled()) {
+    if (!COMMON_CONFIG.isEnableLastCache()) {
       return;
     }
     for (int i = 0; i < node.getValues().length; i++) {
@@ -1535,7 +1537,7 @@ public class DataRegion implements IDataRegionForQuery {
             resource.getTsFilePath(),
             new Date(ttlLowerBound),
             dataTTL,
-            config.getTimestampPrecision());
+            COMMON_CONFIG.getTimestampPrecision());
       } finally {
         resource.writeUnlock();
       }
@@ -1548,7 +1550,8 @@ public class DataRegion implements IDataRegionForQuery {
       // only check sequence tsfiles' memtables
       List<TsFileProcessor> tsFileProcessors =
           new ArrayList<>(workSequenceTsFileProcessors.values());
-      long timeLowerBound = System.currentTimeMillis() - config.getSeqMemtableFlushInterval();
+      long timeLowerBound =
+          System.currentTimeMillis() - COMMON_CONFIG.getSeqMemtableFlushInterval();
 
       for (TsFileProcessor tsFileProcessor : tsFileProcessors) {
         if (tsFileProcessor.getWorkMemTableCreatedTime() < timeLowerBound) {
@@ -1571,7 +1574,8 @@ public class DataRegion implements IDataRegionForQuery {
       // only check unsequence tsfiles' memtables
       List<TsFileProcessor> tsFileProcessors =
           new ArrayList<>(workUnsequenceTsFileProcessors.values());
-      long timeLowerBound = System.currentTimeMillis() - config.getUnseqMemtableFlushInterval();
+      long timeLowerBound =
+          System.currentTimeMillis() - COMMON_CONFIG.getUnseqMemtableFlushInterval();
 
       for (TsFileProcessor tsFileProcessor : tsFileProcessors) {
         if (tsFileProcessor.getWorkMemTableCreatedTime() < timeLowerBound) {
@@ -1898,7 +1902,7 @@ public class DataRegion implements IDataRegionForQuery {
     long timePartitionStartId = StorageEngine.getTimePartition(startTime);
     long timePartitionEndId = StorageEngine.getTimePartition(endTime);
     List<WALFlushListener> walFlushListeners = new ArrayList<>();
-    if (config.getWalMode() == WALMode.DISABLE) {
+    if (COMMON_CONFIG.getWalMode() == WALMode.DISABLE) {
       return walFlushListeners;
     }
     DeleteDataNode deleteDataNode =
@@ -2246,7 +2250,7 @@ public class DataRegion implements IDataRegionForQuery {
   }
 
   private void resetLastCacheWhenLoadingTsFile() throws IllegalPathException {
-    if (!IoTDBDescriptor.getInstance().getConfig().isLastCacheEnabled()) {
+    if (!COMMON_CONFIG.isEnableLastCache()) {
       return;
     }
     DataNodeSchemaCache.getInstance().cleanUp();
@@ -2860,7 +2864,7 @@ public class DataRegion implements IDataRegionForQuery {
     if (dataTTL != Long.MAX_VALUE) {
       dataTTL =
           DateTimeUtils.convertMilliTimeWithPrecision(
-              dataTTL, IoTDBDescriptor.getInstance().getConfig().getTimestampPrecision());
+              dataTTL, COMMON_CONFIG.getTimestampPrecision());
     }
     this.dataTTL = dataTTL;
   }
@@ -3095,8 +3099,7 @@ public class DataRegion implements IDataRegionForQuery {
                       timePartitionId, insertRowNode.getDevicePath().getFullPath());
         }
         // is unsequence and user set config to discard out of order data
-        if (!isSequence
-            && IoTDBDescriptor.getInstance().getConfig().isEnableDiscardOutOfOrderData()) {
+        if (!isSequence && COMMON_CONFIG.isEnableDiscardOutOfOrderData()) {
           return;
         }
 
@@ -3306,7 +3309,10 @@ public class DataRegion implements IDataRegionForQuery {
 
   /** This method could only be used in iot consensus */
   public IWALNode getWALNode() {
-    if (!config.getDataRegionConsensusProtocolClass().equals(ConsensusFactory.IOT_CONSENSUS)) {
+    if (!COMMON_CONFIG
+        .getDataRegionConsensusProtocolClass()
+        .getProtocol()
+        .equals(ConsensusFactory.IOT_CONSENSUS)) {
       throw new UnsupportedOperationException();
     }
     // identifier should be same with getTsFileProcessor method
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/DataRegionInfo.java b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/DataRegionInfo.java
index 2add35658e..0e60feae04 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/DataRegionInfo.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/DataRegionInfo.java
@@ -18,7 +18,7 @@
  */
 package org.apache.iotdb.db.engine.storagegroup;
 
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.db.rescon.SystemInfo;
 
 import java.util.List;
@@ -39,9 +39,9 @@ public class DataRegionInfo {
   /** The threshold of reporting it's size to SystemInfo */
   private final long storageGroupSizeReportThreshold =
       (long)
-          (IoTDBDescriptor.getInstance().getConfig().getWriteMemoryVariationReportProportion()
-              * IoTDBDescriptor.getInstance().getConfig().getAllocateMemoryForStorageEngine()
-              * IoTDBDescriptor.getInstance().getConfig().getWriteProportionForMemtable());
+          (CommonDescriptor.getInstance().getConfig().getWriteMemoryVariationReportProportion()
+              * CommonDescriptor.getInstance().getConfig().getAllocateMemoryForStorageEngine()
+              * CommonDescriptor.getInstance().getConfig().getWriteProportionForMemtable());
 
   private final AtomicLong lastReportedSize = new AtomicLong();
 
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TimePartitionManager.java b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TimePartitionManager.java
index 1f77b36b82..ff507ed552 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TimePartitionManager.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TimePartitionManager.java
@@ -19,6 +19,7 @@
 
 package org.apache.iotdb.db.engine.storagegroup;
 
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.consensus.DataRegionId;
 import org.apache.iotdb.commons.utils.TestOnly;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
@@ -35,7 +36,7 @@ public class TimePartitionManager {
 
   long memCost = 0;
   long timePartitionInfoMemoryThreshold =
-      IoTDBDescriptor.getInstance().getConfig().getAllocateMemoryForTimePartitionInfo();
+      CommonDescriptor.getInstance().getConfig().getAllocateMemoryForTimePartitionInfo();
 
   private TimePartitionManager() {
     timePartitionInfoMap = new HashMap<>();
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileProcessor.java b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileProcessor.java
index 7807418b1f..a3678b1459 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileProcessor.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/storagegroup/TsFileProcessor.java
@@ -19,6 +19,7 @@
 package org.apache.iotdb.db.engine.storagegroup;
 
 import org.apache.iotdb.common.rpc.thrift.TSStatus;
+import org.apache.iotdb.commons.conf.CommonConfig;
 import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.exception.MetadataException;
 import org.apache.iotdb.commons.path.AlignedPath;
@@ -98,14 +99,14 @@ public class TsFileProcessor {
   /** logger fot this class */
   private static final Logger logger = LoggerFactory.getLogger(TsFileProcessor.class);
 
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
+  private static final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
+
   /** storgae group name of this tsfile */
   private final String storageGroupName;
 
-  /** IoTDB config */
-  private final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
-
   /** whether it's enable mem control */
-  private final boolean enableMemControl = config.isEnableMemControl();
+  private final boolean enableMemControl = COMMON_CONFIG.isEnableMemControl();
 
   /** database info for mem control */
   private DataRegionInfo dataRegionInfo;
@@ -718,7 +719,7 @@ public class TsFileProcessor {
   }
 
   private long getMemtableSizeThresholdBasedOnSeriesNum() {
-    return config.getMemtableSizeThreshold();
+    return COMMON_CONFIG.getMemtableSizeThreshold();
   }
 
   public boolean shouldClose() {
diff --git a/server/src/main/java/org/apache/iotdb/db/engine/trigger/utils/MQTTConnectionPool.java b/server/src/main/java/org/apache/iotdb/db/engine/trigger/utils/MQTTConnectionPool.java
index fbc775a1a3..b5877d07b6 100644
--- a/server/src/main/java/org/apache/iotdb/db/engine/trigger/utils/MQTTConnectionPool.java
+++ b/server/src/main/java/org/apache/iotdb/db/engine/trigger/utils/MQTTConnectionPool.java
@@ -19,7 +19,7 @@
 
 package org.apache.iotdb.db.engine.trigger.utils;
 
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 
 import org.apache.commons.pool2.impl.GenericObjectPool;
 import org.fusesource.mqtt.client.BlockingConnection;
@@ -51,7 +51,7 @@ public class MQTTConnectionPool extends GenericObjectPool<BlockingConnection> {
   private MQTTConnectionPool(MQTTConnectionFactory factory, int size) {
     super(factory);
     setMaxTotal(
-        Math.min(size, IoTDBDescriptor.getInstance().getConfig().getTriggerForwardMQTTPoolSize()));
+        Math.min(size, CommonDescriptor.getInstance().getConfig().getTriggerForwardMQTTPoolSize()));
     setMinIdle(1);
   }
 
diff --git a/server/src/main/java/org/apache/iotdb/db/metadata/cache/DataNodeSchemaCache.java b/server/src/main/java/org/apache/iotdb/db/metadata/cache/DataNodeSchemaCache.java
index a3a47d07a8..bfde2437d0 100644
--- a/server/src/main/java/org/apache/iotdb/db/metadata/cache/DataNodeSchemaCache.java
+++ b/server/src/main/java/org/apache/iotdb/db/metadata/cache/DataNodeSchemaCache.java
@@ -19,11 +19,11 @@
 
 package org.apache.iotdb.db.metadata.cache;
 
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.path.MeasurementPath;
 import org.apache.iotdb.commons.path.PartialPath;
 import org.apache.iotdb.commons.service.metric.MetricService;
-import org.apache.iotdb.db.conf.IoTDBConfig;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.mpp.common.schematree.ClusterSchemaTree;
 import org.apache.iotdb.tsfile.read.TimeValuePair;
 import org.apache.iotdb.tsfile.write.schema.MeasurementSchema;
@@ -45,7 +45,7 @@ import java.util.concurrent.locks.ReentrantReadWriteLock;
 public class DataNodeSchemaCache {
 
   private static final Logger logger = LoggerFactory.getLogger(DataNodeSchemaCache.class);
-  private static final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
 
   private final Cache<PartialPath, SchemaCacheEntry> cache;
 
@@ -55,7 +55,7 @@ public class DataNodeSchemaCache {
   private DataNodeSchemaCache() {
     cache =
         Caffeine.newBuilder()
-            .maximumWeight(config.getAllocateMemoryForSchemaCache())
+            .maximumWeight(COMMON_CONFIG.getAllocateMemoryForSchemaCache())
             .weigher(
                 (PartialPath key, SchemaCacheEntry value) ->
                     PartialPath.estimateSize(key) + SchemaCacheEntry.estimateSize(value))
diff --git a/server/src/main/java/org/apache/iotdb/db/metadata/rescon/MemoryStatistics.java b/server/src/main/java/org/apache/iotdb/db/metadata/rescon/MemoryStatistics.java
index 78d2e76db2..4e6cc501ae 100644
--- a/server/src/main/java/org/apache/iotdb/db/metadata/rescon/MemoryStatistics.java
+++ b/server/src/main/java/org/apache/iotdb/db/metadata/rescon/MemoryStatistics.java
@@ -19,6 +19,7 @@
 
 package org.apache.iotdb.db.metadata.rescon;
 
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 
 import org.slf4j.Logger;
@@ -53,7 +54,7 @@ public class MemoryStatistics {
   private MemoryStatistics() {}
 
   public void init() {
-    memoryCapacity = IoTDBDescriptor.getInstance().getConfig().getAllocateMemoryForSchemaRegion();
+    memoryCapacity = CommonDescriptor.getInstance().getConfig().getAllocateMemoryForSchemaRegion();
     memoryUsage.getAndSet(0);
     allowToCreateNewSeries = true;
   }
diff --git a/server/src/main/java/org/apache/iotdb/db/metadata/schemaregion/SchemaEngine.java b/server/src/main/java/org/apache/iotdb/db/metadata/schemaregion/SchemaEngine.java
index 2f60e6e1d4..adcf9066de 100644
--- a/server/src/main/java/org/apache/iotdb/db/metadata/schemaregion/SchemaEngine.java
+++ b/server/src/main/java/org/apache/iotdb/db/metadata/schemaregion/SchemaEngine.java
@@ -22,6 +22,8 @@ package org.apache.iotdb.db.metadata.schemaregion;
 import org.apache.iotdb.common.rpc.thrift.TSStatus;
 import org.apache.iotdb.commons.concurrent.IoTDBThreadPoolFactory;
 import org.apache.iotdb.commons.concurrent.threadpool.ScheduledExecutorUtil;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.consensus.SchemaRegionId;
 import org.apache.iotdb.commons.exception.IllegalPathException;
 import org.apache.iotdb.commons.exception.MetadataException;
@@ -58,6 +60,7 @@ public class SchemaEngine {
 
   private static final Logger logger = LoggerFactory.getLogger(SchemaEngine.class);
 
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
   private static final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
 
   private volatile Map<SchemaRegionId, ISchemaRegion> schemaRegionMap;
@@ -120,18 +123,19 @@ public class SchemaEngine {
     Map<PartialPath, List<SchemaRegionId>> schemaRegionInfo = initSchemaRegion();
 
     if (!(config.isClusterMode()
-            && config
+            && COMMON_CONFIG
                 .getSchemaRegionConsensusProtocolClass()
+                .getProtocol()
                 .equals(ConsensusFactory.RATIS_CONSENSUS))
-        && config.getSyncMlogPeriodInMs() != 0) {
+        && COMMON_CONFIG.getSyncMlogPeriodInMs() != 0) {
       timedForceMLogThread =
           IoTDBThreadPoolFactory.newSingleThreadScheduledExecutor(
               "SchemaEngine-TimedForceMLog-Thread");
       ScheduledExecutorUtil.unsafelyScheduleAtFixedRate(
           timedForceMLogThread,
           this::forceMlog,
-          config.getSyncMlogPeriodInMs(),
-          config.getSyncMlogPeriodInMs(),
+          COMMON_CONFIG.getSyncMlogPeriodInMs(),
+          COMMON_CONFIG.getSyncMlogPeriodInMs(),
           TimeUnit.MILLISECONDS);
     }
 
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/common/schematree/ClusterSchemaTree.java b/server/src/main/java/org/apache/iotdb/db/mpp/common/schematree/ClusterSchemaTree.java
index 4b547c28ec..ead88e81ec 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/common/schematree/ClusterSchemaTree.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/common/schematree/ClusterSchemaTree.java
@@ -19,11 +19,11 @@
 
 package org.apache.iotdb.db.mpp.common.schematree;
 
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.path.MeasurementPath;
 import org.apache.iotdb.commons.path.PartialPath;
 import org.apache.iotdb.commons.utils.PathUtils;
 import org.apache.iotdb.commons.utils.TestOnly;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.mpp.common.schematree.node.SchemaEntityNode;
 import org.apache.iotdb.db.mpp.common.schematree.node.SchemaInternalNode;
 import org.apache.iotdb.db.mpp.common.schematree.node.SchemaMeasurementNode;
@@ -87,7 +87,7 @@ public class ClusterSchemaTree implements ISchemaTree {
             root,
             pathPattern,
             false,
-            IoTDBDescriptor.getInstance().getConfig().getMaxQueryDeduplicatedPathNum() + 1,
+            CommonDescriptor.getInstance().getConfig().getMaxDeduplicatedPathNum() + 1,
             0);
     return new Pair<>(visitor.getAllResult(), visitor.getNextOffset());
   }
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/execution/exchange/MPPDataExchangeService.java b/server/src/main/java/org/apache/iotdb/db/mpp/execution/exchange/MPPDataExchangeService.java
index d35a145004..4efa08e78c 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/execution/exchange/MPPDataExchangeService.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/execution/exchange/MPPDataExchangeService.java
@@ -26,6 +26,8 @@ import org.apache.iotdb.commons.client.sync.SyncDataNodeMPPDataExchangeServiceCl
 import org.apache.iotdb.commons.concurrent.IoTDBThreadPoolFactory;
 import org.apache.iotdb.commons.concurrent.IoTThreadFactory;
 import org.apache.iotdb.commons.concurrent.ThreadName;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.exception.runtime.RPCServiceException;
 import org.apache.iotdb.commons.service.ServiceType;
 import org.apache.iotdb.commons.service.ThriftService;
@@ -47,6 +49,8 @@ public class MPPDataExchangeService extends ThriftService implements MPPDataExch
 
   private static final Logger LOGGER = LoggerFactory.getLogger(MPPDataExchangeService.class);
 
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
+
   private final MPPDataExchangeManager mppDataExchangeManager;
   private final ExecutorService executorService;
 
@@ -54,9 +58,9 @@ public class MPPDataExchangeService extends ThriftService implements MPPDataExch
     IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
     executorService =
         IoTDBThreadPoolFactory.newThreadPool(
-            config.getMppDataExchangeCorePoolSize(),
-            config.getMppDataExchangeMaxPoolSize(),
-            config.getMppDataExchangeKeepAliveTimeInMs(),
+            COMMON_CONFIG.getMppDataExchangeCorePoolSize(),
+            COMMON_CONFIG.getMppDataExchangeMaxPoolSize(),
+            COMMON_CONFIG.getMppDataExchangeKeepAliveTimeInMs(),
             TimeUnit.MILLISECONDS,
             // TODO: Use a priority queue.
             new LinkedBlockingQueue<>(),
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/execution/exchange/SharedTsBlockQueue.java b/server/src/main/java/org/apache/iotdb/db/mpp/execution/exchange/SharedTsBlockQueue.java
index ade913aebc..ef7299a67d 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/execution/exchange/SharedTsBlockQueue.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/execution/exchange/SharedTsBlockQueue.java
@@ -19,7 +19,7 @@
 
 package org.apache.iotdb.db.mpp.execution.exchange;
 
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.db.mpp.execution.memory.LocalMemoryManager;
 import org.apache.iotdb.mpp.rpc.thrift.TFragmentInstanceId;
 import org.apache.iotdb.tsfile.read.common.block.TsBlock;
@@ -73,7 +73,7 @@ public class SharedTsBlockQueue {
   private LocalSinkHandle sinkHandle;
 
   private long maxBytesCanReserve =
-      IoTDBDescriptor.getInstance().getConfig().getMaxBytesPerFragmentInstance();
+      CommonDescriptor.getInstance().getConfig().getMaxBytesPerFragmentInstance();
 
   public SharedTsBlockQueue(
       TFragmentInstanceId fragmentInstanceId,
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/execution/exchange/SinkHandle.java b/server/src/main/java/org/apache/iotdb/db/mpp/execution/exchange/SinkHandle.java
index e2494af0fb..ae913b5481 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/execution/exchange/SinkHandle.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/execution/exchange/SinkHandle.java
@@ -22,6 +22,7 @@ package org.apache.iotdb.db.mpp.execution.exchange;
 import org.apache.iotdb.common.rpc.thrift.TEndPoint;
 import org.apache.iotdb.commons.client.IClientManager;
 import org.apache.iotdb.commons.client.sync.SyncDataNodeMPPDataExchangeServiceClient;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.utils.TestOnly;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.mpp.execution.exchange.MPPDataExchangeManager.SinkHandleListener;
@@ -100,7 +101,7 @@ public class SinkHandle implements ISinkHandle {
 
   /** max bytes this SourceHandle can reserve. */
   private long maxBytesCanReserve =
-      IoTDBDescriptor.getInstance().getConfig().getMaxBytesPerFragmentInstance();
+    CommonDescriptor.getInstance().getConfig().getMaxBytesPerFragmentInstance();
 
   private static final QueryMetricsManager QUERY_METRICS = QueryMetricsManager.getInstance();
 
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/execution/exchange/SourceHandle.java b/server/src/main/java/org/apache/iotdb/db/mpp/execution/exchange/SourceHandle.java
index 2e1a4b8a6d..a20b4dabe4 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/execution/exchange/SourceHandle.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/execution/exchange/SourceHandle.java
@@ -22,6 +22,7 @@ package org.apache.iotdb.db.mpp.execution.exchange;
 import org.apache.iotdb.common.rpc.thrift.TEndPoint;
 import org.apache.iotdb.commons.client.IClientManager;
 import org.apache.iotdb.commons.client.sync.SyncDataNodeMPPDataExchangeServiceClient;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.utils.TestOnly;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.mpp.execution.exchange.MPPDataExchangeManager.SourceHandleListener;
@@ -97,7 +98,7 @@ public class SourceHandle implements ISourceHandle {
 
   /** max bytes this SourceHandle can reserve. */
   private long maxBytesCanReserve =
-      IoTDBDescriptor.getInstance().getConfig().getMaxBytesPerFragmentInstance();
+    CommonDescriptor.getInstance().getConfig().getMaxBytesPerFragmentInstance();
 
   /**
    * this is set to true after calling isBlocked() at least once which indicates that this
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/execution/executor/RegionWriteExecutor.java b/server/src/main/java/org/apache/iotdb/db/mpp/execution/executor/RegionWriteExecutor.java
index 73df88fd94..cd1b5a305a 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/execution/executor/RegionWriteExecutor.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/execution/executor/RegionWriteExecutor.java
@@ -20,6 +20,8 @@
 package org.apache.iotdb.db.mpp.execution.executor;
 
 import org.apache.iotdb.common.rpc.thrift.TSStatus;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.consensus.ConsensusGroupId;
 import org.apache.iotdb.commons.consensus.DataRegionId;
 import org.apache.iotdb.commons.consensus.SchemaRegionId;
@@ -29,8 +31,6 @@ import org.apache.iotdb.commons.path.MeasurementPath;
 import org.apache.iotdb.commons.path.PartialPath;
 import org.apache.iotdb.consensus.ConsensusFactory;
 import org.apache.iotdb.consensus.common.response.ConsensusWriteResponse;
-import org.apache.iotdb.db.conf.IoTDBConfig;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.consensus.DataRegionConsensusImpl;
 import org.apache.iotdb.db.consensus.SchemaRegionConsensusImpl;
 import org.apache.iotdb.db.exception.metadata.MeasurementAlreadyExistException;
@@ -76,6 +76,8 @@ public class RegionWriteExecutor {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(RegionWriteExecutor.class);
 
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
+
   private static final DataNodeRegionManager REGION_MANAGER = DataNodeRegionManager.getInstance();
 
   public RegionExecutionResult execute(ConsensusGroupId groupId, PlanNode planNode) {
@@ -128,8 +130,6 @@ public class RegionWriteExecutor {
   private static class WritePlanNodeExecutionVisitor
       extends PlanVisitor<RegionExecutionResult, WritePlanNodeExecutionContext> {
 
-    private final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
-
     @Override
     public RegionExecutionResult visitPlan(PlanNode node, WritePlanNodeExecutionContext context) {
       RegionExecutionResult response = new RegionExecutionResult();
@@ -276,7 +276,10 @@ public class RegionWriteExecutor {
         CreateTimeSeriesNode node, WritePlanNodeExecutionContext context) {
       ISchemaRegion schemaRegion =
           SchemaEngine.getInstance().getSchemaRegion((SchemaRegionId) context.getRegionId());
-      if (config.getSchemaRegionConsensusProtocolClass().equals(ConsensusFactory.RATIS_CONSENSUS)) {
+      if (COMMON_CONFIG
+          .getSchemaRegionConsensusProtocolClass()
+          .getProtocol()
+          .equals(ConsensusFactory.RATIS_CONSENSUS)) {
         context.getRegionWriteValidationRWLock().writeLock().lock();
         try {
           Map<Integer, MetadataException> failingMeasurementMap =
@@ -310,7 +313,10 @@ public class RegionWriteExecutor {
         CreateAlignedTimeSeriesNode node, WritePlanNodeExecutionContext context) {
       ISchemaRegion schemaRegion =
           SchemaEngine.getInstance().getSchemaRegion((SchemaRegionId) context.getRegionId());
-      if (config.getSchemaRegionConsensusProtocolClass().equals(ConsensusFactory.RATIS_CONSENSUS)) {
+      if (COMMON_CONFIG
+          .getSchemaRegionConsensusProtocolClass()
+          .getProtocol()
+          .equals(ConsensusFactory.RATIS_CONSENSUS)) {
         context.getRegionWriteValidationRWLock().writeLock().lock();
         try {
           Map<Integer, MetadataException> failingMeasurementMap =
@@ -342,7 +348,10 @@ public class RegionWriteExecutor {
         CreateMultiTimeSeriesNode node, WritePlanNodeExecutionContext context) {
       ISchemaRegion schemaRegion =
           SchemaEngine.getInstance().getSchemaRegion((SchemaRegionId) context.getRegionId());
-      if (config.getSchemaRegionConsensusProtocolClass().equals(ConsensusFactory.RATIS_CONSENSUS)) {
+      if (COMMON_CONFIG
+          .getSchemaRegionConsensusProtocolClass()
+          .getProtocol()
+          .equals(ConsensusFactory.RATIS_CONSENSUS)) {
         context.getRegionWriteValidationRWLock().writeLock().lock();
         try {
           List<TSStatus> failingStatus = new ArrayList<>();
@@ -411,7 +420,10 @@ public class RegionWriteExecutor {
         InternalCreateTimeSeriesNode node, WritePlanNodeExecutionContext context) {
       ISchemaRegion schemaRegion =
           SchemaEngine.getInstance().getSchemaRegion((SchemaRegionId) context.getRegionId());
-      if (config.getSchemaRegionConsensusProtocolClass().equals(ConsensusFactory.RATIS_CONSENSUS)) {
+      if (COMMON_CONFIG
+          .getSchemaRegionConsensusProtocolClass()
+          .getProtocol()
+          .equals(ConsensusFactory.RATIS_CONSENSUS)) {
         context.getRegionWriteValidationRWLock().writeLock().lock();
         try {
           List<TSStatus> failingStatus = new ArrayList<>();
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/execution/memory/LocalMemoryManager.java b/server/src/main/java/org/apache/iotdb/db/mpp/execution/memory/LocalMemoryManager.java
index 1152dfcf10..ae9f0c4a32 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/execution/memory/LocalMemoryManager.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/execution/memory/LocalMemoryManager.java
@@ -19,7 +19,7 @@
 
 package org.apache.iotdb.db.mpp.execution.memory;
 
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 
 /**
  * Manages memory of a data node. The memory is divided into two memory pools so that the memory for
@@ -33,8 +33,8 @@ public class LocalMemoryManager {
     queryPool =
         new MemoryPool(
             "query",
-            IoTDBDescriptor.getInstance().getConfig().getAllocateMemoryForDataExchange(),
-            IoTDBDescriptor.getInstance().getConfig().getMaxBytesPerFragmentInstance());
+            CommonDescriptor.getInstance().getConfig().getAllocateMemoryForDataExchange(),
+            CommonDescriptor.getInstance().getConfig().getMaxBytesPerFragmentInstance());
   }
 
   public MemoryPool getQueryPool() {
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/process/TransformOperator.java b/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/process/TransformOperator.java
index 9f0a0113f5..f8384e090e 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/process/TransformOperator.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/execution/operator/process/TransformOperator.java
@@ -19,6 +19,7 @@
 
 package org.apache.iotdb.db.mpp.execution.operator.process;
 
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.udf.service.UDFClassLoaderManager;
 import org.apache.iotdb.commons.udf.service.UDFManagementService;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
@@ -59,11 +60,11 @@ public class TransformOperator implements ProcessOperator {
   private static final Logger LOGGER = LoggerFactory.getLogger(TransformOperator.class);
 
   protected final float udfReaderMemoryBudgetInMB =
-      IoTDBDescriptor.getInstance().getConfig().getUdfReaderMemoryBudgetInMB();
+      CommonDescriptor.getInstance().getConfig().getUdfReaderMemoryBudgetInMB();
   protected final float udfTransformerMemoryBudgetInMB =
-      IoTDBDescriptor.getInstance().getConfig().getUdfTransformerMemoryBudgetInMB();
+    CommonDescriptor.getInstance().getConfig().getUdfTransformerMemoryBudgetInMB();
   protected final float udfCollectorMemoryBudgetInMB =
-      IoTDBDescriptor.getInstance().getConfig().getUdfCollectorMemoryBudgetInMB();
+    CommonDescriptor.getInstance().getConfig().getUdfCollectorMemoryBudgetInMB();
 
   protected final OperatorContext operatorContext;
   protected final Operator inputOperator;
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/Coordinator.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/Coordinator.java
index 731b650dad..ab66646a4f 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/Coordinator.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/Coordinator.java
@@ -23,6 +23,8 @@ import org.apache.iotdb.commons.client.ClientPoolFactory;
 import org.apache.iotdb.commons.client.IClientManager;
 import org.apache.iotdb.commons.client.sync.SyncDataNodeInternalServiceClient;
 import org.apache.iotdb.commons.concurrent.IoTDBThreadPoolFactory;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.conf.IoTDBConstant;
 import org.apache.iotdb.db.conf.IoTDBConfig;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
@@ -59,11 +61,13 @@ public class Coordinator {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(Coordinator.class);
 
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
+  private static final IoTDBConfig IOTDB_CONFIG = IoTDBDescriptor.getInstance().getConfig();
+
   private static final String COORDINATOR_EXECUTOR_NAME = "MPPCoordinator";
   private static final String COORDINATOR_WRITE_EXECUTOR_NAME = "MPPCoordinatorWrite";
   private static final String COORDINATOR_SCHEDULED_EXECUTOR_NAME = "MPPCoordinatorScheduled";
   private static final int COORDINATOR_SCHEDULED_EXECUTOR_SIZE = 10;
-  private static final IoTDBConfig CONFIG = IoTDBDescriptor.getInstance().getConfig();
 
   private static final Logger SLOW_SQL_LOGGER =
       LoggerFactory.getLogger(IoTDBConstant.SLOW_SQL_LOGGER_NAME);
@@ -142,7 +146,7 @@ public class Coordinator {
               queryContext,
               partitionFetcher,
               schemaFetcher,
-              timeOut > 0 ? timeOut : CONFIG.getQueryTimeoutThreshold(),
+              timeOut > 0 ? timeOut : COMMON_CONFIG.getQueryTimeoutThreshold(),
               startTime);
       if (execution.isQuery()) {
         queryExecutionMap.put(queryId, execution);
@@ -179,13 +183,13 @@ public class Coordinator {
   // TODO: (xingtanzjr) need to redo once we have a concrete policy for the threadPool management
   private ExecutorService getQueryExecutor() {
     int coordinatorReadExecutorSize =
-        CONFIG.isClusterMode() ? CONFIG.getCoordinatorReadExecutorSize() : 1;
+        IOTDB_CONFIG.isClusterMode() ? COMMON_CONFIG.getCoordinatorReadExecutorSize() : 1;
     return IoTDBThreadPoolFactory.newFixedThreadPool(
         coordinatorReadExecutorSize, COORDINATOR_EXECUTOR_NAME);
   }
 
   private ExecutorService getWriteExecutor() {
-    int coordinatorWriteExecutorSize = CONFIG.getCoordinatorWriteExecutorSize();
+    int coordinatorWriteExecutorSize = COMMON_CONFIG.getCoordinatorWriteExecutorSize();
     return IoTDBThreadPoolFactory.newFixedThreadPool(
         coordinatorWriteExecutorSize, COORDINATOR_WRITE_EXECUTOR_NAME);
   }
@@ -209,7 +213,7 @@ public class Coordinator {
         queryExecutionMap.remove(queryId);
         if (queryExecution.isQuery()) {
           long costTime = queryExecution.getTotalExecutionTime();
-          if (costTime >= CONFIG.getSlowQueryThreshold()) {
+          if (costTime >= COMMON_CONFIG.getSlowQueryThreshold()) {
             SLOW_SQL_LOGGER.info(
                 "Cost: {} ms, sql is {}",
                 costTime,
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/LocalExecutionPlanContext.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/LocalExecutionPlanContext.java
index 2d8e6d7051..0deed615db 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/LocalExecutionPlanContext.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/LocalExecutionPlanContext.java
@@ -18,6 +18,7 @@
  */
 package org.apache.iotdb.db.mpp.plan.planner;
 
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.metadata.schemaregion.ISchemaRegion;
 import org.apache.iotdb.db.mpp.common.FragmentInstanceId;
@@ -163,7 +164,7 @@ public class LocalExecutionPlanContext {
   }
 
   public long getMaxBytesOneHandleCanReserve() {
-    long maxBytesPerFI = IoTDBDescriptor.getInstance().getConfig().getMaxBytesPerFragmentInstance();
+    long maxBytesPerFI = CommonDescriptor.getInstance().getConfig().getMaxBytesPerFragmentInstance();
     return exchangeSumNum == 0 ? maxBytesPerFI : maxBytesPerFI / exchangeSumNum;
   }
 
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/LocalExecutionPlanner.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/LocalExecutionPlanner.java
index 231ca1d680..dd27a6f1dc 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/LocalExecutionPlanner.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/LocalExecutionPlanner.java
@@ -18,6 +18,7 @@
  */
 package org.apache.iotdb.db.mpp.plan.planner;
 
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.path.PartialPath;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.exception.query.QueryProcessException;
@@ -52,7 +53,7 @@ public class LocalExecutionPlanner {
 
   /** allocated memory for operator execution */
   private long freeMemoryForOperators =
-      IoTDBDescriptor.getInstance().getConfig().getAllocateMemoryForOperators();
+      CommonDescriptor.getInstance().getConfig().getAllocateMemoryForOperators();
 
   public static LocalExecutionPlanner getInstance() {
     return InstanceHolder.INSTANCE;
@@ -110,7 +111,7 @@ public class LocalExecutionPlanner {
       throws MemoryNotEnoughException {
 
     // if it is disabled, just return
-    if (!IoTDBDescriptor.getInstance().getConfig().isEnableQueryMemoryEstimation()) {
+    if (!CommonDescriptor.getInstance().getConfig().isEnableQueryMemoryEstimation()) {
       return;
     }
 
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/FragmentInstance.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/FragmentInstance.java
index 77db9b673d..8775865ee8 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/FragmentInstance.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/FragmentInstance.java
@@ -20,13 +20,13 @@ package org.apache.iotdb.db.mpp.plan.planner.plan;
 
 import org.apache.iotdb.common.rpc.thrift.TDataNodeLocation;
 import org.apache.iotdb.common.rpc.thrift.TRegionReplicaSet;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.exception.runtime.SerializationRunTimeException;
 import org.apache.iotdb.commons.partition.ExecutorType;
 import org.apache.iotdb.commons.utils.TestOnly;
 import org.apache.iotdb.commons.utils.ThriftCommonsSerDeUtils;
 import org.apache.iotdb.consensus.common.request.IConsensusRequest;
-import org.apache.iotdb.db.conf.IoTDBConfig;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.mpp.common.FragmentInstanceId;
 import org.apache.iotdb.db.mpp.common.SessionInfo;
 import org.apache.iotdb.db.mpp.plan.analyze.QueryType;
@@ -50,7 +50,7 @@ public class FragmentInstance implements IConsensusRequest {
 
   private final Logger logger = LoggerFactory.getLogger(FragmentInstance.class);
 
-  private static final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
 
   private final FragmentInstanceId id;
   private final QueryType type;
@@ -84,7 +84,7 @@ public class FragmentInstance implements IConsensusRequest {
     this.timeFilter = timeFilter;
     this.id = id;
     this.type = type;
-    this.timeOut = timeOut > 0 ? timeOut : config.getQueryTimeoutThreshold();
+    this.timeOut = timeOut > 0 ? timeOut : COMMON_CONFIG.getQueryTimeoutThreshold();
     this.isRoot = false;
     this.sessionInfo = sessionInfo;
   }
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/write/InsertNode.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/write/InsertNode.java
index ac63f82940..377070f3b4 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/write/InsertNode.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/write/InsertNode.java
@@ -19,6 +19,7 @@
 package org.apache.iotdb.db.mpp.plan.planner.plan.node.write;
 
 import org.apache.iotdb.common.rpc.thrift.TRegionReplicaSet;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.exception.MetadataException;
 import org.apache.iotdb.commons.path.PartialPath;
 import org.apache.iotdb.consensus.iot.wal.ConsensusReqReader;
@@ -249,7 +250,7 @@ public abstract class InsertNode extends WritePlanNode {
   /** Check whether data types are matched with measurement schemas */
   protected void selfCheckDataTypes() throws DataTypeMismatchException, PathNotExistException {
     for (int i = 0; i < measurementSchemas.length; i++) {
-      if (IoTDBDescriptor.getInstance().getConfig().isEnablePartialInsert()) {
+      if (CommonDescriptor.getInstance().getConfig().isEnablePartialInsert()) {
         // if enable partial insert, mark failed measurements with exception
         if (measurementSchemas[i] == null) {
           markFailedMeasurement(
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/write/InsertRowNode.java b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/write/InsertRowNode.java
index 36cba297e3..173ea3390d 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/write/InsertRowNode.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/plan/planner/plan/node/write/InsertRowNode.java
@@ -19,12 +19,12 @@
 package org.apache.iotdb.db.mpp.plan.planner.plan.node.write;
 
 import org.apache.iotdb.common.rpc.thrift.TTimePartitionSlot;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.conf.IoTDBConstant;
 import org.apache.iotdb.commons.exception.IllegalPathException;
 import org.apache.iotdb.commons.exception.MetadataException;
 import org.apache.iotdb.commons.path.PartialPath;
 import org.apache.iotdb.commons.utils.TestOnly;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.exception.metadata.AlignedTimeseriesException;
 import org.apache.iotdb.db.exception.metadata.PathNotExistException;
 import org.apache.iotdb.db.exception.query.QueryProcessException;
@@ -240,7 +240,7 @@ public class InsertRowNode extends InsertNode implements WALEntryValue {
     for (int i = 0; i < measurementSchemas.length; i++) {
       // null when time series doesn't exist
       if (measurementSchemas[i] == null) {
-        if (!IoTDBDescriptor.getInstance().getConfig().isEnablePartialInsert()) {
+        if (!CommonDescriptor.getInstance().getConfig().isEnablePartialInsert()) {
           throw new QueryProcessException(
               new PathNotExistException(
                   devicePath.getFullPath() + IoTDBConstant.PATH_SEPARATOR + measurements[i]));
@@ -265,7 +265,7 @@ public class InsertRowNode extends InsertNode implements WALEntryValue {
             dataTypes[i],
             time,
             values[i]);
-        if (!IoTDBDescriptor.getInstance().getConfig().isEnablePartialInsert()) {
+        if (!CommonDescriptor.getInstance().getConfig().isEnablePartialInsert()) {
           throw e;
         } else {
           markFailedMeasurement(i, e);
diff --git a/server/src/main/java/org/apache/iotdb/db/mpp/transformation/datastructure/SerializableList.java b/server/src/main/java/org/apache/iotdb/db/mpp/transformation/datastructure/SerializableList.java
index 9ab4449a69..9ebe306d58 100644
--- a/server/src/main/java/org/apache/iotdb/db/mpp/transformation/datastructure/SerializableList.java
+++ b/server/src/main/java/org/apache/iotdb/db/mpp/transformation/datastructure/SerializableList.java
@@ -19,6 +19,7 @@
 
 package org.apache.iotdb.db.mpp.transformation.datastructure;
 
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.file.SystemFileFactory;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.service.TemporaryQueryDataFileService;
@@ -32,7 +33,7 @@ import java.nio.channels.FileChannel;
 public interface SerializableList {
 
   int INITIAL_BYTE_ARRAY_LENGTH_FOR_MEMORY_CONTROL =
-      IoTDBDescriptor.getInstance().getConfig().getUdfInitialByteArrayLengthForMemoryControl();
+      CommonDescriptor.getInstance().getConfig().getUdfInitialByteArrayLengthForMemoryControl();
 
   void serialize(PublicBAOS outputStream) throws IOException;
 
diff --git a/server/src/main/java/org/apache/iotdb/db/protocol/mqtt/MPPPublishHandler.java b/server/src/main/java/org/apache/iotdb/db/protocol/mqtt/MPPPublishHandler.java
index 53d5241ef2..e688405bad 100644
--- a/server/src/main/java/org/apache/iotdb/db/protocol/mqtt/MPPPublishHandler.java
+++ b/server/src/main/java/org/apache/iotdb/db/protocol/mqtt/MPPPublishHandler.java
@@ -18,6 +18,8 @@
 package org.apache.iotdb.db.protocol.mqtt;
 
 import org.apache.iotdb.common.rpc.thrift.TSStatus;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.conf.IoTDBConstant;
 import org.apache.iotdb.commons.path.PartialPath;
 import org.apache.iotdb.db.auth.AuthorityChecker;
@@ -56,7 +58,6 @@ public class MPPPublishHandler extends AbstractInterceptHandler {
 
   private static final Logger LOG = LoggerFactory.getLogger(MPPPublishHandler.class);
 
-  private static final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
   private final SessionManager SESSION_MANAGER = SessionManager.getInstance();
 
   private final ConcurrentHashMap<String, MqttClientSession> clientIdToSessionMap =
@@ -65,7 +66,7 @@ public class MPPPublishHandler extends AbstractInterceptHandler {
   private final IPartitionFetcher partitionFetcher;
   private final ISchemaFetcher schemaFetcher;
 
-  public MPPPublishHandler(IoTDBConfig config) {
+  public MPPPublishHandler(CommonConfig config) {
     this.payloadFormat = PayloadFormatManager.getPayloadFormat(config.getMqttPayloadFormatter());
     partitionFetcher = ClusterPartitionFetcher.getInstance();
     schemaFetcher = ClusterSchemaFetcher.getInstance();
@@ -169,7 +170,7 @@ public class MPPPublishHandler extends AbstractInterceptHandler {
                       "",
                       partitionFetcher,
                       schemaFetcher,
-                      config.getQueryTimeoutThreshold());
+                      CommonDescriptor.getInstance().getConfig().getQueryTimeoutThreshold());
           tsStatus = result.status;
         }
       } catch (Exception e) {
diff --git a/server/src/main/java/org/apache/iotdb/db/rescon/MemTableManager.java b/server/src/main/java/org/apache/iotdb/db/rescon/MemTableManager.java
index 03b32e71fc..c2d862470c 100644
--- a/server/src/main/java/org/apache/iotdb/db/rescon/MemTableManager.java
+++ b/server/src/main/java/org/apache/iotdb/db/rescon/MemTableManager.java
@@ -18,6 +18,8 @@
  */
 package org.apache.iotdb.db.rescon;
 
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.db.conf.IoTDBConfig;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.engine.memtable.IMemTable;
@@ -29,7 +31,8 @@ import org.slf4j.LoggerFactory;
 
 public class MemTableManager {
 
-  private static final IoTDBConfig CONFIG = IoTDBDescriptor.getInstance().getConfig();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
+  private static final IoTDBConfig IOTDB_CONFIG = IoTDBDescriptor.getInstance().getConfig();
 
   private static final Logger logger = LoggerFactory.getLogger(MemTableManager.class);
 
@@ -45,9 +48,9 @@ public class MemTableManager {
 
   public synchronized IMemTable getAvailableMemTable(String storageGroup)
       throws WriteProcessException {
-    if (CONFIG.isEnableMemControl()) {
+    if (COMMON_CONFIG.isEnableMemControl()) {
       currentMemtableNumber++;
-      return new PrimitiveMemTable(CONFIG.isEnableMemControl());
+      return new PrimitiveMemTable(COMMON_CONFIG.isEnableMemControl());
     }
 
     if (!reachMaxMemtableNumber()) {
@@ -86,15 +89,15 @@ public class MemTableManager {
 
   /** Called when memory control is disabled */
   private boolean reachMaxMemtableNumber() {
-    return currentMemtableNumber >= CONFIG.getMaxMemtableNumber();
+    return currentMemtableNumber >= IOTDB_CONFIG.getMaxMemtableNumber();
   }
 
   /** Called when memory control is disabled */
   public synchronized void addOrDeleteStorageGroup(int diff) {
-    int maxMemTableNum = CONFIG.getMaxMemtableNumber();
+    int maxMemTableNum = IOTDB_CONFIG.getMaxMemtableNumber();
     maxMemTableNum +=
-        MEMTABLE_NUM_FOR_EACH_PARTITION * CONFIG.getConcurrentWritingTimePartition() * diff;
-    CONFIG.setMaxMemtableNumber(maxMemTableNum);
+        MEMTABLE_NUM_FOR_EACH_PARTITION * COMMON_CONFIG.getConcurrentWritingTimePartition() * diff;
+    IOTDB_CONFIG.setMaxMemtableNumber(maxMemTableNum);
     notifyAll();
   }
 
diff --git a/server/src/main/java/org/apache/iotdb/db/rescon/PrimitiveArrayManager.java b/server/src/main/java/org/apache/iotdb/db/rescon/PrimitiveArrayManager.java
index afa9e8f839..cc9f4d7e43 100644
--- a/server/src/main/java/org/apache/iotdb/db/rescon/PrimitiveArrayManager.java
+++ b/server/src/main/java/org/apache/iotdb/db/rescon/PrimitiveArrayManager.java
@@ -18,6 +18,8 @@
  */
 package org.apache.iotdb.db.rescon;
 
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.utils.datastructure.TVListSortAlgorithm;
 import org.apache.iotdb.db.conf.IoTDBConfig;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
@@ -37,11 +39,12 @@ public class PrimitiveArrayManager {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(PrimitiveArrayManager.class);
 
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
   private static final IoTDBConfig CONFIG = IoTDBDescriptor.getInstance().getConfig();
 
-  public static final int ARRAY_SIZE = CONFIG.getPrimitiveArraySize();
+  public static final int ARRAY_SIZE = COMMON_CONFIG.getPrimitiveArraySize();
 
-  public static final TVListSortAlgorithm TVLIST_SORT_ALGORITHM = CONFIG.getTvListSortAlgorithm();
+  public static final TVListSortAlgorithm TVLIST_SORT_ALGORITHM = COMMON_CONFIG.getTvListSortAlgorithm();
 
   /**
    * The actual used memory will be 50% larger than the statistic, so we need to limit the size of
@@ -51,8 +54,8 @@ public class PrimitiveArrayManager {
 
   /** threshold total size of arrays for all data types */
   private static final double POOLED_ARRAYS_MEMORY_THRESHOLD =
-      CONFIG.getAllocateMemoryForStorageEngine()
-          * CONFIG.getBufferedArraysMemoryProportion()
+    COMMON_CONFIG.getAllocateMemoryForStorageEngine()
+          * COMMON_CONFIG.getBufferedArraysMemoryProportion()
           / AMPLIFICATION_FACTOR;
 
   /** TSDataType#serialize() -> ArrayDeque<Array>, VECTOR is ignored */
diff --git a/server/src/main/java/org/apache/iotdb/db/rescon/SystemInfo.java b/server/src/main/java/org/apache/iotdb/db/rescon/SystemInfo.java
index fd0214b519..f123c9a089 100644
--- a/server/src/main/java/org/apache/iotdb/db/rescon/SystemInfo.java
+++ b/server/src/main/java/org/apache/iotdb/db/rescon/SystemInfo.java
@@ -21,6 +21,8 @@ package org.apache.iotdb.db.rescon;
 
 import org.apache.iotdb.commons.concurrent.IoTDBThreadPoolFactory;
 import org.apache.iotdb.commons.concurrent.ThreadName;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.utils.TestOnly;
 import org.apache.iotdb.db.conf.IoTDBConfig;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
@@ -40,7 +42,7 @@ import java.util.concurrent.atomic.AtomicLong;
 
 public class SystemInfo {
 
-  private static final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
   private static final Logger logger = LoggerFactory.getLogger(SystemInfo.class);
 
   private long totalStorageGroupMemCost = 0L;
@@ -55,8 +57,8 @@ public class SystemInfo {
 
   private ExecutorService flushTaskSubmitThreadPool =
       IoTDBThreadPoolFactory.newSingleThreadExecutor(ThreadName.FLUSH_TASK_SUBMIT.getName());
-  private double FLUSH_THERSHOLD = memorySizeForMemtable * config.getFlushProportion();
-  private double REJECT_THERSHOLD = memorySizeForMemtable * config.getRejectProportion();
+  private double FLUSH_THERSHOLD = memorySizeForMemtable * COMMON_CONFIG.getFlushProportion();
+  private double REJECT_THERSHOLD = memorySizeForMemtable * COMMON_CONFIG.getRejectProportion();
 
   private volatile boolean isEncodingFasterThanIo = true;
 
@@ -180,7 +182,7 @@ public class SystemInfo {
   }
 
   public void addCompactionMemoryCost(long memoryCost) throws InterruptedException {
-    if (config.isEnableMemControl()) {
+    if (COMMON_CONFIG.isEnableMemControl()) {
       long originSize = this.compactionMemoryCost.get();
       while (originSize + memoryCost > memorySizeForCompaction
           || !compactionMemoryCost.compareAndSet(originSize, originSize + memoryCost)) {
@@ -195,7 +197,7 @@ public class SystemInfo {
   }
 
   public long getMemorySizeForCompaction() {
-    if (config.isEnableMemControl()) {
+    if (COMMON_CONFIG.isEnableMemControl()) {
       return memorySizeForCompaction;
     } else {
       return Long.MAX_VALUE;
@@ -205,11 +207,11 @@ public class SystemInfo {
   public void allocateWriteMemory() {
     memorySizeForMemtable =
         (long)
-            (config.getAllocateMemoryForStorageEngine() * config.getWriteProportionForMemtable());
+            (COMMON_CONFIG.getAllocateMemoryForStorageEngine() * COMMON_CONFIG.getWriteProportionForMemtable());
     memorySizeForCompaction =
-        (long) (config.getAllocateMemoryForStorageEngine() * config.getCompactionProportion());
-    FLUSH_THERSHOLD = memorySizeForMemtable * config.getFlushProportion();
-    REJECT_THERSHOLD = memorySizeForMemtable * config.getRejectProportion();
+        (long) (COMMON_CONFIG.getAllocateMemoryForStorageEngine() * COMMON_CONFIG.getCompactionProportion());
+    FLUSH_THERSHOLD = memorySizeForMemtable * COMMON_CONFIG.getFlushProportion();
+    REJECT_THERSHOLD = memorySizeForMemtable * COMMON_CONFIG.getRejectProportion();
   }
 
   @TestOnly
@@ -291,14 +293,14 @@ public class SystemInfo {
 
   public synchronized void applyTemporaryMemoryForFlushing(long estimatedTemporaryMemSize) {
     memorySizeForMemtable -= estimatedTemporaryMemSize;
-    FLUSH_THERSHOLD = memorySizeForMemtable * config.getFlushProportion();
-    REJECT_THERSHOLD = memorySizeForMemtable * config.getRejectProportion();
+    FLUSH_THERSHOLD = memorySizeForMemtable * COMMON_CONFIG.getFlushProportion();
+    REJECT_THERSHOLD = memorySizeForMemtable * COMMON_CONFIG.getRejectProportion();
   }
 
   public synchronized void releaseTemporaryMemoryForFlushing(long estimatedTemporaryMemSize) {
     memorySizeForMemtable += estimatedTemporaryMemSize;
-    FLUSH_THERSHOLD = memorySizeForMemtable * config.getFlushProportion();
-    REJECT_THERSHOLD = memorySizeForMemtable * config.getRejectProportion();
+    FLUSH_THERSHOLD = memorySizeForMemtable * COMMON_CONFIG.getFlushProportion();
+    REJECT_THERSHOLD = memorySizeForMemtable * COMMON_CONFIG.getRejectProportion();
   }
 
   public long getTotalMemTableSize() {
diff --git a/server/src/main/java/org/apache/iotdb/db/rescon/TsFileResourceManager.java b/server/src/main/java/org/apache/iotdb/db/rescon/TsFileResourceManager.java
index b20e84216e..a83d50dd62 100644
--- a/server/src/main/java/org/apache/iotdb/db/rescon/TsFileResourceManager.java
+++ b/server/src/main/java/org/apache/iotdb/db/rescon/TsFileResourceManager.java
@@ -18,9 +18,9 @@
  */
 package org.apache.iotdb.db.rescon;
 
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.utils.TestOnly;
-import org.apache.iotdb.db.conf.IoTDBConfig;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.engine.storagegroup.TsFileResource;
 import org.apache.iotdb.db.engine.storagegroup.timeindex.TimeIndexLevel;
 
@@ -32,10 +32,10 @@ import java.util.TreeSet;
 public class TsFileResourceManager {
   private static final Logger logger = LoggerFactory.getLogger(TsFileResourceManager.class);
 
-  private static final IoTDBConfig CONFIG = IoTDBDescriptor.getInstance().getConfig();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
 
   /** threshold total memory for all TimeIndex */
-  private double TIME_INDEX_MEMORY_THRESHOLD = CONFIG.getAllocateMemoryForTimeIndex();
+  private double TIME_INDEX_MEMORY_THRESHOLD = COMMON_CONFIG.getAllocateMemoryForTimeIndex();
 
   /** store the sealed TsFileResource, sorted by priority of TimeIndex */
   private final TreeSet<TsFileResource> sealedTsFileResources =
diff --git a/server/src/main/java/org/apache/iotdb/db/service/IoTDBShutdownHook.java b/server/src/main/java/org/apache/iotdb/db/service/IoTDBShutdownHook.java
index b8ddc97d2d..f15e4406a8 100644
--- a/server/src/main/java/org/apache/iotdb/db/service/IoTDBShutdownHook.java
+++ b/server/src/main/java/org/apache/iotdb/db/service/IoTDBShutdownHook.java
@@ -60,9 +60,10 @@ public class IoTDBShutdownHook extends Thread {
     // latest snapshot, while other consensus algorithms will not. This judgement ensures that
     // compaction work is not discarded even if there are frequent restarts
     if (IoTDBDescriptor.getInstance().getConfig().isClusterMode()
-        && IoTDBDescriptor.getInstance()
+        && CommonDescriptor.getInstance()
             .getConfig()
             .getDataRegionConsensusProtocolClass()
+            .getProtocol()
             .equals(ConsensusFactory.RATIS_CONSENSUS)) {
       DataRegionConsensusImpl.getInstance()
           .getAllConsensusGroupIds()
diff --git a/server/src/main/java/org/apache/iotdb/db/service/MQTTService.java b/server/src/main/java/org/apache/iotdb/db/service/MQTTService.java
index f572a4fd28..e4e03ea5c0 100644
--- a/server/src/main/java/org/apache/iotdb/db/service/MQTTService.java
+++ b/server/src/main/java/org/apache/iotdb/db/service/MQTTService.java
@@ -18,6 +18,8 @@
  */
 package org.apache.iotdb.db.service;
 
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.service.IService;
 import org.apache.iotdb.commons.service.ServiceType;
 import org.apache.iotdb.db.conf.IoTDBConfig;
@@ -56,18 +58,18 @@ public class MQTTService implements IService {
   }
 
   public void startup() {
-    IoTDBConfig iotDBConfig = IoTDBDescriptor.getInstance().getConfig();
-    IConfig config = createBrokerConfig(iotDBConfig);
+    CommonConfig commonConfig = CommonDescriptor.getInstance().getConfig();
+    IConfig config = createBrokerConfig(commonConfig);
     List<InterceptHandler> handlers = new ArrayList<>(1);
-    handlers.add(new MPPPublishHandler(iotDBConfig));
+    handlers.add(new MPPPublishHandler(commonConfig));
     IAuthenticator authenticator = new BrokerAuthenticator();
 
     server.startServer(config, handlers, null, authenticator, null);
 
     LOG.info(
         "Start MQTT service successfully, listening on ip {} port {}",
-        iotDBConfig.getMqttHost(),
-        iotDBConfig.getMqttPort());
+      commonConfig.getMqttHost(),
+      commonConfig.getMqttPort());
 
     Runtime.getRuntime()
         .addShutdownHook(
@@ -79,20 +81,20 @@ public class MQTTService implements IService {
                 }));
   }
 
-  private IConfig createBrokerConfig(IoTDBConfig iotDBConfig) {
+  private IConfig createBrokerConfig(CommonConfig commonConfig) {
     Properties properties = new Properties();
-    properties.setProperty(BrokerConstants.HOST_PROPERTY_NAME, iotDBConfig.getMqttHost());
+    properties.setProperty(BrokerConstants.HOST_PROPERTY_NAME, commonConfig.getMqttHost());
     properties.setProperty(
-        BrokerConstants.PORT_PROPERTY_NAME, String.valueOf(iotDBConfig.getMqttPort()));
+        BrokerConstants.PORT_PROPERTY_NAME, String.valueOf(commonConfig.getMqttPort()));
     properties.setProperty(
         BrokerConstants.BROKER_INTERCEPTOR_THREAD_POOL_SIZE,
-        String.valueOf(iotDBConfig.getMqttHandlerPoolSize()));
+        String.valueOf(commonConfig.getMqttHandlerPoolSize()));
     properties.setProperty(BrokerConstants.IMMEDIATE_BUFFER_FLUSH_PROPERTY_NAME, "true");
     properties.setProperty(BrokerConstants.ALLOW_ANONYMOUS_PROPERTY_NAME, "false");
     properties.setProperty(BrokerConstants.ALLOW_ZERO_BYTE_CLIENT_ID_PROPERTY_NAME, "true");
     properties.setProperty(
         BrokerConstants.NETTY_MAX_BYTES_PROPERTY_NAME,
-        String.valueOf(iotDBConfig.getMqttMaxMessageSize()));
+        String.valueOf(commonConfig.getMqttMaxMessageSize()));
     return new MemoryConfig(properties);
   }
 
diff --git a/server/src/main/java/org/apache/iotdb/db/service/thrift/impl/ClientRPCServiceImpl.java b/server/src/main/java/org/apache/iotdb/db/service/thrift/impl/ClientRPCServiceImpl.java
index 0aa6c1968b..4a4600929e 100644
--- a/server/src/main/java/org/apache/iotdb/db/service/thrift/impl/ClientRPCServiceImpl.java
+++ b/server/src/main/java/org/apache/iotdb/db/service/thrift/impl/ClientRPCServiceImpl.java
@@ -19,6 +19,7 @@
 package org.apache.iotdb.db.service.thrift.impl;
 
 import org.apache.iotdb.common.rpc.thrift.TSStatus;
+import org.apache.iotdb.commons.conf.CommonConfig;
 import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.conf.IoTDBConstant;
 import org.apache.iotdb.commons.exception.IllegalPathException;
@@ -137,7 +138,8 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(ClientRPCServiceImpl.class);
 
-  private static final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
+  private static final IoTDBConfig IOTDB_CONFIG = IoTDBDescriptor.getInstance().getConfig();
 
   private static final Coordinator COORDINATOR = Coordinator.getInstance();
 
@@ -146,7 +148,7 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
   private static final TSProtocolVersion CURRENT_RPC_VERSION =
       TSProtocolVersion.IOTDB_SERVICE_PROTOCOL_V3;
 
-  private static final boolean enableAuditLog = config.isEnableAuditLog();
+  private static final boolean enableAuditLog = IOTDB_CONFIG.isEnableAuditLog();
 
   private final IPartitionFetcher PARTITION_FETCHER;
 
@@ -555,18 +557,12 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
     properties.setSupportedTimeAggregationOperations(new ArrayList<>());
     properties.getSupportedTimeAggregationOperations().add(IoTDBConstant.MAX_TIME);
     properties.getSupportedTimeAggregationOperations().add(IoTDBConstant.MIN_TIME);
-    properties.setTimestampPrecision(
-        IoTDBDescriptor.getInstance().getConfig().getTimestampPrecision());
-    properties.setMaxConcurrentClientNum(
-        IoTDBDescriptor.getInstance().getConfig().getDnRpcMaxConcurrentClientNum());
-    properties.setWatermarkSecretKey(
-        IoTDBDescriptor.getInstance().getConfig().getWatermarkSecretKey());
-    properties.setWatermarkBitString(
-        IoTDBDescriptor.getInstance().getConfig().getWatermarkBitString());
-    properties.setWatermarkParamMarkRate(
-        IoTDBDescriptor.getInstance().getConfig().getWatermarkParamMarkRate());
-    properties.setWatermarkParamMaxRightBit(
-        IoTDBDescriptor.getInstance().getConfig().getWatermarkParamMaxRightBit());
+    properties.setTimestampPrecision(COMMON_CONFIG.getTimestampPrecision());
+    properties.setMaxConcurrentClientNum(IOTDB_CONFIG.getDnRpcMaxConcurrentClientNum());
+    properties.setWatermarkSecretKey(COMMON_CONFIG.getWatermarkSecretKey());
+    properties.setWatermarkBitString(COMMON_CONFIG.getWatermarkBitString());
+    properties.setWatermarkParamMarkRate(COMMON_CONFIG.getWatermarkParamMarkRate());
+    properties.setWatermarkParamMaxRightBit(COMMON_CONFIG.getWatermarkParamMaxRightBit());
     properties.setIsReadOnly(CommonDescriptor.getInstance().getConfig().isReadOnly());
     properties.setThriftMaxFrameSize(
         IoTDBDescriptor.getInstance().getConfig().getDnThriftMaxFrameSize());
@@ -885,7 +881,7 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
                 statement,
                 PARTITION_FETCHER,
                 SCHEMA_FETCHER,
-                config.getQueryTimeoutThreshold());
+                COMMON_CONFIG.getQueryTimeoutThreshold());
         results.add(result.status);
       } catch (Exception e) {
         LOGGER.warn("Error occurred when executing executeBatchStatement: ", e);
@@ -1571,7 +1567,7 @@ public class ClientRPCServiceImpl implements IClientRPCServiceWithHandler {
               null,
               PARTITION_FETCHER,
               SCHEMA_FETCHER,
-              config.getQueryTimeoutThreshold());
+              COMMON_CONFIG.getQueryTimeoutThreshold());
 
       if (executionResult.status.code != TSStatusCode.SUCCESS_STATUS.getStatusCode()
           && executionResult.status.code != TSStatusCode.REDIRECTION_RECOMMEND.getStatusCode()) {
diff --git a/server/src/main/java/org/apache/iotdb/db/tools/watermark/GroupedLSBWatermarkEncoder.java b/server/src/main/java/org/apache/iotdb/db/tools/watermark/GroupedLSBWatermarkEncoder.java
index 20d8f3b9b2..5c86e4abb6 100644
--- a/server/src/main/java/org/apache/iotdb/db/tools/watermark/GroupedLSBWatermarkEncoder.java
+++ b/server/src/main/java/org/apache/iotdb/db/tools/watermark/GroupedLSBWatermarkEncoder.java
@@ -18,7 +18,7 @@
  */
 package org.apache.iotdb.db.tools.watermark;
 
-import org.apache.iotdb.db.conf.IoTDBConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
 import org.apache.iotdb.tsfile.read.common.Field;
 import org.apache.iotdb.tsfile.read.common.RowRecord;
@@ -45,10 +45,12 @@ public class GroupedLSBWatermarkEncoder implements WatermarkEncoder {
     this.groupNumber = bitString.length();
   }
 
-  public GroupedLSBWatermarkEncoder(IoTDBConfig conf) {
-    this(conf.getWatermarkSecretKey(), conf.getWatermarkBitString());
-    this.markRate = conf.getWatermarkParamMarkRate();
-    this.maxBitPosition = conf.getWatermarkParamMaxRightBit();
+  public GroupedLSBWatermarkEncoder() {
+    this(
+        CommonDescriptor.getInstance().getConfig().getWatermarkSecretKey(),
+        CommonDescriptor.getInstance().getConfig().getWatermarkBitString());
+    this.markRate = CommonDescriptor.getInstance().getConfig().getWatermarkParamMarkRate();
+    this.maxBitPosition = CommonDescriptor.getInstance().getConfig().getWatermarkParamMaxRightBit();
   }
 
   public static int hashMod(String val, Integer base) {
diff --git a/server/src/main/java/org/apache/iotdb/db/utils/DateTimeUtils.java b/server/src/main/java/org/apache/iotdb/db/utils/DateTimeUtils.java
index f7514da9ea..914058af81 100644
--- a/server/src/main/java/org/apache/iotdb/db/utils/DateTimeUtils.java
+++ b/server/src/main/java/org/apache/iotdb/db/utils/DateTimeUtils.java
@@ -18,6 +18,7 @@
  */
 package org.apache.iotdb.db.utils;
 
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.utils.TestOnly;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.query.control.SessionManager;
@@ -454,7 +455,7 @@ public class DateTimeUtils {
         str,
         toZoneOffset(zoneId),
         0,
-        IoTDBDescriptor.getInstance().getConfig().getTimestampPrecision());
+        CommonDescriptor.getInstance().getConfig().getTimestampPrecision());
   }
 
   public static long convertDatetimeStrToLong(
@@ -532,7 +533,7 @@ public class DateTimeUtils {
 
   public static long convertDurationStrToLong(long currentTime, String duration) {
     return convertDurationStrToLong(
-        currentTime, duration, IoTDBDescriptor.getInstance().getConfig().getTimestampPrecision());
+        currentTime, duration, CommonDescriptor.getInstance().getConfig().getTimestampPrecision());
   }
 
   /**
@@ -653,7 +654,7 @@ public class DateTimeUtils {
 
   public static long currentTime() {
     long startupNano = IoTDBDescriptor.getInstance().getConfig().getStartUpNanosecond();
-    String timePrecision = IoTDBDescriptor.getInstance().getConfig().getTimestampPrecision();
+    String timePrecision = CommonDescriptor.getInstance().getConfig().getTimestampPrecision();
     switch (timePrecision) {
       case "ns":
         return System.currentTimeMillis() * 1000_000 + (System.nanoTime() - startupNano) % 1000_000;
@@ -665,7 +666,7 @@ public class DateTimeUtils {
   }
 
   public static String convertLongToDate(long timestamp) {
-    String timePrecision = IoTDBDescriptor.getInstance().getConfig().getTimestampPrecision();
+    String timePrecision = CommonDescriptor.getInstance().getConfig().getTimestampPrecision();
     switch (timePrecision) {
       case "ns":
         timestamp /= 1000_000_000;
diff --git a/server/src/main/java/org/apache/iotdb/db/utils/EncodingInferenceUtils.java b/server/src/main/java/org/apache/iotdb/db/utils/EncodingInferenceUtils.java
index 745c4a79ce..1688a09dbc 100644
--- a/server/src/main/java/org/apache/iotdb/db/utils/EncodingInferenceUtils.java
+++ b/server/src/main/java/org/apache/iotdb/db/utils/EncodingInferenceUtils.java
@@ -18,8 +18,8 @@
  */
 package org.apache.iotdb.db.utils;
 
-import org.apache.iotdb.db.conf.IoTDBConfig;
-import org.apache.iotdb.db.conf.IoTDBDescriptor;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.tsfile.exception.write.UnSupportedDataTypeException;
 import org.apache.iotdb.tsfile.file.metadata.enums.TSDataType;
 import org.apache.iotdb.tsfile.file.metadata.enums.TSEncoding;
@@ -32,7 +32,7 @@ public class EncodingInferenceUtils {
 
   /** Get default encoding by dataType */
   public static TSEncoding getDefaultEncoding(TSDataType dataType) {
-    IoTDBConfig conf = IoTDBDescriptor.getInstance().getConfig();
+    CommonConfig conf = CommonDescriptor.getInstance().getConfig();
     switch (dataType) {
       case BOOLEAN:
         return conf.getDefaultBooleanEncoding();
diff --git a/server/src/main/java/org/apache/iotdb/db/wal/WALManager.java b/server/src/main/java/org/apache/iotdb/db/wal/WALManager.java
index 9593818b49..b8b7b5317b 100644
--- a/server/src/main/java/org/apache/iotdb/db/wal/WALManager.java
+++ b/server/src/main/java/org/apache/iotdb/db/wal/WALManager.java
@@ -21,6 +21,8 @@ package org.apache.iotdb.db.wal;
 import org.apache.iotdb.commons.concurrent.IoTDBThreadPoolFactory;
 import org.apache.iotdb.commons.concurrent.ThreadName;
 import org.apache.iotdb.commons.concurrent.threadpool.ScheduledExecutorUtil;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.conf.IoTDBConstant;
 import org.apache.iotdb.commons.exception.StartupException;
 import org.apache.iotdb.commons.service.IService;
@@ -51,6 +53,8 @@ import java.util.concurrent.atomic.AtomicLong;
 /** This class is used to manage and allocate wal nodes */
 public class WALManager implements IService {
   private static final Logger logger = LoggerFactory.getLogger(WALManager.class);
+
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
   private static final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
 
   /** manage all wal nodes and decide how to allocate them */
@@ -64,17 +68,23 @@ public class WALManager implements IService {
 
   private WALManager() {
     if (config.isClusterMode()
-        && config.getDataRegionConsensusProtocolClass().equals(ConsensusFactory.IOT_CONSENSUS)) {
+        && COMMON_CONFIG
+            .getDataRegionConsensusProtocolClass()
+            .getProtocol()
+            .equals(ConsensusFactory.IOT_CONSENSUS)) {
       walNodesManager = new FirstCreateStrategy();
-    } else if (config.getMaxWalNodesNum() == 0) {
+    } else if (COMMON_CONFIG.getMaxWalNodesNum() == 0) {
       walNodesManager = new ElasticStrategy();
     } else {
-      walNodesManager = new RoundRobinStrategy(config.getMaxWalNodesNum());
+      walNodesManager = new RoundRobinStrategy(COMMON_CONFIG.getMaxWalNodesNum());
     }
   }
 
   public static String getApplicantUniqueId(String storageGroupName, boolean sequence) {
-    return config.getDataRegionConsensusProtocolClass().equals(ConsensusFactory.IOT_CONSENSUS)
+    return COMMON_CONFIG
+            .getDataRegionConsensusProtocolClass()
+            .getProtocol()
+            .equals(ConsensusFactory.IOT_CONSENSUS)
         ? storageGroupName
         : storageGroupName
             + IoTDBConstant.FILE_NAME_SEPARATOR
@@ -83,7 +93,7 @@ public class WALManager implements IService {
 
   /** Apply for a wal node */
   public IWALNode applyForWALNode(String applicantUniqueId) {
-    if (config.getWalMode() == WALMode.DISABLE) {
+    if (COMMON_CONFIG.getWalMode() == WALMode.DISABLE) {
       return WALFakeNode.getSuccessInstance();
     }
 
@@ -93,9 +103,12 @@ public class WALManager implements IService {
   /** WAL node will be registered only when using iot consensus protocol */
   public void registerWALNode(
       String applicantUniqueId, String logDirectory, long startFileVersion, long startSearchIndex) {
-    if (config.getWalMode() == WALMode.DISABLE
+    if (COMMON_CONFIG.getWalMode() == WALMode.DISABLE
         || !config.isClusterMode()
-        || !config.getDataRegionConsensusProtocolClass().equals(ConsensusFactory.IOT_CONSENSUS)) {
+        || !COMMON_CONFIG
+            .getDataRegionConsensusProtocolClass()
+            .getProtocol()
+            .equals(ConsensusFactory.IOT_CONSENSUS)) {
       return;
     }
 
@@ -105,9 +118,12 @@ public class WALManager implements IService {
 
   /** WAL node will be deleted only when using iot consensus protocol */
   public void deleteWALNode(String applicantUniqueId) {
-    if (config.getWalMode() == WALMode.DISABLE
+    if (COMMON_CONFIG.getWalMode() == WALMode.DISABLE
         || !config.isClusterMode()
-        || !config.getDataRegionConsensusProtocolClass().equals(ConsensusFactory.IOT_CONSENSUS)) {
+        || !COMMON_CONFIG
+            .getDataRegionConsensusProtocolClass()
+            .getProtocol()
+            .equals(ConsensusFactory.IOT_CONSENSUS)) {
       return;
     }
 
@@ -116,13 +132,13 @@ public class WALManager implements IService {
 
   @Override
   public void start() throws StartupException {
-    if (config.getWalMode() == WALMode.DISABLE) {
+    if (COMMON_CONFIG.getWalMode() == WALMode.DISABLE) {
       return;
     }
 
     try {
       registerScheduleTask(
-          config.getDeleteWalFilesPeriodInMs(), config.getDeleteWalFilesPeriodInMs());
+          COMMON_CONFIG.getDeleteWalFilesPeriodInMs(), COMMON_CONFIG.getDeleteWalFilesPeriodInMs());
     } catch (Exception e) {
       throw new StartupException(this.getID().getName(), e.getMessage());
     }
@@ -130,7 +146,7 @@ public class WALManager implements IService {
 
   /** reboot wal delete thread to hot modify delete wal period */
   public void rebootWALDeleteThread() {
-    if (config.getWalMode() == WALMode.DISABLE) {
+    if (COMMON_CONFIG.getWalMode() == WALMode.DISABLE) {
       return;
     }
 
@@ -139,15 +155,15 @@ public class WALManager implements IService {
       shutdownThread(walDeleteThread, ThreadName.WAL_DELETE);
     }
     logger.info("Stop wal delete thread successfully, and now restart it.");
-    registerScheduleTask(0, config.getDeleteWalFilesPeriodInMs());
+    registerScheduleTask(0, COMMON_CONFIG.getDeleteWalFilesPeriodInMs());
     logger.info(
         "Reboot wal delete thread successfully, current period is {} ms",
-        config.getDeleteWalFilesPeriodInMs());
+        COMMON_CONFIG.getDeleteWalFilesPeriodInMs());
   }
 
   /** submit delete outdated wal files task and wait for result */
   public void deleteOutdatedWALFiles() {
-    if (config.getWalMode() == WALMode.DISABLE) {
+    if (COMMON_CONFIG.getWalMode() == WALMode.DISABLE) {
       return;
     }
 
@@ -174,7 +190,7 @@ public class WALManager implements IService {
 
   /** Wait until all write-ahead logs are flushed */
   public void waitAllWALFlushed() {
-    if (config.getWalMode() == WALMode.DISABLE) {
+    if (COMMON_CONFIG.getWalMode() == WALMode.DISABLE) {
       return;
     }
 
@@ -215,7 +231,7 @@ public class WALManager implements IService {
 
   @Override
   public void stop() {
-    if (config.getWalMode() == WALMode.DISABLE) {
+    if (COMMON_CONFIG.getWalMode() == WALMode.DISABLE) {
       return;
     }
 
diff --git a/server/src/main/java/org/apache/iotdb/db/wal/checkpoint/CheckpointManager.java b/server/src/main/java/org/apache/iotdb/db/wal/checkpoint/CheckpointManager.java
index 020576f9c4..8e6d4a83bb 100644
--- a/server/src/main/java/org/apache/iotdb/db/wal/checkpoint/CheckpointManager.java
+++ b/server/src/main/java/org/apache/iotdb/db/wal/checkpoint/CheckpointManager.java
@@ -18,6 +18,7 @@
  */
 package org.apache.iotdb.db.wal.checkpoint;
 
+import org.apache.iotdb.commons.conf.CommonConfig;
 import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.file.SystemFileFactory;
 import org.apache.iotdb.db.conf.IoTDBConfig;
@@ -44,6 +45,7 @@ import java.util.concurrent.locks.ReentrantLock;
 /** This class is used to manage checkpoints of one wal node */
 public class CheckpointManager implements AutoCloseable {
   private static final Logger logger = LoggerFactory.getLogger(CheckpointManager.class);
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
   private static final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
 
   /** WALNode identifier of this checkpoint manager */
@@ -260,7 +262,7 @@ public class CheckpointManager implements AutoCloseable {
   public long getTotalCostOfActiveMemTables() {
     long totalCost = 0;
 
-    if (!config.isEnableMemControl()) {
+    if (!COMMON_CONFIG.isEnableMemControl()) {
       infoLock.lock();
       try {
         totalCost = memTableId2Info.size();
diff --git a/server/src/main/java/org/apache/iotdb/db/wal/node/WALNode.java b/server/src/main/java/org/apache/iotdb/db/wal/node/WALNode.java
index 283eb56bf7..8e48dc160d 100644
--- a/server/src/main/java/org/apache/iotdb/db/wal/node/WALNode.java
+++ b/server/src/main/java/org/apache/iotdb/db/wal/node/WALNode.java
@@ -18,6 +18,8 @@
  */
 package org.apache.iotdb.db.wal.node;
 
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.conf.IoTDBConstant;
 import org.apache.iotdb.commons.consensus.DataRegionId;
 import org.apache.iotdb.commons.file.SystemFileFactory;
@@ -78,6 +80,7 @@ import java.util.regex.Pattern;
  */
 public class WALNode implements IWALNode {
   private static final Logger logger = LoggerFactory.getLogger(WALNode.class);
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
   private static final IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
   /** no iot consensus, all insert nodes can be safely deleted */
   public static final long DEFAULT_SAFELY_DELETED_SEARCH_INDEX = Long.MAX_VALUE;
@@ -162,7 +165,7 @@ public class WALNode implements IWALNode {
     // remove snapshot info
     memTableSnapshotCount.remove(memTable.getMemTableId());
     // update cost info
-    long cost = config.isEnableMemControl() ? memTable.getTVListsRamCost() : 1;
+    long cost = COMMON_CONFIG.isEnableMemControl() ? memTable.getTVListsRamCost() : 1;
     long currentWALFileVersion = buffer.getCurrentWALFileVersion();
     walFileVersionId2MemTablesTotalCost.compute(
         currentWALFileVersion, (k, v) -> v == null ? cost : v + cost);
@@ -238,14 +241,14 @@ public class WALNode implements IWALNode {
       // effective information ratio is too small
       // update first valid version id by snapshotting or flushing memTable,
       // then delete old .wal files again
-      if (effectiveInfoRatio < config.getWalMinEffectiveInfoRatio()) {
+      if (effectiveInfoRatio < COMMON_CONFIG.getWalMinEffectiveInfoRatio()) {
         logger.info(
             "Effective information ratio {} (active memTables cost is {}, flushed memTables cost is {}) of wal node-{} is below wal min effective info ratio {}, some memTables will be snapshot or flushed.",
             effectiveInfoRatio,
             costOfActiveMemTables,
             costOfFlushedMemTables,
             identifier,
-            config.getWalMinEffectiveInfoRatio());
+            COMMON_CONFIG.getWalMinEffectiveInfoRatio());
         if (snapshotOrFlushMemTable() && recursionTime < MAX_RECURSION_TIME) {
           // wal is used to search, cannot optimize files deletion
           if (safelyDeletedSearchIndex != DEFAULT_SAFELY_DELETED_SEARCH_INDEX) {
@@ -352,8 +355,8 @@ public class WALNode implements IWALNode {
       int snapshotCount = memTableSnapshotCount.getOrDefault(oldestMemTable.getMemTableId(), 0);
       if (TsFileUtils.getTimePartition(new File(oldestMemTableInfo.getTsFilePath()))
               < dataRegion.getLatestTimePartition()
-          || snapshotCount >= config.getMaxWalMemTableSnapshotNum()
-          || oldestMemTable.getTVListsRamCost() > config.getWalMemTableSnapshotThreshold()) {
+          || snapshotCount >= COMMON_CONFIG.getMaxWalMemTableSnapshotNum()
+          || oldestMemTable.getTVListsRamCost() > COMMON_CONFIG.getWalMemTableSnapshotThreshold()) {
         flushMemTable(dataRegion, oldestTsFile, oldestMemTable);
       } else {
         snapshotMemTable(dataRegion, oldestTsFile, oldestMemTableInfo);
diff --git a/server/src/test/java/org/apache/iotdb/db/engine/storagegroup/TimePartitionManagerTest.java b/server/src/test/java/org/apache/iotdb/db/engine/storagegroup/TimePartitionManagerTest.java
index 1b5f1f15b2..94088940c2 100644
--- a/server/src/test/java/org/apache/iotdb/db/engine/storagegroup/TimePartitionManagerTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/engine/storagegroup/TimePartitionManagerTest.java
@@ -19,6 +19,8 @@
 
 package org.apache.iotdb.db.engine.storagegroup;
 
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.consensus.DataRegionId;
 import org.apache.iotdb.commons.exception.MetadataException;
 import org.apache.iotdb.db.conf.IoTDBConfig;
@@ -41,14 +43,14 @@ import static org.junit.Assert.assertTrue;
 public class TimePartitionManagerTest {
 
   private final TimePartitionManager timePartitionManager = TimePartitionManager.getInstance();
-  private static final IoTDBConfig CONFIG = IoTDBDescriptor.getInstance().getConfig();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
   private long prevTimePartitionInfoMemoryThreshold;
 
   public TimePartitionManagerTest() throws QueryProcessException {}
 
   @Before
   public void setUp() throws IOException, WriteProcessException, MetadataException {
-    prevTimePartitionInfoMemoryThreshold = CONFIG.getAllocateMemoryForTimePartitionInfo();
+    prevTimePartitionInfoMemoryThreshold = COMMON_CONFIG.getAllocateMemoryForTimePartitionInfo();
     timePartitionManager.setTimePartitionInfoMemoryThreshold(100L);
   }
 
diff --git a/server/src/test/java/org/apache/iotdb/db/mpp/execution/exchange/SourceHandleTest.java b/server/src/test/java/org/apache/iotdb/db/mpp/execution/exchange/SourceHandleTest.java
index 04a9dc8d16..ef4ae38cba 100644
--- a/server/src/test/java/org/apache/iotdb/db/mpp/execution/exchange/SourceHandleTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/mpp/execution/exchange/SourceHandleTest.java
@@ -23,6 +23,7 @@ import org.apache.iotdb.common.rpc.thrift.TEndPoint;
 import org.apache.iotdb.commons.client.IClientManager;
 import org.apache.iotdb.commons.client.exception.ClientManagerException;
 import org.apache.iotdb.commons.client.sync.SyncDataNodeMPPDataExchangeServiceClient;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.mpp.execution.exchange.MPPDataExchangeManager.SourceHandleListener;
 import org.apache.iotdb.db.mpp.execution.memory.LocalMemoryManager;
@@ -55,13 +56,13 @@ public class SourceHandleTest {
 
   @BeforeClass
   public static void beforeClass() {
-    maxBytesPerFI = IoTDBDescriptor.getInstance().getConfig().getMaxBytesPerFragmentInstance();
-    IoTDBDescriptor.getInstance().getConfig().setMaxBytesPerFragmentInstance(5 * MOCK_TSBLOCK_SIZE);
+    maxBytesPerFI = CommonDescriptor.getInstance().getConfig().getMaxBytesPerFragmentInstance();
+    CommonDescriptor.getInstance().getConfig().setMaxBytesPerFragmentInstance(5 * MOCK_TSBLOCK_SIZE);
   }
 
   @AfterClass
   public static void afterClass() {
-    IoTDBDescriptor.getInstance().getConfig().setMaxBytesPerFragmentInstance(maxBytesPerFI);
+    CommonDescriptor.getInstance().getConfig().setMaxBytesPerFragmentInstance(maxBytesPerFI);
   }
 
   @Test
@@ -237,7 +238,7 @@ public class SourceHandleTest {
     long maxBytesCanReserve =
         Math.min(
             5 * MOCK_TSBLOCK_SIZE,
-            IoTDBDescriptor.getInstance().getConfig().getMaxBytesPerFragmentInstance());
+            CommonDescriptor.getInstance().getConfig().getMaxBytesPerFragmentInstance());
     sourceHandle.setMaxBytesCanReserve(maxBytesCanReserve);
     Assert.assertFalse(sourceHandle.isBlocked().isDone());
     Assert.assertFalse(sourceHandle.isAborted());
diff --git a/server/src/test/java/org/apache/iotdb/db/rescon/ResourceManagerTest.java b/server/src/test/java/org/apache/iotdb/db/rescon/ResourceManagerTest.java
index c16cd691a3..a22b113da0 100644
--- a/server/src/test/java/org/apache/iotdb/db/rescon/ResourceManagerTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/rescon/ResourceManagerTest.java
@@ -18,6 +18,8 @@
  */
 package org.apache.iotdb.db.rescon;
 
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.commons.conf.IoTDBConstant;
 import org.apache.iotdb.commons.exception.MetadataException;
 import org.apache.iotdb.db.conf.IoTDBConfig;
@@ -70,15 +72,16 @@ public class ResourceManagerTest {
   List<TsFileResource> seqResources = new ArrayList<>();
   List<TsFileResource> unseqResources = new ArrayList<>();
 
-  private static final IoTDBConfig CONFIG = IoTDBDescriptor.getInstance().getConfig();
+  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
+  private static final IoTDBConfig IOTDB_CONFIG = IoTDBDescriptor.getInstance().getConfig();
   private final TsFileResourceManager tsFileResourceManager = TsFileResourceManager.getInstance();
   private long prevTimeIndexMemoryThreshold;
   private TimeIndexLevel timeIndexLevel;
 
   @Before
   public void setUp() throws IOException, WriteProcessException, MetadataException {
-    prevTimeIndexMemoryThreshold = CONFIG.getAllocateMemoryForTimeIndex();
-    timeIndexLevel = CONFIG.getTimeIndexLevel();
+    prevTimeIndexMemoryThreshold = COMMON_CONFIG.getAllocateMemoryForTimeIndex();
+    timeIndexLevel = IOTDB_CONFIG.getTimeIndexLevel();
     prepareSeries();
   }
 
@@ -87,7 +90,7 @@ public class ResourceManagerTest {
     removeFiles();
     seqResources.clear();
     unseqResources.clear();
-    CONFIG.setTimeIndexLevel(String.valueOf(timeIndexLevel));
+    IOTDB_CONFIG.setTimeIndexLevel(String.valueOf(timeIndexLevel));
     tsFileResourceManager.setTimeIndexMemoryThreshold(prevTimeIndexMemoryThreshold);
     ChunkCache.getInstance().clear();
     TimeSeriesMetadataCache.getInstance().clear();
diff --git a/server/src/test/java/org/apache/iotdb/db/utils/datastructure/PrimitiveArrayManagerTest.java b/server/src/test/java/org/apache/iotdb/db/utils/datastructure/PrimitiveArrayManagerTest.java
index 9fa7c57a57..839b5a3547 100644
--- a/server/src/test/java/org/apache/iotdb/db/utils/datastructure/PrimitiveArrayManagerTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/utils/datastructure/PrimitiveArrayManagerTest.java
@@ -19,6 +19,8 @@
 
 package org.apache.iotdb.db.utils.datastructure;
 
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.CommonDescriptor;
 import org.apache.iotdb.db.conf.IoTDBConfig;
 import org.apache.iotdb.db.conf.IoTDBDescriptor;
 import org.apache.iotdb.db.rescon.PrimitiveArrayManager;
@@ -27,24 +29,24 @@ import org.junit.Assert;
 import org.junit.Test;
 
 public class PrimitiveArrayManagerTest {
-  private IoTDBConfig config = IoTDBDescriptor.getInstance().getConfig();
+  private CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
 
   @Test
   public void testGetArrayRowCount() {
 
     Assert.assertEquals(
         1224827,
-        PrimitiveArrayManager.getArrayRowCount(1224826 * config.getPrimitiveArraySize() + 1));
+        PrimitiveArrayManager.getArrayRowCount(1224826 * COMMON_CONFIG.getPrimitiveArraySize() + 1));
 
     Assert.assertEquals(
-        1224826, PrimitiveArrayManager.getArrayRowCount(1224826 * config.getPrimitiveArraySize()));
+        1224826, PrimitiveArrayManager.getArrayRowCount(1224826 * COMMON_CONFIG.getPrimitiveArraySize()));
 
-    Assert.assertEquals(1, PrimitiveArrayManager.getArrayRowCount(config.getPrimitiveArraySize()));
+    Assert.assertEquals(1, PrimitiveArrayManager.getArrayRowCount(COMMON_CONFIG.getPrimitiveArraySize()));
 
     Assert.assertEquals(
-        1, PrimitiveArrayManager.getArrayRowCount(config.getPrimitiveArraySize() - 1));
+        1, PrimitiveArrayManager.getArrayRowCount(COMMON_CONFIG.getPrimitiveArraySize() - 1));
 
     Assert.assertEquals(
-        2, PrimitiveArrayManager.getArrayRowCount(config.getPrimitiveArraySize() + 1));
+        2, PrimitiveArrayManager.getArrayRowCount(COMMON_CONFIG.getPrimitiveArraySize() + 1));
   }
 }


[iotdb] 02/02: Merge branch 'master' into Move-ConfigNodeConfig-into-CommonConfig

Posted by yo...@apache.org.
This is an automated email from the ASF dual-hosted git repository.

yongzao pushed a commit to branch Move-ConfigNodeConfig-into-CommonConfig
in repository https://gitbox.apache.org/repos/asf/iotdb.git

commit 6b8c7295e672b812033fc8495ae75674fadf2f6d
Merge: ff1991cb17 0308ab6cab
Author: YongzaoDan <53...@qq.com>
AuthorDate: Thu Jan 12 22:16:20 2023 +0800

    Merge branch 'master' into Move-ConfigNodeConfig-into-CommonConfig

 .../confignode/manager/ClusterSchemaManager.java   |    79 +-
 .../manager/ClusterSchemaManagerTest.java          |    32 +-
 .../apache/iotdb/consensus/iot/IoTConsensus.java   |     1 +
 .../consensus/iot/IoTConsensusServerImpl.java      |    86 +-
 .../consensus/iot/IoTConsensusServerMetrics.java   |     2 +-
 .../consensus/iot/logdispatcher/LogDispatcher.java |     2 +-
 .../service/IoTConsensusRPCServiceProcessor.java   |     2 +-
 .../apache/iotdb/consensus/iot/ReplicateTest.java  |    32 +-
 .../apache/iotdb/consensus/iot/StabilityTest.java  |    55 +-
 docs/UserGuide/API/Programming-MQTT.md             |     6 +-
 .../UserGuide/Ecosystem-Integration/Flink-IoTDB.md |     3 +-
 .../Apache-IoTDB-DataNode-Dashboard.json           | 15015 +++++++++++++++----
 docs/UserGuide/Monitor-Alert/Metric-Tool.md        |    31 +
 docs/zh/UserGuide/API/Programming-MQTT.md          |     6 +-
 .../UserGuide/Ecosystem-Integration/Flink-IoTDB.md |     8 +-
 docs/zh/UserGuide/Monitor-Alert/Metric-Tool.md     |    31 +
 .../org/apache/iotdb/flink/FlinkIoTDBSink.java     |     2 +-
 .../apache/iotdb/it/env/cluster/AbstractEnv.java   |    64 +-
 .../iotdb/it/env/cluster/AbstractNodeWrapper.java  |     7 -
 .../iotdb/it/env/remote/RemoteServerEnv.java       |     7 +
 .../java/org/apache/iotdb/itbase/env/BaseEnv.java  |    13 +
 .../apache/iotdb/itbase/env/BaseNodeWrapper.java   |     2 -
 .../it/cluster/IoTDBClusterNodeErrorStartUpIT.java |    60 +-
 .../load/IoTDBClusterRegionLeaderBalancingIT.java  |    28 +-
 .../it/partition/IoTDBPartitionDurableIT.java      |    24 +-
 .../iotdb/metrics/AbstractMetricService.java       |     9 +-
 .../resources/conf/iotdb-common.properties         |     2 +-
 .../commons/schema/tree/AbstractTreeVisitor.java   |     2 +-
 .../resources/tools/tsfile/settle-tsfile.bat       |    62 +
 .../resources/tools/tsfile/settle-tsfile.sh        |    48 +
 .../execute/utils/reader/PointPriorityReader.java  |    14 +-
 .../db/engine/settle/SettleRequestHandler.java     |   323 +
 .../db/metadata/mtree/MTreeBelowSGCachedImpl.java  |    30 +
 .../db/metadata/mtree/MTreeBelowSGMemoryImpl.java  |    30 +
 .../mtree/store/disk/schemafile/SchemaFile.java    |    21 +-
 .../disk/schemafile/pagemgr/BTreePageManager.java  |     5 +-
 .../store/disk/schemafile/pagemgr/PageManager.java |    17 +-
 .../traverser/TraverserWithLimitOffsetWrapper.java |    10 +
 .../db/metadata/query/reader/ISchemaReader.java    |    16 +-
 .../schemaregion/SchemaRegionMemoryImpl.java       |    10 +
 .../schemaregion/SchemaRegionSchemaFileImpl.java   |    10 +
 .../schema/CountGroupByLevelScanOperator.java      |     3 +
 .../operator/schema/SchemaCountOperator.java       |     3 +
 .../operator/schema/SchemaQueryScanOperator.java   |     3 +
 .../schema/source/PathsUsingTemplateSource.java    |    26 +
 .../AbstractSeriesAggregationScanOperator.java     |     8 +-
 .../db/mpp/execution/schedule/DriverScheduler.java |    32 +-
 .../mpp/execution/schedule/DriverTaskThread.java   |     8 +-
 .../mpp/execution/schedule/ExecutionContext.java   |    10 +
 .../mpp/execution/schedule/IDriverScheduler.java   |     3 +-
 .../queue/multilevelqueue/DriverTaskHandle.java    |    92 +
 .../multilevelqueue/MultilevelPriorityQueue.java   |   290 +
 .../schedule/queue/multilevelqueue/Priority.java   |    73 +
 .../db/mpp/execution/schedule/task/DriverTask.java |    71 +-
 .../impl/DataNodeInternalRPCServiceImpl.java       |     7 +
 .../tools/settle/TsFileSettleByCompactionTool.java |   123 +
 .../compaction/FastAlignedCrossCompactionTest.java |   134 +
 .../FastNonAlignedCrossCompactionTest.java         |   138 +
 .../db/engine/settle/SettleRequestHandlerTest.java |   162 +
 .../mpp/execution/operator/OperatorMemoryTest.java |    35 +-
 .../schema/CountGroupByLevelMergeOperatorTest.java |    95 +-
 .../operator/schema/SchemaCountOperatorTest.java   |    88 +-
 .../operator/schema/SchemaOperatorTestUtil.java    |    66 +
 .../schema/SchemaQueryScanOperatorTest.java        |    79 +-
 .../schedule/DefaultDriverSchedulerTest.java       |    87 +-
 .../DriverTaskTimeoutSentinelThreadTest.java       |    18 +-
 thrift-commons/src/main/thrift/common.thrift       |     4 +
 thrift/src/main/thrift/datanode.thrift             |     2 +
 68 files changed, 14384 insertions(+), 3483 deletions(-)

diff --cc confignode/src/main/java/org/apache/iotdb/confignode/manager/ClusterSchemaManager.java
index ac82a02b76,6259a753f4..6f42d68514
--- a/confignode/src/main/java/org/apache/iotdb/confignode/manager/ClusterSchemaManager.java
+++ b/confignode/src/main/java/org/apache/iotdb/confignode/manager/ClusterSchemaManager.java
@@@ -101,11 -99,9 +101,9 @@@ public class ClusterSchemaManager 
  
    private static final Logger LOGGER = LoggerFactory.getLogger(ClusterSchemaManager.class);
  
 -  private static final ConfigNodeConfig CONF = ConfigNodeDescriptor.getInstance().getConf();
 -  private static final double SCHEMA_REGION_PER_DATA_NODE = CONF.getSchemaRegionPerDataNode();
 -  private static final double DATA_REGION_PER_PROCESSOR = CONF.getDataRegionPerProcessor();
 +  private static final CommonConfig COMMON_CONFIG = CommonDescriptor.getInstance().getConfig();
-   private static final int LEAST_SCHEMA_REGION_GROUP_NUM = COMMON_CONFIG.getLeastSchemaRegionGroupNum();
 +  private static final double SCHEMA_REGION_PER_DATA_NODE = COMMON_CONFIG.getSchemaRegionPerDataNode();
-   private static final int LEAST_DATA_REGION_GROUP_NUM = COMMON_CONFIG.getLeastDataRegionGroupNum();
 +  private static final double DATA_REGION_PER_PROCESSOR = COMMON_CONFIG.getDataRegionPerProcessor();
  
    private final IManager configManager;
    private final ClusterSchemaInfo clusterSchemaInfo;
diff --cc server/src/main/java/org/apache/iotdb/db/service/thrift/impl/DataNodeInternalRPCServiceImpl.java
index 9d8a215928,a44774faa4..5740a12226
--- a/server/src/main/java/org/apache/iotdb/db/service/thrift/impl/DataNodeInternalRPCServiceImpl.java
+++ b/server/src/main/java/org/apache/iotdb/db/service/thrift/impl/DataNodeInternalRPCServiceImpl.java
@@@ -59,7 -60,9 +60,8 @@@ import org.apache.iotdb.db.engine.Stora
  import org.apache.iotdb.db.engine.cache.BloomFilterCache;
  import org.apache.iotdb.db.engine.cache.ChunkCache;
  import org.apache.iotdb.db.engine.cache.TimeSeriesMetadataCache;
+ import org.apache.iotdb.db.engine.settle.SettleRequestHandler;
  import org.apache.iotdb.db.exception.StorageEngineException;
 -import org.apache.iotdb.db.exception.query.QueryProcessException;
  import org.apache.iotdb.db.metadata.cache.DataNodeSchemaCache;
  import org.apache.iotdb.db.metadata.schemaregion.ISchemaRegion;
  import org.apache.iotdb.db.metadata.schemaregion.SchemaEngine;