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

CRZbulabula pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/iotdb.git


The following commit(s) were added to refs/heads/master by this push:
     new a4568b6e90c Reject RegionGroup policy hot reload on mixed-version 
ConfigNodes (#19204)
a4568b6e90c is described below

commit a4568b6e90c984ecbf7531679473eaf6ae983b7e
Author: d-wang-commit <[email protected]>
AuthorDate: Tue Nov 10 22:52:43 2026 +0800

    Reject RegionGroup policy hot reload on mixed-version ConfigNodes (#19204)
    
    Check registered ConfigNode versions and builds before applying either 
policy.
    Keep internal follower application and unrelated configuration updates 
unchanged.
---
 .../iotdb/confignode/i18n/ConfigNodeMessages.java  |   4 +
 .../iotdb/confignode/i18n/ConfigNodeMessages.java  |   3 +
 .../iotdb/confignode/manager/ConfigManager.java    |  22 ++
 .../iotdb/confignode/manager/node/NodeManager.java |  31 +++
 .../ConfigManagerRegionGroupPolicyVersionTest.java | 280 +++++++++++++++++++++
 .../node/NodeManagerVersionConsistencyTest.java    | 178 +++++++++++++
 6 files changed, 518 insertions(+)

diff --git 
a/iotdb-core/confignode/src/main/i18n/en/org/apache/iotdb/confignode/i18n/ConfigNodeMessages.java
 
b/iotdb-core/confignode/src/main/i18n/en/org/apache/iotdb/confignode/i18n/ConfigNodeMessages.java
index d9a319039bf..cb272a86815 100644
--- 
a/iotdb-core/confignode/src/main/i18n/en/org/apache/iotdb/confignode/i18n/ConfigNodeMessages.java
+++ 
b/iotdb-core/confignode/src/main/i18n/en/org/apache/iotdb/confignode/i18n/ConfigNodeMessages.java
@@ -838,4 +838,8 @@ public final class ConfigNodeMessages {
       "Get error when serialize pattern tree.";
 
   public static final String EXCEPTION_NO_SUCH_USER_9F8AB2B7 = "No such user : 
";
+
+  public static final String
+      
EXCEPTION_REGIONGROUP_POLICY_HOT_RELOAD_REQUIRES_IDENTICAL_CONFIGNODE_VERSIONS_AND_BUILDS_FA3BBFEA
 =
+          "RegionGroup policy hot reload requires identical ConfigNode 
versions and builds.";
 }
diff --git 
a/iotdb-core/confignode/src/main/i18n/zh/org/apache/iotdb/confignode/i18n/ConfigNodeMessages.java
 
b/iotdb-core/confignode/src/main/i18n/zh/org/apache/iotdb/confignode/i18n/ConfigNodeMessages.java
index bd5803f32f3..83417ab1968 100644
--- 
a/iotdb-core/confignode/src/main/i18n/zh/org/apache/iotdb/confignode/i18n/ConfigNodeMessages.java
+++ 
b/iotdb-core/confignode/src/main/i18n/zh/org/apache/iotdb/confignode/i18n/ConfigNodeMessages.java
@@ -868,4 +868,7 @@ public final class ConfigNodeMessages {
       "序列化模式树时发生错误。";
 
   public static final String EXCEPTION_NO_SUCH_USER_9F8AB2B7 = "用户不存在:";
+  public static final String
+      
EXCEPTION_REGIONGROUP_POLICY_HOT_RELOAD_REQUIRES_IDENTICAL_CONFIGNODE_VERSIONS_AND_BUILDS_FA3BBFEA
 =
+          "RegionGroup 策略热更新要求所有 ConfigNode 的版本及构建信息一致。";
 }
diff --git 
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/manager/ConfigManager.java
 
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/manager/ConfigManager.java
index 7659475d841..cb9dab67bc6 100644
--- 
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/manager/ConfigManager.java
+++ 
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/manager/ConfigManager.java
@@ -115,6 +115,7 @@ import 
org.apache.iotdb.confignode.consensus.response.partition.SchemaPartitionR
 import 
org.apache.iotdb.confignode.consensus.response.template.TemplateSetInfoResp;
 import org.apache.iotdb.confignode.consensus.response.ttl.ShowTTLResp;
 import 
org.apache.iotdb.confignode.consensus.statemachine.ConfigRegionStateMachine;
+import org.apache.iotdb.confignode.i18n.ConfigNodeMessages;
 import org.apache.iotdb.confignode.i18n.ManagerMessages;
 import org.apache.iotdb.confignode.manager.consensus.ConsensusManager;
 import org.apache.iotdb.confignode.manager.cq.CQManager;
@@ -1899,6 +1900,10 @@ public class ConfigManager implements IManager {
     if (currentNodeId == req.getNodeId()
         || req.getNodeId() < 0
         || req.getNodeId() == NodeManager.APPLY_CONFIG_LOCALLY) {
+      TSStatus regionGroupPolicyStatus = checkRegionGroupPolicyHotReload(req);
+      if (regionGroupPolicyStatus != null) {
+        return regionGroupPolicyStatus;
+      }
       URL url = 
ConfigNodeDescriptor.getPropsUrl(CommonConfig.SYSTEM_CONFIG_NAME);
       boolean configurationFileFound = (url != null && new 
File(url.getFile()).exists());
       TrimProperties properties = new TrimProperties();
@@ -1961,6 +1966,23 @@ public class ConfigManager implements IManager {
     return RpcUtils.squashResponseStatusList(statusList);
   }
 
+  private TSStatus checkRegionGroupPolicyHotReload(TSetConfigurationReq req) {
+    if (req.getNodeId() == NodeManager.APPLY_CONFIG_LOCALLY
+        || 
(!req.getConfigs().containsKey("schema_region_group_extension_policy")
+            && 
!req.getConfigs().containsKey("data_region_group_extension_policy"))) {
+      return null;
+    }
+    if (!getNodeManager()
+        .isConfigNodeVersionConsistentWith(
+            new TNodeVersionInfo(IoTDBConstant.VERSION, 
IoTDBConstant.BUILD_INFO))) {
+      return RpcUtils.getStatus(
+          TSStatusCode.EXECUTE_STATEMENT_ERROR,
+          ConfigNodeMessages
+              
.EXCEPTION_REGIONGROUP_POLICY_HOT_RELOAD_REQUIRES_IDENTICAL_CONFIGNODE_VERSIONS_AND_BUILDS_FA3BBFEA);
+    }
+    return null;
+  }
+
   private TSStatus 
checkConsistentClusterConfigSetConfigurationTarget(TSetConfigurationReq req) {
     if (req.getNodeId() == NodeManager.APPLY_CONFIG_LOCALLY) {
       if (getConsensusManager() != null && !getConsensusManager().isLeader()) {
diff --git 
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/manager/node/NodeManager.java
 
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/manager/node/NodeManager.java
index 72ab9728af6..9e3830eaa13 100644
--- 
a/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/manager/node/NodeManager.java
+++ 
b/iotdb-core/confignode/src/main/java/org/apache/iotdb/confignode/manager/node/NodeManager.java
@@ -885,6 +885,37 @@ public class NodeManager {
     return nodeInfo.getNodeVersionInfo();
   }
 
+  /** Checks the version and build of every registered ConfigNode. */
+  public boolean isConfigNodeVersionConsistentWith(TNodeVersionInfo 
expectedVersion) {
+    if (expectedVersion == null
+        || !isKnownVersionValue(expectedVersion.getVersion())
+        || !isKnownVersionValue(expectedVersion.getBuildInfo())) {
+      return false;
+    }
+    List<TConfigNodeLocation> configNodes = getRegisteredConfigNodes();
+    if (configNodes.isEmpty()) {
+      return false;
+    }
+    Map<Integer, TNodeVersionInfo> versions = getNodeVersionInfo();
+    for (TConfigNodeLocation configNode : configNodes) {
+      if (!hasMatchingVersion(expectedVersion, 
versions.get(configNode.getConfigNodeId()))) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private static boolean hasMatchingVersion(
+      TNodeVersionInfo expectedVersion, TNodeVersionInfo actualVersion) {
+    return actualVersion != null
+        && expectedVersion.getVersion().equals(actualVersion.getVersion())
+        && expectedVersion.getBuildInfo().equals(actualVersion.getBuildInfo());
+  }
+
+  private static boolean isKnownVersionValue(String value) {
+    return value != null && !value.trim().isEmpty() && 
!"UNKNOWN".equalsIgnoreCase(value.trim());
+  }
+
   public List<TConfigNodeInfo> getRegisteredConfigNodeInfoList() {
     List<TConfigNodeInfo> configNodeInfoList = new ArrayList<>();
     List<TConfigNodeLocation> registeredConfigNodes = 
this.getRegisteredConfigNodes();
diff --git 
a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/manager/ConfigManagerRegionGroupPolicyVersionTest.java
 
b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/manager/ConfigManagerRegionGroupPolicyVersionTest.java
new file mode 100644
index 00000000000..dd4ad5d78d3
--- /dev/null
+++ 
b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/manager/ConfigManagerRegionGroupPolicyVersionTest.java
@@ -0,0 +1,280 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.iotdb.confignode.manager;
+
+import org.apache.iotdb.common.rpc.thrift.TSStatus;
+import org.apache.iotdb.common.rpc.thrift.TSetConfigurationReq;
+import org.apache.iotdb.commons.conf.CommonConfig;
+import org.apache.iotdb.commons.conf.ConfigurationFileUtils;
+import org.apache.iotdb.commons.conf.IoTDBConstant;
+import org.apache.iotdb.confignode.conf.ConfigNodeConfig;
+import org.apache.iotdb.confignode.conf.ConfigNodeConstant;
+import org.apache.iotdb.confignode.conf.ConfigNodeDescriptor;
+import org.apache.iotdb.confignode.i18n.ConfigNodeMessages;
+import org.apache.iotdb.confignode.manager.consensus.ConsensusManager;
+import org.apache.iotdb.confignode.manager.load.LoadManager;
+import org.apache.iotdb.confignode.manager.node.NodeManager;
+import 
org.apache.iotdb.confignode.manager.partition.RegionGroupExtensionPolicy;
+import org.apache.iotdb.confignode.manager.schema.ClusterSchemaManager;
+import org.apache.iotdb.confignode.rpc.thrift.TNodeVersionInfo;
+import org.apache.iotdb.rpc.TSStatusCode;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.Reader;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
+public class ConfigManagerRegionGroupPolicyVersionTest {
+
+  private static final ConfigNodeConfig CONF = 
ConfigNodeDescriptor.getInstance().getConf();
+  private static final String DATA_POLICY_KEY = 
"data_region_group_extension_policy";
+  private static final TNodeVersionInfo LOCAL_VERSION =
+      new TNodeVersionInfo(IoTDBConstant.VERSION, IoTDBConstant.BUILD_INFO);
+
+  @Rule public final TemporaryFolder temporaryFolder = new TemporaryFolder();
+
+  private ConfigManager manager;
+  private NodeManager nodeManager;
+  private ConsensusManager consensusManager;
+  private LoadManager loadManager;
+  private ClusterSchemaManager schemaManager;
+  private File configurationFile;
+  private byte[] originalFileContent;
+  private String originalConfigurationPath;
+  private int originalNodeId;
+  private RegionGroupExtensionPolicy originalSchemaPolicy;
+  private RegionGroupExtensionPolicy originalDataPolicy;
+  private String originalReadConsistency;
+  private String originalClusterName;
+  private Map<String, String> originalAppliedProperties;
+
+  @Before
+  public void setUp() throws IOException {
+    originalConfigurationPath = 
System.getProperty(ConfigNodeConstant.CONFIGNODE_CONF);
+    originalNodeId = CONF.getConfigNodeId();
+    originalSchemaPolicy = CONF.getSchemaRegionGroupExtensionPolicy();
+    originalDataPolicy = CONF.getDataRegionGroupExtensionPolicy();
+    originalReadConsistency = CONF.getReadConsistencyLevel();
+    originalClusterName = CONF.getClusterName();
+    originalAppliedProperties = new 
HashMap<>(ConfigurationFileUtils.getAppliedProperties());
+    CONF.setConfigNodeId(0);
+    File configurationDirectory = temporaryFolder.newFolder();
+    configurationFile = new File(configurationDirectory, 
CommonConfig.SYSTEM_CONFIG_NAME);
+    Files.writeString(
+        configurationFile.toPath(),
+        "schema_region_group_extension_policy="
+            + originalSchemaPolicy.getPolicy()
+            + "\n"
+            + DATA_POLICY_KEY
+            + "="
+            + originalDataPolicy.getPolicy()
+            + "\nread_consistency_level="
+            + originalReadConsistency
+            + "\n",
+        StandardCharsets.UTF_8);
+    originalFileContent = Files.readAllBytes(configurationFile.toPath());
+    System.setProperty(
+        ConfigNodeConstant.CONFIGNODE_CONF, 
configurationDirectory.getAbsolutePath());
+
+    // Run SET dispatch, policy validation and file updates without starting 
ConfigManager
+    // services.
+    manager = mock(ConfigManager.class);
+    nodeManager = mock(NodeManager.class);
+    consensusManager = mock(ConsensusManager.class);
+    loadManager = mock(LoadManager.class);
+    schemaManager = mock(ClusterSchemaManager.class);
+    manager.nodeManager = nodeManager;
+    when(manager.setConfiguration(any())).thenCallRealMethod();
+    when(manager.getNodeManager()).thenReturn(nodeManager);
+    when(manager.getConsensusManager()).thenReturn(consensusManager);
+    when(manager.getLoadManager()).thenReturn(loadManager);
+    when(manager.getClusterSchemaManager()).thenReturn(schemaManager);
+    when(manager.confirmLeader())
+        .thenReturn(new TSStatus(TSStatusCode.SUCCESS_STATUS.getStatusCode()));
+    when(consensusManager.isLeader()).thenReturn(true);
+    
when(nodeManager.isConfigNodeVersionConsistentWith(any())).thenReturn(false);
+    
when(nodeManager.setConfiguration(any())).thenReturn(Collections.emptyList());
+  }
+
+  @After
+  public void tearDown() {
+    CONF.setConfigNodeId(originalNodeId);
+    CONF.setSchemaRegionGroupExtensionPolicy(originalSchemaPolicy);
+    CONF.setDataRegionGroupExtensionPolicy(originalDataPolicy);
+    CONF.setReadConsistencyLevel(originalReadConsistency);
+    CONF.setClusterName(originalClusterName);
+    ConfigurationFileUtils.getAppliedProperties().clear();
+    
ConfigurationFileUtils.getAppliedProperties().putAll(originalAppliedProperties);
+    if (originalConfigurationPath == null) {
+      System.clearProperty(ConfigNodeConstant.CONFIGNODE_CONF);
+    } else {
+      System.setProperty(ConfigNodeConstant.CONFIGNODE_CONF, 
originalConfigurationPath);
+    }
+  }
+
+  @Test
+  public void testMixedVersionsRejectEntireRequestBeforeAnyChanges() throws 
IOException {
+    Map<String, String> configs = new HashMap<>();
+    configs.put(DATA_POLICY_KEY, differentDataPolicy().getPolicy());
+    configs.put(
+        "read_consistency_level", "strong".equals(originalReadConsistency) ? 
"weak" : "strong");
+    configs.put("cluster_name", "changed-cluster");
+
+    TSStatus status = manager.setConfiguration(new 
TSetConfigurationReq(configs, -1));
+
+    assertVersionRejection(status);
+    assertConfigurationUnchanged();
+    assertEquals(originalAppliedProperties, 
ConfigurationFileUtils.getAppliedProperties());
+    verify(nodeManager).isConfigNodeVersionConsistentWith(LOCAL_VERSION);
+    verify(nodeManager, never()).setConfiguration(any());
+    verifyZeroInteractions(schemaManager, loadManager);
+  }
+
+  @Test
+  public void testMixedVersionsRejectSchemaPolicyBeforeAnyChanges() throws 
IOException {
+    RegionGroupExtensionPolicy nextPolicy =
+        originalSchemaPolicy == RegionGroupExtensionPolicy.PROACTIVE
+            ? RegionGroupExtensionPolicy.AUTO
+            : RegionGroupExtensionPolicy.PROACTIVE;
+    TSetConfigurationReq request =
+        new TSetConfigurationReq(
+            Collections.singletonMap(
+                "schema_region_group_extension_policy", 
nextPolicy.getPolicy()),
+            -1);
+
+    TSStatus status = manager.setConfiguration(request);
+
+    assertVersionRejection(status);
+    assertConfigurationUnchanged();
+    assertEquals(originalAppliedProperties, 
ConfigurationFileUtils.getAppliedProperties());
+    verify(nodeManager).isConfigNodeVersionConsistentWith(LOCAL_VERSION);
+    verify(nodeManager, never()).setConfiguration(any());
+    verifyZeroInteractions(schemaManager, loadManager);
+  }
+
+  @Test
+  public void testMixedVersionsRejectUnchangedPolicy() throws IOException {
+    TSStatus status = 
manager.setConfiguration(policyRequest(originalDataPolicy, -1));
+
+    assertVersionRejection(status);
+    assertConfigurationUnchanged();
+    assertEquals(originalAppliedProperties, 
ConfigurationFileUtils.getAppliedProperties());
+    verify(nodeManager).isConfigNodeVersionConsistentWith(LOCAL_VERSION);
+    verify(nodeManager, never()).setConfiguration(any());
+    verifyZeroInteractions(schemaManager, loadManager);
+  }
+
+  @Test
+  public void testInternalFollowerApplicationSkipsVersionCheck() throws 
IOException {
+    when(consensusManager.isLeader()).thenReturn(false);
+    RegionGroupExtensionPolicy nextPolicy = differentDataPolicy();
+
+    TSStatus status =
+        manager.setConfiguration(policyRequest(nextPolicy, 
NodeManager.APPLY_CONFIG_LOCALLY));
+
+    assertEquals(TSStatusCode.SUCCESS_STATUS.getStatusCode(), 
status.getCode());
+    assertEquals(nextPolicy, CONF.getDataRegionGroupExtensionPolicy());
+    Properties fileProperties = new Properties();
+    try (Reader reader =
+        Files.newBufferedReader(configurationFile.toPath(), 
StandardCharsets.UTF_8)) {
+      fileProperties.load(reader);
+    }
+    assertEquals(nextPolicy.getPolicy(), 
fileProperties.getProperty(DATA_POLICY_KEY));
+    verify(nodeManager, never()).isConfigNodeVersionConsistentWith(any());
+    verify(nodeManager, never()).setConfiguration(any());
+    verifyZeroInteractions(schemaManager, loadManager);
+  }
+
+  @Test
+  public void testConsistentVersionsAllowUnchangedPolicyAndBroadcast() throws 
IOException {
+    
when(nodeManager.isConfigNodeVersionConsistentWith(any())).thenReturn(true);
+    TSetConfigurationReq request = policyRequest(originalDataPolicy, -1);
+
+    TSStatus status = manager.setConfiguration(request);
+
+    assertEquals(TSStatusCode.SUCCESS_STATUS.getStatusCode(), 
status.getCode());
+    assertConfigurationUnchanged();
+    verify(nodeManager).isConfigNodeVersionConsistentWith(LOCAL_VERSION);
+    verify(nodeManager).setConfiguration(request);
+    verifyZeroInteractions(schemaManager, loadManager);
+  }
+
+  @Test
+  public void testOtherConfigurationSkipsVersionCheckAndBroadcasts() throws 
IOException {
+    TSetConfigurationReq request =
+        new TSetConfigurationReq(
+            Collections.singletonMap("read_consistency_level", 
originalReadConsistency), -1);
+
+    TSStatus status = manager.setConfiguration(request);
+
+    assertEquals(TSStatusCode.SUCCESS_STATUS.getStatusCode(), 
status.getCode());
+    assertConfigurationUnchanged();
+    verify(nodeManager, never()).isConfigNodeVersionConsistentWith(any());
+    verify(nodeManager).setConfiguration(request);
+    verifyZeroInteractions(schemaManager, loadManager);
+  }
+
+  private void assertVersionRejection(TSStatus status) {
+    assertEquals(TSStatusCode.EXECUTE_STATEMENT_ERROR.getStatusCode(), 
status.getCode());
+    assertEquals(
+        ConfigNodeMessages
+            
.EXCEPTION_REGIONGROUP_POLICY_HOT_RELOAD_REQUIRES_IDENTICAL_CONFIGNODE_VERSIONS_AND_BUILDS_FA3BBFEA,
+        status.getMessage());
+  }
+
+  private void assertConfigurationUnchanged() throws IOException {
+    assertEquals(originalSchemaPolicy, 
CONF.getSchemaRegionGroupExtensionPolicy());
+    assertEquals(originalDataPolicy, CONF.getDataRegionGroupExtensionPolicy());
+    assertEquals(originalReadConsistency, CONF.getReadConsistencyLevel());
+    assertEquals(originalClusterName, CONF.getClusterName());
+    assertArrayEquals(originalFileContent, 
Files.readAllBytes(configurationFile.toPath()));
+  }
+
+  private RegionGroupExtensionPolicy differentDataPolicy() {
+    return originalDataPolicy == RegionGroupExtensionPolicy.PROACTIVE
+        ? RegionGroupExtensionPolicy.AUTO
+        : RegionGroupExtensionPolicy.PROACTIVE;
+  }
+
+  private TSetConfigurationReq policyRequest(RegionGroupExtensionPolicy 
policy, int nodeId) {
+    return new TSetConfigurationReq(
+        Collections.singletonMap(DATA_POLICY_KEY, policy.getPolicy()), nodeId);
+  }
+}
diff --git 
a/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/manager/node/NodeManagerVersionConsistencyTest.java
 
b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/manager/node/NodeManagerVersionConsistencyTest.java
new file mode 100644
index 00000000000..ad7d5932c91
--- /dev/null
+++ 
b/iotdb-core/confignode/src/test/java/org/apache/iotdb/confignode/manager/node/NodeManagerVersionConsistencyTest.java
@@ -0,0 +1,178 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.iotdb.confignode.manager.node;
+
+import org.apache.iotdb.common.rpc.thrift.TConfigNodeLocation;
+import org.apache.iotdb.common.rpc.thrift.TDataNodeConfiguration;
+import org.apache.iotdb.common.rpc.thrift.TDataNodeLocation;
+import org.apache.iotdb.confignode.manager.IManager;
+import org.apache.iotdb.confignode.persistence.node.NodeInfo;
+import org.apache.iotdb.confignode.rpc.thrift.TNodeVersionInfo;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class NodeManagerVersionConsistencyTest {
+
+  private static final TNodeVersionInfo EXPECTED_VERSION =
+      new TNodeVersionInfo("2.0.0", "current-build");
+
+  private NodeInfo nodeInfo;
+  private NodeManager nodeManager;
+  private Map<Integer, TNodeVersionInfo> versions;
+
+  @Before
+  public void setUp() {
+    nodeInfo = mock(NodeInfo.class);
+    nodeManager = new NodeManager(mock(IManager.class), nodeInfo);
+    when(nodeInfo.getRegisteredConfigNodes())
+        .thenReturn(
+            Arrays.asList(
+                new TConfigNodeLocation().setConfigNodeId(0),
+                new TConfigNodeLocation().setConfigNodeId(1)));
+    when(nodeInfo.getRegisteredDataNodes())
+        .thenReturn(
+            Collections.singletonList(
+                new TDataNodeConfiguration()
+                    .setLocation(new TDataNodeLocation().setDataNodeId(2))));
+    versions = new HashMap<>();
+    for (int nodeId = 0; nodeId < 3; nodeId++) {
+      versions.put(nodeId, EXPECTED_VERSION.deepCopy());
+    }
+    when(nodeInfo.getNodeVersionInfo()).thenReturn(versions);
+  }
+
+  @Test
+  public void testAllRegisteredConfigNodesMatchExpectedVersion() {
+    
assertTrue(nodeManager.isConfigNodeVersionConsistentWith(EXPECTED_VERSION));
+  }
+
+  @Test
+  public void testConfigNodeVersionMismatch() {
+    versions.put(1, new TNodeVersionInfo("1.0.0", "previous-build"));
+
+    
assertFalse(nodeManager.isConfigNodeVersionConsistentWith(EXPECTED_VERSION));
+  }
+
+  @Test
+  public void testDataNodeVersionDoesNotParticipate() {
+    versions.put(2, new TNodeVersionInfo("1.0.0", "previous-build"));
+
+    
assertTrue(nodeManager.isConfigNodeVersionConsistentWith(EXPECTED_VERSION));
+
+    versions.put(2, new TNodeVersionInfo(EXPECTED_VERSION.getVersion(), 
"another-build"));
+
+    
assertTrue(nodeManager.isConfigNodeVersionConsistentWith(EXPECTED_VERSION));
+  }
+
+  @Test
+  public void testMissingDataNodeVersionDoesNotParticipate() {
+    versions.remove(2);
+
+    
assertTrue(nodeManager.isConfigNodeVersionConsistentWith(EXPECTED_VERSION));
+  }
+
+  @Test
+  public void testUnknownOrIncompleteDataNodeVersionDoesNotParticipate() {
+    for (String invalidValue : Arrays.asList(null, "", " ", "UNKNOWN", 
"unknown")) {
+      versions.put(2, new TNodeVersionInfo(invalidValue, 
EXPECTED_VERSION.getBuildInfo()));
+      
assertTrue(nodeManager.isConfigNodeVersionConsistentWith(EXPECTED_VERSION));
+      versions.put(2, new TNodeVersionInfo(EXPECTED_VERSION.getVersion(), 
invalidValue));
+      
assertTrue(nodeManager.isConfigNodeVersionConsistentWith(EXPECTED_VERSION));
+    }
+  }
+
+  @Test
+  public void testSameVersionWithDifferentBuildIsRejected() {
+    versions.put(1, new TNodeVersionInfo(EXPECTED_VERSION.getVersion(), 
"another-build"));
+
+    
assertFalse(nodeManager.isConfigNodeVersionConsistentWith(EXPECTED_VERSION));
+  }
+
+  @Test
+  public void testMissingRegisteredConfigNodeVersionIsRejected() {
+    for (int nodeId : Arrays.asList(0, 1)) {
+      TNodeVersionInfo previous = versions.remove(nodeId);
+      
assertFalse(nodeManager.isConfigNodeVersionConsistentWith(EXPECTED_VERSION));
+      versions.put(nodeId, previous);
+    }
+  }
+
+  @Test
+  public void testNullVersionEntryIsRejected() {
+    versions.put(1, null);
+
+    
assertFalse(nodeManager.isConfigNodeVersionConsistentWith(EXPECTED_VERSION));
+  }
+
+  @Test
+  public void testUnknownOrIncompleteExpectedVersionIsRejected() {
+    assertFalse(nodeManager.isConfigNodeVersionConsistentWith(null));
+    for (String invalidValue : Arrays.asList(null, "", " ", "UNKNOWN", 
"unknown")) {
+      assertFalse(
+          nodeManager.isConfigNodeVersionConsistentWith(
+              new TNodeVersionInfo(invalidValue, 
EXPECTED_VERSION.getBuildInfo())));
+      assertFalse(
+          nodeManager.isConfigNodeVersionConsistentWith(
+              new TNodeVersionInfo(EXPECTED_VERSION.getVersion(), 
invalidValue)));
+    }
+  }
+
+  @Test
+  public void testUnknownOrIncompleteRegisteredVersionIsRejected() {
+    for (String invalidValue : Arrays.asList(null, "", " ", "UNKNOWN", 
"unknown")) {
+      versions.put(1, new TNodeVersionInfo(invalidValue, 
EXPECTED_VERSION.getBuildInfo()));
+      
assertFalse(nodeManager.isConfigNodeVersionConsistentWith(EXPECTED_VERSION));
+      versions.put(1, new TNodeVersionInfo(EXPECTED_VERSION.getVersion(), 
invalidValue));
+      
assertFalse(nodeManager.isConfigNodeVersionConsistentWith(EXPECTED_VERSION));
+    }
+  }
+
+  @Test
+  public void testConsistentMetadataMustMatchExpectedVersion() {
+    versions.replaceAll((nodeId, version) -> new TNodeVersionInfo("1.0.0", 
"previous-build"));
+
+    
assertFalse(nodeManager.isConfigNodeVersionConsistentWith(EXPECTED_VERSION));
+  }
+
+  @Test
+  public void testAINodeVersionDoesNotParticipate() {
+    versions.put(3, new TNodeVersionInfo("AINode-version", "AINode-build"));
+
+    
assertTrue(nodeManager.isConfigNodeVersionConsistentWith(EXPECTED_VERSION));
+  }
+
+  @Test
+  public void testEmptyConfigNodeMembershipIsRejected() {
+    
when(nodeInfo.getRegisteredConfigNodes()).thenReturn(Collections.emptyList());
+
+    
assertFalse(nodeManager.isConfigNodeVersionConsistentWith(EXPECTED_VERSION));
+  }
+}

Reply via email to