This is an automated email from the ASF dual-hosted git repository.
sunnianjun pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new 2f622fb6fd3 Refactor MetaDataVersionBasedPersistService (#26513)
2f622fb6fd3 is described below
commit 2f622fb6fd3d1186ce392cbb4c3cfa338127d230
Author: zhaojinchao <[email protected]>
AuthorDate: Sat Jun 24 15:15:29 2023 +0800
Refactor MetaDataVersionBasedPersistService (#26513)
* Refactor MetaDataVersionBasedPersistService
* Fix checkstyle
* Add NewDatabaseMetaDataPersistService
* Fix ci
* Fix unit test
---
.../persist/NewMetaDataPersistService.java | 13 +-
.../NewDatabaseMetaDataPersistService.java | 170 +++++++++++++++++++++
.../MetaDataVersionBasedPersistService.java | 45 +-----
.../version/MetaDataVersionPersistService.java | 73 +--------
.../service/MetaDataVersionPersistServiceTest.java | 64 +-------
.../cluster/NewClusterModeContextManager.java | 6 +-
.../subscriber/ConfigurationChangedSubscriber.java | 12 +-
.../ConfigurationChangedSubscriberTest.java | 2 -
8 files changed, 200 insertions(+), 185 deletions(-)
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/NewMetaDataPersistService.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/NewMetaDataPersistService.java
index f5fc3f3ee1d..0d1a412e5fd 100644
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/NewMetaDataPersistService.java
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/NewMetaDataPersistService.java
@@ -30,7 +30,7 @@ import
org.apache.shardingsphere.metadata.persist.service.config.database.NewDat
import
org.apache.shardingsphere.metadata.persist.service.config.database.NewDatabaseRulePersistService;
import
org.apache.shardingsphere.metadata.persist.service.config.global.NewGlobalRulePersistService;
import
org.apache.shardingsphere.metadata.persist.service.config.global.NewPropertiesPersistService;
-import
org.apache.shardingsphere.metadata.persist.service.database.DatabaseMetaDataPersistService;
+import
org.apache.shardingsphere.metadata.persist.service.database.NewDatabaseMetaDataPersistService;
import
org.apache.shardingsphere.metadata.persist.service.version.MetaDataVersionPersistService;
import org.apache.shardingsphere.mode.spi.PersistRepository;
@@ -50,10 +50,11 @@ public final class NewMetaDataPersistService implements
MetaDataBasedPersistServ
private final PersistRepository repository;
- // TODO replace all service to new persist service
+ private final MetaDataVersionPersistService metaDataVersionPersistService;
+
private final NewDataSourcePersistService dataSourceService;
- private final DatabaseMetaDataPersistService databaseMetaDataService;
+ private final NewDatabaseMetaDataPersistService databaseMetaDataService;
private final NewDatabaseRulePersistService databaseRulePersistService;
@@ -61,18 +62,16 @@ public final class NewMetaDataPersistService implements
MetaDataBasedPersistServ
private final NewPropertiesPersistService propsService;
- private final MetaDataVersionPersistService metaDataVersionPersistService;
-
private final ShardingSphereDataPersistService
shardingSphereDataPersistService;
public NewMetaDataPersistService(final PersistRepository repository) {
this.repository = repository;
+ metaDataVersionPersistService = new
MetaDataVersionPersistService(repository);
dataSourceService = new NewDataSourcePersistService(repository);
- databaseMetaDataService = new
DatabaseMetaDataPersistService(repository);
+ databaseMetaDataService = new
NewDatabaseMetaDataPersistService(repository, metaDataVersionPersistService);
databaseRulePersistService = new
NewDatabaseRulePersistService(repository);
globalRuleService = new NewGlobalRulePersistService(repository);
propsService = new NewPropertiesPersistService(repository);
- metaDataVersionPersistService = new
MetaDataVersionPersistService(repository);
shardingSphereDataPersistService = new
ShardingSphereDataPersistService(repository);
}
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/database/NewDatabaseMetaDataPersistService.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/database/NewDatabaseMetaDataPersistService.java
new file mode 100644
index 00000000000..f366e3d18a5
--- /dev/null
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/database/NewDatabaseMetaDataPersistService.java
@@ -0,0 +1,170 @@
+/*
+ * 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.shardingsphere.metadata.persist.service.database;
+
+import lombok.Getter;
+import org.apache.shardingsphere.infra.metadata.database.schema.SchemaManager;
+import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
+import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereTable;
+import org.apache.shardingsphere.metadata.persist.node.DatabaseMetaDataNode;
+import
org.apache.shardingsphere.metadata.persist.service.schema.NewTableMetaDataPersistService;
+import
org.apache.shardingsphere.metadata.persist.service.schema.NewViewMetaDataPersistService;
+import
org.apache.shardingsphere.metadata.persist.service.version.MetaDataVersionPersistService;
+import org.apache.shardingsphere.mode.spi.PersistRepository;
+
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * Database meta data registry service.
+ */
+@Getter
+public final class NewDatabaseMetaDataPersistService implements
DatabaseMetaDataBasedPersistService {
+
+ private final PersistRepository repository;
+
+ private final NewTableMetaDataPersistService tableMetaDataPersistService;
+
+ private final NewViewMetaDataPersistService viewMetaDataPersistService;
+
+ private final MetaDataVersionPersistService metaDataVersionPersistService;
+
+ public NewDatabaseMetaDataPersistService(final PersistRepository
repository, final MetaDataVersionPersistService metaDataVersionPersistService) {
+ this.repository = repository;
+ this.tableMetaDataPersistService = new
NewTableMetaDataPersistService(repository);
+ this.viewMetaDataPersistService = new
NewViewMetaDataPersistService(repository);
+ this.metaDataVersionPersistService = metaDataVersionPersistService;
+ }
+
+ /**
+ * Add database name.
+ *
+ * @param databaseName database name
+ */
+ @Override
+ public void addDatabase(final String databaseName) {
+
repository.persist(DatabaseMetaDataNode.getDatabaseNamePath(databaseName), "");
+ }
+
+ /**
+ * Drop database.
+ *
+ * @param databaseName database name to be deleted
+ */
+ @Override
+ public void dropDatabase(final String databaseName) {
+
repository.delete(DatabaseMetaDataNode.getDatabaseNamePath(databaseName));
+ }
+
+ /**
+ * Load all database names.
+ *
+ * @return all database names
+ */
+ @Override
+ public Collection<String> loadAllDatabaseNames() {
+ return
repository.getChildrenKeys(DatabaseMetaDataNode.getMetaDataNodePath());
+ }
+
+ /**
+ * Add schema.
+ *
+ * @param databaseName database name
+ * @param schemaName schema name
+ */
+ @Override
+ public void addSchema(final String databaseName, final String schemaName) {
+
repository.persist(DatabaseMetaDataNode.getMetaDataTablesPath(databaseName,
schemaName), "");
+ }
+
+ /**
+ * Drop schema.
+ *
+ * @param databaseName database name
+ * @param schemaName schema name
+ */
+ @Override
+ public void dropSchema(final String databaseName, final String schemaName)
{
+
repository.delete(DatabaseMetaDataNode.getMetaDataSchemaPath(databaseName,
schemaName));
+ }
+
+ /**
+ * Compare and persist schema meta data.
+ *
+ * @param databaseName database name
+ * @param schemaName schema name
+ * @param schema schema meta data
+ */
+ @Override
+ public void compareAndPersist(final String databaseName, final String
schemaName, final ShardingSphereSchema schema) {
+ if (schema.getTables().isEmpty() && schema.getViews().isEmpty()) {
+ addSchema(databaseName, schemaName);
+ }
+ Map<String, ShardingSphereTable> currentTables =
tableMetaDataPersistService.load(databaseName, schemaName);
+
metaDataVersionPersistService.switchActiveVersion(tableMetaDataPersistService
+ .persistSchemaMetaData(databaseName, schemaName,
SchemaManager.getToBeAddedTables(schema.getTables(), currentTables)));
+ SchemaManager.getToBeDeletedTables(schema.getTables(),
currentTables).forEach((key, value) ->
tableMetaDataPersistService.delete(databaseName, schemaName, key));
+ }
+
+ /**
+ * Persist schema meta data.
+ *
+ * @param databaseName database name
+ * @param schemaName schema name
+ * @param schema schema meta data
+ */
+ @Override
+ public void persist(final String databaseName, final String schemaName,
final ShardingSphereSchema schema) {
+ if (schema.getTables().isEmpty() && schema.getViews().isEmpty()) {
+ addSchema(databaseName, schemaName);
+ }
+
metaDataVersionPersistService.switchActiveVersion(tableMetaDataPersistService.persistSchemaMetaData(databaseName,
schemaName, schema.getTables()));
+ }
+
+ /**
+ * Delete schema meta data.
+ *
+ * @param databaseName database name
+ * @param schemaName schema name
+ * @param schema schema meta data
+ */
+ @Override
+ public void delete(final String databaseName, final String schemaName,
final ShardingSphereSchema schema) {
+ schema.getTables().forEach((key, value) ->
tableMetaDataPersistService.delete(databaseName, schemaName, key));
+ }
+
+ /**
+ * Load schema meta data.
+ *
+ * @param databaseName database name
+ * @return schema meta data
+ */
+ @Override
+ public Map<String, ShardingSphereSchema> loadSchemas(final String
databaseName) {
+ Collection<String> schemaNames = loadAllSchemaNames(databaseName);
+ Map<String, ShardingSphereSchema> result = new
LinkedHashMap<>(schemaNames.size(), 1F);
+ schemaNames.forEach(each -> result.put(each.toLowerCase(),
+ new
ShardingSphereSchema(tableMetaDataPersistService.load(databaseName, each),
viewMetaDataPersistService.load(databaseName, each))));
+ return result;
+ }
+
+ private Collection<String> loadAllSchemaNames(final String databaseName) {
+ return
repository.getChildrenKeys(DatabaseMetaDataNode.getMetaDataSchemasPath(databaseName));
+ }
+}
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/version/MetaDataVersionBasedPersistService.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/version/MetaDataVersionBasedPersistService.java
index da0f3d8d87e..3abc83f2194 100644
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/version/MetaDataVersionBasedPersistService.java
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/version/MetaDataVersionBasedPersistService.java
@@ -17,52 +17,19 @@
package org.apache.shardingsphere.metadata.persist.service.version;
-import java.util.Optional;
+import org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
+
+import java.util.Collection;
/**
- * TODO Remove this when metadata structure adjustment completed. #25485
* Meta data version based registry service.
*/
public interface MetaDataVersionBasedPersistService {
/**
- * Get active version.
- *
- * @param databaseName database name
- * @return active database version
- */
- Optional<String> getActiveVersion(String databaseName);
-
- /**
- * Judge whether active version.
- *
- * @param databaseName database name
- * @param version version
- * @return is active version or not
- */
- boolean isActiveVersion(String databaseName, String version);
-
- /**
- * Create new schema version.
- *
- * @param databaseName database name
- * @return new version
- */
- Optional<String> createNewVersion(String databaseName);
-
- /**
- * Persist active database version.
- *
- * @param databaseName database name
- * @param version version
- */
- void persistActiveVersion(String databaseName, String version);
-
- /**
- * Delete database version.
+ * Switch active version.
*
- * @param databaseName database name
- * @param version version
+ * @param metaDataVersions meta data versions
*/
- void deleteVersion(String databaseName, String version);
+ void switchActiveVersion(Collection<MetaDataVersion> metaDataVersions);
}
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/version/MetaDataVersionPersistService.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/version/MetaDataVersionPersistService.java
index e368cecd34d..2ba47070797 100644
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/version/MetaDataVersionPersistService.java
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/version/MetaDataVersionPersistService.java
@@ -18,11 +18,10 @@
package org.apache.shardingsphere.metadata.persist.service.version;
import lombok.RequiredArgsConstructor;
-import org.apache.shardingsphere.metadata.persist.node.DatabaseMetaDataNode;
+import org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
import org.apache.shardingsphere.mode.spi.PersistRepository;
-import java.util.Optional;
-import java.util.concurrent.atomic.AtomicLong;
+import java.util.Collection;
/**
* Meta data version persist service.
@@ -32,71 +31,11 @@ public final class MetaDataVersionPersistService implements
MetaDataVersionBased
private final PersistRepository repository;
- /**
- * Get active version.
- *
- * @param databaseName database name
- * @return active database version
- */
+ // TODO Need to use transaction operation
@Override
- public Optional<String> getActiveVersion(final String databaseName) {
- return
Optional.ofNullable(repository.getDirectly(DatabaseMetaDataNode.getActiveVersionPath(databaseName)));
- }
-
- /**
- * Judge whether active version.
- *
- * @param databaseName database name
- * @param version version
- * @return is active version or not
- */
- @Override
- public boolean isActiveVersion(final String databaseName, final String
version) {
- Optional<String> actualVersion = getActiveVersion(databaseName);
- return actualVersion.isPresent() &&
actualVersion.get().equals(version);
- }
-
- /**
- * Create new schema version.
- *
- * @param databaseName database name
- * @return new version
- */
- @Override
- public Optional<String> createNewVersion(final String databaseName) {
- Optional<String> activeVersion = getActiveVersion(databaseName);
- if (!activeVersion.isPresent()) {
- return Optional.empty();
+ public void switchActiveVersion(final Collection<MetaDataVersion>
metaDataVersions) {
+ for (MetaDataVersion each : metaDataVersions) {
+ repository.persist(each.getPersistKey(),
each.getNextActiveVersion());
}
- String newVersion = String.valueOf(new
AtomicLong(Long.parseLong(activeVersion.get())).incrementAndGet());
- repository.persist(DatabaseMetaDataNode.getRulePath(databaseName,
newVersion),
repository.getDirectly(DatabaseMetaDataNode.getRulePath(databaseName,
activeVersion.get())));
- repository.persist(
- DatabaseMetaDataNode.getMetaDataDataSourcePath(databaseName,
newVersion),
repository.getDirectly(DatabaseMetaDataNode.getMetaDataDataSourcePath(databaseName,
activeVersion.get())));
- return Optional.of(newVersion);
- }
-
- /**
- * Persist active database version.
- *
- * @param databaseName database name
- * @param version version
- */
- @Override
- public void persistActiveVersion(final String databaseName, final String
version) {
- Optional<String> activeVersion = getActiveVersion(databaseName);
- if (activeVersion.isPresent() && !activeVersion.get().equals(version))
{
-
repository.persist(DatabaseMetaDataNode.getActiveVersionPath(databaseName),
version);
- }
- }
-
- /**
- * Delete database version.
- *
- * @param databaseName database name
- * @param version version
- */
- @Override
- public void deleteVersion(final String databaseName, final String version)
{
-
repository.delete(DatabaseMetaDataNode.getDatabaseVersionPath(databaseName,
version));
}
}
diff --git
a/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/service/MetaDataVersionPersistServiceTest.java
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/service/MetaDataVersionPersistServiceTest.java
index ed70adf36cd..65dad3a503c 100644
---
a/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/service/MetaDataVersionPersistServiceTest.java
+++
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/service/MetaDataVersionPersistServiceTest.java
@@ -17,23 +17,16 @@
package org.apache.shardingsphere.metadata.persist.service;
-import org.apache.shardingsphere.metadata.persist.node.DatabaseMetaDataNode;
+import org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
import
org.apache.shardingsphere.metadata.persist.service.version.MetaDataVersionPersistService;
import org.apache.shardingsphere.mode.spi.PersistRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-import java.util.Optional;
+import java.util.Collections;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.is;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.mockito.ArgumentMatchers.contains;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
class MetaDataVersionPersistServiceTest {
@@ -44,61 +37,12 @@ class MetaDataVersionPersistServiceTest {
@BeforeEach
void setUp() {
repository = mock(PersistRepository.class);
- when(repository.getDirectly(contains("foo_db"))).thenReturn("1");
metaDataVersionPersistService = new
MetaDataVersionPersistService(repository);
}
@Test
void assertGetActiveVersion() {
- Optional<String> actual =
metaDataVersionPersistService.getActiveVersion("foo_db");
- assertTrue(actual.isPresent());
- assertThat(actual.get(), is("1"));
- }
-
- @Test
- void assertIsActiveVersion() {
- assertTrue(metaDataVersionPersistService.isActiveVersion("foo_db",
"1"));
- }
-
- @Test
- void assertIsNotActiveVersionWithNotExistedDatabase() {
- assertFalse(metaDataVersionPersistService.isActiveVersion("bar_db",
"1"));
- }
-
- @Test
- void assertIsNotActiveVersionWithNotExistedVersion() {
- assertFalse(metaDataVersionPersistService.isActiveVersion("foo_db",
"2"));
- }
-
- @Test
- void assertCreateNewVersionWithoutExistedActiveVersion() {
-
assertFalse(metaDataVersionPersistService.createNewVersion("bar_db").isPresent());
- }
-
- @Test
- void assertCreateNewVersionWithExistedActiveVersion() {
- Optional<String> actual =
metaDataVersionPersistService.createNewVersion("foo_db");
- assertTrue(actual.isPresent());
- assertThat(actual.get(), is("2"));
- verify(repository).persist("/metadata/foo_db/versions/2/rules", "1");
- verify(repository).persist("/metadata/foo_db/versions/2/data_sources",
"1");
- }
-
- @Test
- void assertPersistActiveVersionWhenExisted() {
- metaDataVersionPersistService.persistActiveVersion("foo_db", "2");
-
verify(repository).persist(DatabaseMetaDataNode.getActiveVersionPath("foo_db"),
"2");
- }
-
- @Test
- void assertPersistActiveVersionWithNotExistedDatabase() {
- metaDataVersionPersistService.persistActiveVersion("bar_db", "2");
- verify(repository,
times(0)).persist(DatabaseMetaDataNode.getActiveVersionPath("bar_db"), "2");
- }
-
- @Test
- void assertDeleteVersion() {
- metaDataVersionPersistService.deleteVersion("foo_db", "1");
-
verify(repository).delete(DatabaseMetaDataNode.getDatabaseVersionPath("foo_db",
"1"));
+
metaDataVersionPersistService.switchActiveVersion(Collections.singletonList(new
MetaDataVersion("foo_key", "0", "1")));
+ verify(repository).persist("foo_key", "1");
}
}
diff --git
a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/NewClusterModeContextManager.java
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/NewClusterModeContextManager.java
index 9bfe5b6f5f3..8f7755e4982 100644
---
a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/NewClusterModeContextManager.java
+++
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/NewClusterModeContextManager.java
@@ -28,6 +28,7 @@ import
org.apache.shardingsphere.infra.metadata.database.schema.pojo.AlterSchema
import org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
import org.apache.shardingsphere.metadata.persist.node.NewDatabaseMetaDataNode;
import
org.apache.shardingsphere.metadata.persist.service.database.DatabaseMetaDataBasedPersistService;
+import
org.apache.shardingsphere.metadata.persist.service.version.MetaDataVersionBasedPersistService;
import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.mode.manager.ContextManagerAware;
@@ -84,8 +85,9 @@ public final class NewClusterModeContextManager implements
ModeContextManager, C
Map<String, ShardingSphereTable> tables =
alterSchemaMetaDataPOJO.getAlteredTables().stream().collect(Collectors.toMap(ShardingSphereTable::getName,
table -> table));
Map<String, ShardingSphereView> views =
alterSchemaMetaDataPOJO.getAlteredViews().stream().collect(Collectors.toMap(ShardingSphereView::getName,
view -> view));
DatabaseMetaDataBasedPersistService databaseMetaDataService =
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService();
-
databaseMetaDataService.getTableMetaDataPersistService().persist(databaseName,
schemaName, tables);
-
databaseMetaDataService.getViewMetaDataPersistService().persist(databaseName,
schemaName, views);
+ MetaDataVersionBasedPersistService metaDataVersionBasedPersistService
=
contextManager.getMetaDataContexts().getPersistService().getMetaDataVersionPersistService();
+
metaDataVersionBasedPersistService.switchActiveVersion(databaseMetaDataService.getTableMetaDataPersistService().persistSchemaMetaData(databaseName,
schemaName, tables));
+
metaDataVersionBasedPersistService.switchActiveVersion(databaseMetaDataService.getViewMetaDataPersistService().persistSchemaMetaData(databaseName,
schemaName, views));
alterSchemaMetaDataPOJO.getDroppedTables().forEach(each ->
databaseMetaDataService.getTableMetaDataPersistService().delete(databaseName,
schemaName, each));
alterSchemaMetaDataPOJO.getDroppedViews().forEach(each ->
databaseMetaDataService.getViewMetaDataPersistService().delete(databaseName,
schemaName, each));
}
diff --git
a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/coordinator/subscriber/ConfigurationChangedSubscriber.java
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/coordinator/subscriber/ConfigurationChangedSubscriber.java
index a4f4bf7d554..daaa9c41033 100644
---
a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/coordinator/subscriber/ConfigurationChangedSubscriber.java
+++
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/coordinator/subscriber/ConfigurationChangedSubscriber.java
@@ -64,10 +64,8 @@ public final class ConfigurationChangedSubscriber {
*/
@Subscribe
public synchronized void renew(final DataSourceChangedEvent event) {
- if
(persistService.getMetaDataVersionPersistService().isActiveVersion(event.getDatabaseName(),
event.getDatabaseVersion())) {
-
contextManager.alterDataSourceConfiguration(event.getDatabaseName(),
event.getDataSourcePropertiesMap());
- disableDataSources();
- }
+ contextManager.alterDataSourceConfiguration(event.getDatabaseName(),
event.getDataSourcePropertiesMap());
+ disableDataSources();
}
/**
@@ -77,10 +75,8 @@ public final class ConfigurationChangedSubscriber {
*/
@Subscribe
public synchronized void renew(final RuleConfigurationsChangedEvent event)
{
- if
(persistService.getMetaDataVersionPersistService().isActiveVersion(event.getDatabaseName(),
event.getDatabaseVersion())) {
- contextManager.alterRuleConfiguration(event.getDatabaseName(),
event.getRuleConfigs());
- disableDataSources();
- }
+ contextManager.alterRuleConfiguration(event.getDatabaseName(),
event.getRuleConfigs());
+ disableDataSources();
}
/**
diff --git
a/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/coordinator/subscriber/ConfigurationChangedSubscriberTest.java
b/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/coordinator/subscriber/ConfigurationChangedSubscriberTest.java
index 2d5c73f3473..28c5b9b85e9 100644
---
a/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/coordinator/subscriber/ConfigurationChangedSubscriberTest.java
+++
b/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/coordinator/subscriber/ConfigurationChangedSubscriberTest.java
@@ -126,7 +126,6 @@ class ConfigurationChangedSubscriberTest {
@Test
void assertRenewForRuleConfigurationsChanged() {
-
when(persistService.getMetaDataVersionPersistService().isActiveVersion("db",
"0")).thenReturn(true);
assertThat(contextManager.getMetaDataContexts().getMetaData().getDatabase("db"),
is(database));
subscriber.renew(new RuleConfigurationsChangedEvent("db", "0",
Collections.emptyList()));
assertThat(contextManager.getMetaDataContexts().getMetaData().getDatabase("db"),
not(database));
@@ -134,7 +133,6 @@ class ConfigurationChangedSubscriberTest {
@Test
void assertRenewForDataSourceChanged() {
-
when(persistService.getMetaDataVersionPersistService().isActiveVersion("db",
"0")).thenReturn(true);
subscriber.renew(new DataSourceChangedEvent("db", "0",
createChangedDataSourcePropertiesMap()));
assertTrue(contextManager.getMetaDataContexts().getMetaData().getDatabase("db").getResourceMetaData().getDataSources().containsKey("ds_2"));
}
