This is an automated email from the ASF dual-hosted git repository.
zhangliang 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 b521a8acb4c Refactor DataSourceMetaDataNodePath (#34294)
b521a8acb4c is described below
commit b521a8acb4c81dbd20d5e35000b33f7a79043cf7
Author: Liang Zhang <[email protected]>
AuthorDate: Fri Jan 10 01:01:11 2025 +0800
Refactor DataSourceMetaDataNodePath (#34294)
* Refactor DataSourceMetaDataNodePath
* Refactor DataSourceMetaDataNodePath
---
.../node/metadata/DataSourceMetaDataNodePath.java | 188 +++++++++------------
.../database/DataSourceNodePersistService.java | 16 +-
.../database/DataSourceUnitPersistService.java | 16 +-
.../metadata/DataSourceMetaDataNodePathTest.java | 95 +++++------
.../database/metadata/MetaDataChangedHandler.java | 52 +++---
5 files changed, 164 insertions(+), 203 deletions(-)
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNodePath.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNodePath.java
index c04edad6b8b..620f684a8a4 100644
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNodePath.java
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNodePath.java
@@ -34,225 +34,191 @@ public final class DataSourceMetaDataNodePath {
private static final String DATA_SOURCES_NODE = "data_sources";
- private static final String DATA_SOURCE_NODES_NODE = "nodes";
+ private static final String NODES_NODE = "nodes";
- private static final String DATA_SOURCE_UNITS_NODE = "units";
+ private static final String UNITS_NODE = "units";
private static final String VERSIONS_NODE = "versions";
private static final String ACTIVE_VERSION_NODE = "active_version";
- private static final String DATABASE_DATA_SOURCES_NODE =
"/([\\w\\-]+)/data_sources/";
-
- private static final String ACTIVE_VERSION_SUFFIX =
"/([\\w\\-]+)/active_version";
-
- private static final String DATA_SOURCE_SUFFIX = "/([\\w\\-]+)$";
+ private static final String IDENTIFIER_PATTERN = "([\\w\\-]+)";
/**
- * Get data source units path.
+ * Get data source root path.
*
* @param databaseName database name
- * @return data sources path
+ * @return data source root path
*/
- public static String getDataSourceUnitsPath(final String databaseName) {
- return String.join("/", ROOT_NODE, databaseName, DATA_SOURCES_NODE,
DATA_SOURCE_UNITS_NODE);
+ public static String getDataSourceRootPath(final String databaseName) {
+ return String.join("/", ROOT_NODE, databaseName, DATA_SOURCES_NODE);
}
/**
- * Get data source nodes path.
+ * Get storage units path.
*
* @param databaseName database name
- * @return data sources path
+ * @return storage units path
*/
- public static String getDataSourceNodesPath(final String databaseName) {
- return String.join("/", ROOT_NODE, databaseName, DATA_SOURCES_NODE,
DATA_SOURCE_NODES_NODE);
+ public static String getStorageUnitsPath(final String databaseName) {
+ return String.join("/", getDataSourceRootPath(databaseName),
UNITS_NODE);
}
/**
- * Get data source unit path.
+ * Get storage nodes path.
*
* @param databaseName database name
- * @param dataSourceName data source name
- * @return data source path
+ * @return storage nodes path
*/
- public static String getDataSourceUnitPath(final String databaseName,
final String dataSourceName) {
- return String.join("/", getDataSourceUnitsPath(databaseName),
dataSourceName);
+ public static String getStorageNodesPath(final String databaseName) {
+ return String.join("/", getDataSourceRootPath(databaseName),
NODES_NODE);
}
/**
- * Get data source node path.
+ * Get storage unit path.
*
* @param databaseName database name
- * @param dataSourceName data source name
- * @return data source path
+ * @param storageUnitName storage unit name
+ * @return storage unit path
*/
- public static String getDataSourceNodePath(final String databaseName,
final String dataSourceName) {
- return String.join("/", getDataSourceNodesPath(databaseName),
dataSourceName);
+ public static String getStorageUnitPath(final String databaseName, final
String storageUnitName) {
+ return String.join("/", getStorageUnitsPath(databaseName),
storageUnitName);
}
/**
- * Get data source unit version path.
+ * Get storage node path.
*
* @param databaseName database name
- * @param dataSourceName data source name
- * @param version version
- * @return data source unit version path
+ * @param storageNodeName storage node name
+ * @return storage node path
*/
- public static String getDataSourceUnitVersionPath(final String
databaseName, final String dataSourceName, final String version) {
- return String.join("/", getDataSourceUnitVersionsPath(databaseName,
dataSourceName), version);
+ public static String getStorageNodePath(final String databaseName, final
String storageNodeName) {
+ return String.join("/", getStorageNodesPath(databaseName),
storageNodeName);
}
/**
- * Get data source unit versions path.
+ * Get storage unit version path.
*
* @param databaseName database name
- * @param dataSourceName data source name
- * @return data source versions path
+ * @param storageUnitName storage unit name
+ * @param version version
+ * @return storage unit version path
*/
- public static String getDataSourceUnitVersionsPath(final String
databaseName, final String dataSourceName) {
- return String.join("/", getDataSourceUnitsPath(databaseName),
dataSourceName, VERSIONS_NODE);
+ public static String getStorageUnitVersionPath(final String databaseName,
final String storageUnitName, final String version) {
+ return String.join("/", getStorageUnitVersionsPath(databaseName,
storageUnitName), version);
}
/**
- * Get data source unit active version path.
+ * Get storage unit versions path.
*
* @param databaseName database name
- * @param dataSourceName data source name
- * @return data source active version path
+ * @param dataSourceName storage unit name
+ * @return storage unit versions path
*/
- public static String getDataSourceUnitActiveVersionPath(final String
databaseName, final String dataSourceName) {
- return String.join("/", getDataSourceUnitsPath(databaseName),
dataSourceName, ACTIVE_VERSION_NODE);
+ public static String getStorageUnitVersionsPath(final String databaseName,
final String dataSourceName) {
+ return String.join("/", getStorageUnitsPath(databaseName),
dataSourceName, VERSIONS_NODE);
}
/**
- * Get data source node versions path.
+ * Get storage unit active version path.
*
* @param databaseName database name
- * @param dataSourceName data source name
- * @return data source versions path
+ * @param dataSourceName storage unit name
+ * @return storage unit active version path
*/
- public static String getDataSourceNodeVersionsPath(final String
databaseName, final String dataSourceName) {
- return String.join("/", getDataSourceNodesPath(databaseName),
dataSourceName, VERSIONS_NODE);
+ public static String getStorageUnitActiveVersionPath(final String
databaseName, final String dataSourceName) {
+ return String.join("/", getStorageUnitsPath(databaseName),
dataSourceName, ACTIVE_VERSION_NODE);
}
/**
- * Get data source node version path.
+ * Get storage node versions path.
*
* @param databaseName database name
- * @param dataSourceName data source name
- * @param version version
- * @return data source node version path
+ * @param storageNodeName storage node name
+ * @return storage node versions path
*/
- public static String getDataSourceNodeVersionPath(final String
databaseName, final String dataSourceName, final String version) {
- return String.join("/", getDataSourceNodeVersionsPath(databaseName,
dataSourceName), version);
+ public static String getStorageNodeVersionsPath(final String databaseName,
final String storageNodeName) {
+ return String.join("/", getStorageNodesPath(databaseName),
storageNodeName, VERSIONS_NODE);
}
/**
- * Get data source node active version path.
+ * Get storage node version path.
*
* @param databaseName database name
- * @param dataSourceName data source name
- * @return data source active version path
+ * @param storageNodeName storage node name
+ * @param version version
+ * @return storage node version path
*/
- public static String getDataSourceNodeActiveVersionPath(final String
databaseName, final String dataSourceName) {
- return String.join("/", getDataSourceNodesPath(databaseName),
dataSourceName, ACTIVE_VERSION_NODE);
+ public static String getStorageNodeVersionPath(final String databaseName,
final String storageNodeName, final String version) {
+ return String.join("/", getStorageNodeVersionsPath(databaseName,
storageNodeName), version);
}
/**
- * Is data sources path.
+ * Get storage node active version path.
*
- * @param path path
- * @return true or false
+ * @param databaseName database name
+ * @param storageNodeName storage node name
+ * @return storage node active version path
*/
- public static boolean isDataSourcesPath(final String path) {
- return Pattern.compile(ROOT_NODE + DATABASE_DATA_SOURCES_NODE + "?",
Pattern.CASE_INSENSITIVE).matcher(path).find();
+ public static String getStorageNodeActiveVersionPath(final String
databaseName, final String storageNodeName) {
+ return String.join("/", getStorageNodesPath(databaseName),
storageNodeName, ACTIVE_VERSION_NODE);
}
/**
- * Find data source name by data source unit active version path.
+ * Find storage unit name by active version path.
*
* @param path path
- * @return found data source name
+ * @return found storage unit name
*/
- public static Optional<String>
findDataSourceNameByDataSourceUnitActiveVersionPath(final String path) {
- Pattern pattern = Pattern.compile(ROOT_NODE +
DATABASE_DATA_SOURCES_NODE + DATA_SOURCE_UNITS_NODE + ACTIVE_VERSION_SUFFIX,
Pattern.CASE_INSENSITIVE);
+ public static Optional<String>
findStorageUnitNameByActiveVersionPath(final String path) {
+ Pattern pattern =
Pattern.compile(getStorageUnitActiveVersionPath(IDENTIFIER_PATTERN,
IDENTIFIER_PATTERN), Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(path);
return matcher.find() ? Optional.of(matcher.group(2)) :
Optional.empty();
}
/**
- * Find data source name by data source unit path.
+ * Find storage unit name by storage unit path.
*
* @param path path
- * @return data source name
+ * @return found storage unit name
*/
- public static Optional<String>
findDataSourceNameByDataSourceUnitPath(final String path) {
- Pattern pattern = Pattern.compile(ROOT_NODE +
DATABASE_DATA_SOURCES_NODE + DATA_SOURCE_UNITS_NODE + DATA_SOURCE_SUFFIX,
Pattern.CASE_INSENSITIVE);
+ public static Optional<String> findStorageUnitNameByStorageUnitPath(final
String path) {
+ Pattern pattern =
Pattern.compile(getStorageUnitPath(IDENTIFIER_PATTERN, IDENTIFIER_PATTERN) +
"$", Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(path);
return matcher.find() ? Optional.of(matcher.group(2)) :
Optional.empty();
}
/**
- * Find data source name by data source node active version path.
+ * Find storage node name by active version path.
*
* @param path path
- * @return data source name
+ * @return found storage unit name
*/
- public static Optional<String>
findDataSourceNameByDataSourceNodeActiveVersionPath(final String path) {
- Pattern pattern = Pattern.compile(ROOT_NODE +
DATABASE_DATA_SOURCES_NODE + DATA_SOURCE_NODES_NODE + ACTIVE_VERSION_SUFFIX,
Pattern.CASE_INSENSITIVE);
+ public static Optional<String>
findStorageNodeNameByActiveVersionPath(final String path) {
+ Pattern pattern =
Pattern.compile(getStorageNodeActiveVersionPath(IDENTIFIER_PATTERN,
IDENTIFIER_PATTERN), Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(path);
return matcher.find() ? Optional.of(matcher.group(2)) :
Optional.empty();
}
/**
- * Find data source name by data source path.
+ * Find storage node name by storage node path.
*
* @param path path
- * @return data source name
+ * @return found storage unit name
*/
- public static Optional<String>
findDataSourceNameByDataSourceNodePath(final String path) {
- Pattern pattern = Pattern.compile(ROOT_NODE +
DATABASE_DATA_SOURCES_NODE + DATA_SOURCE_NODES_NODE + DATA_SOURCE_SUFFIX,
Pattern.CASE_INSENSITIVE);
+ public static Optional<String> findStorageNodeNameByStorageNodePath(final
String path) {
+ Pattern pattern =
Pattern.compile(getStorageNodePath(IDENTIFIER_PATTERN, IDENTIFIER_PATTERN) +
"$", Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(path);
return matcher.find() ? Optional.of(matcher.group(2)) :
Optional.empty();
}
/**
- * Is data source unit active version path.
- *
- * @param path path
- * @return true or false
- */
- public static boolean isDataSourceUnitActiveVersionPath(final String path)
{
- return Pattern.compile(ROOT_NODE + DATABASE_DATA_SOURCES_NODE +
DATA_SOURCE_UNITS_NODE + ACTIVE_VERSION_SUFFIX,
Pattern.CASE_INSENSITIVE).matcher(path).find();
- }
-
- /**
- * Is data source unit path.
- *
- * @param path path
- * @return true or false
- */
- public static boolean isDataSourceUnitPath(final String path) {
- return Pattern.compile(ROOT_NODE + DATABASE_DATA_SOURCES_NODE +
DATA_SOURCE_UNITS_NODE + DATA_SOURCE_SUFFIX,
Pattern.CASE_INSENSITIVE).matcher(path).find();
- }
-
- /**
- * Is data source node active version path.
- *
- * @param path path
- * @return true or false
- */
- public static boolean isDataSourceNodeActiveVersionPath(final String path)
{
- return Pattern.compile(ROOT_NODE + DATABASE_DATA_SOURCES_NODE +
DATA_SOURCE_NODES_NODE + ACTIVE_VERSION_SUFFIX,
Pattern.CASE_INSENSITIVE).matcher(path).find();
- }
-
- /**
- * Is data source node path.
+ * Is data source root path.
*
* @param path path
* @return true or false
*/
- public static boolean isDataSourceNodePath(final String path) {
- return Pattern.compile(ROOT_NODE + DATABASE_DATA_SOURCES_NODE +
DATA_SOURCE_NODES_NODE + DATA_SOURCE_SUFFIX,
Pattern.CASE_INSENSITIVE).matcher(path).find();
+ public static boolean isDataSourceRootPath(final String path) {
+ return Pattern.compile(getDataSourceRootPath(IDENTIFIER_PATTERN) +
"?", Pattern.CASE_INSENSITIVE).matcher(path).find();
}
}
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/DataSourceNodePersistService.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/DataSourceNodePersistService.java
index fabf578c6de..6327eb582e1 100644
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/DataSourceNodePersistService.java
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/DataSourceNodePersistService.java
@@ -54,10 +54,10 @@ public final class DataSourceNodePersistService {
*/
@SuppressWarnings("unchecked")
public Map<String, DataSourcePoolProperties> load(final String
databaseName) {
- Collection<String> childrenKeys =
repository.getChildrenKeys(DataSourceMetaDataNodePath.getDataSourceNodesPath(databaseName));
+ Collection<String> childrenKeys =
repository.getChildrenKeys(DataSourceMetaDataNodePath.getStorageNodesPath(databaseName));
Map<String, DataSourcePoolProperties> result = new
LinkedHashMap<>(childrenKeys.size(), 1F);
for (String each : childrenKeys) {
- String dataSourceValue =
repository.query(DataSourceMetaDataNodePath.getDataSourceNodeVersionPath(databaseName,
each, getDataSourceActiveVersion(databaseName, each)));
+ String dataSourceValue =
repository.query(DataSourceMetaDataNodePath.getStorageNodeVersionPath(databaseName,
each, getDataSourceActiveVersion(databaseName, each)));
if (!Strings.isNullOrEmpty(dataSourceValue)) {
result.put(each, new
YamlDataSourceConfigurationSwapper().swapToDataSourcePoolProperties(YamlEngine.unmarshal(dataSourceValue,
Map.class)));
}
@@ -74,7 +74,7 @@ public final class DataSourceNodePersistService {
*/
@SuppressWarnings("unchecked")
public DataSourcePoolProperties load(final String databaseName, final
String dataSourceName) {
- String dataSourceValue =
repository.query(DataSourceMetaDataNodePath.getDataSourceNodeVersionPath(databaseName,
dataSourceName, getDataSourceActiveVersion(databaseName, dataSourceName)));
+ String dataSourceValue =
repository.query(DataSourceMetaDataNodePath.getStorageNodeVersionPath(databaseName,
dataSourceName, getDataSourceActiveVersion(databaseName, dataSourceName)));
return new
YamlDataSourceConfigurationSwapper().swapToDataSourcePoolProperties(YamlEngine.unmarshal(dataSourceValue,
Map.class));
}
@@ -87,18 +87,18 @@ public final class DataSourceNodePersistService {
public void persist(final String databaseName, final Map<String,
DataSourcePoolProperties> dataSourceConfigs) {
for (Entry<String, DataSourcePoolProperties> entry :
dataSourceConfigs.entrySet()) {
String activeVersion = getDataSourceActiveVersion(databaseName,
entry.getKey());
- List<String> versions =
metaDataVersionPersistService.getVersions(DataSourceMetaDataNodePath.getDataSourceNodeVersionsPath(databaseName,
entry.getKey()));
-
repository.persist(DataSourceMetaDataNodePath.getDataSourceNodeVersionPath(databaseName,
entry.getKey(), versions.isEmpty()
+ List<String> versions =
metaDataVersionPersistService.getVersions(DataSourceMetaDataNodePath.getStorageNodeVersionsPath(databaseName,
entry.getKey()));
+
repository.persist(DataSourceMetaDataNodePath.getStorageNodeVersionPath(databaseName,
entry.getKey(), versions.isEmpty()
? MetaDataVersion.DEFAULT_VERSION
: String.valueOf(Integer.parseInt(versions.get(0)) + 1)),
YamlEngine.marshal(new
YamlDataSourceConfigurationSwapper().swapToMap(entry.getValue())));
if (Strings.isNullOrEmpty(activeVersion)) {
-
repository.persist(DataSourceMetaDataNodePath.getDataSourceNodeActiveVersionPath(databaseName,
entry.getKey()), MetaDataVersion.DEFAULT_VERSION);
+
repository.persist(DataSourceMetaDataNodePath.getStorageNodeActiveVersionPath(databaseName,
entry.getKey()), MetaDataVersion.DEFAULT_VERSION);
}
}
}
private String getDataSourceActiveVersion(final String databaseName, final
String dataSourceName) {
- return
repository.query(DataSourceMetaDataNodePath.getDataSourceNodeActiveVersionPath(databaseName,
dataSourceName));
+ return
repository.query(DataSourceMetaDataNodePath.getStorageNodeActiveVersionPath(databaseName,
dataSourceName));
}
/**
@@ -108,6 +108,6 @@ public final class DataSourceNodePersistService {
* @param dataSourceName data source name
*/
public void delete(final String databaseName, final String dataSourceName)
{
-
repository.delete(DataSourceMetaDataNodePath.getDataSourceNodePath(databaseName,
dataSourceName));
+
repository.delete(DataSourceMetaDataNodePath.getStorageNodePath(databaseName,
dataSourceName));
}
}
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/DataSourceUnitPersistService.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/DataSourceUnitPersistService.java
index 5fd34ee57c5..b546fe5fcba 100644
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/DataSourceUnitPersistService.java
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/service/config/database/DataSourceUnitPersistService.java
@@ -55,7 +55,7 @@ public final class DataSourceUnitPersistService {
* @return data source pool properties map
*/
public Map<String, DataSourcePoolProperties> load(final String
databaseName) {
- Collection<String> childrenKeys =
repository.getChildrenKeys(DataSourceMetaDataNodePath.getDataSourceUnitsPath(databaseName));
+ Collection<String> childrenKeys =
repository.getChildrenKeys(DataSourceMetaDataNodePath.getStorageUnitsPath(databaseName));
return childrenKeys.stream().collect(Collectors.toMap(each -> each,
each -> load(databaseName, each), (a, b) -> b, () -> new
LinkedHashMap<>(childrenKeys.size(), 1F)));
}
@@ -68,7 +68,7 @@ public final class DataSourceUnitPersistService {
*/
@SuppressWarnings("unchecked")
public DataSourcePoolProperties load(final String databaseName, final
String dataSourceName) {
- String dataSourceValue =
repository.query(DataSourceMetaDataNodePath.getDataSourceUnitVersionPath(databaseName,
dataSourceName, getDataSourceActiveVersion(databaseName, dataSourceName)));
+ String dataSourceValue =
repository.query(DataSourceMetaDataNodePath.getStorageUnitVersionPath(databaseName,
dataSourceName, getDataSourceActiveVersion(databaseName, dataSourceName)));
return new
YamlDataSourceConfigurationSwapper().swapToDataSourcePoolProperties(YamlEngine.unmarshal(dataSourceValue,
Map.class));
}
@@ -83,20 +83,20 @@ public final class DataSourceUnitPersistService {
Collection<MetaDataVersion> result = new LinkedList<>();
for (Entry<String, DataSourcePoolProperties> entry :
dataSourcePropsMap.entrySet()) {
String activeVersion = getDataSourceActiveVersion(databaseName,
entry.getKey());
- List<String> versions =
metaDataVersionPersistService.getVersions(DataSourceMetaDataNodePath.getDataSourceUnitVersionsPath(databaseName,
entry.getKey()));
+ List<String> versions =
metaDataVersionPersistService.getVersions(DataSourceMetaDataNodePath.getStorageUnitVersionsPath(databaseName,
entry.getKey()));
String nextActiveVersion = versions.isEmpty() ?
MetaDataVersion.DEFAULT_VERSION :
String.valueOf(Integer.parseInt(versions.get(0)) + 1);
-
repository.persist(DataSourceMetaDataNodePath.getDataSourceUnitVersionPath(databaseName,
entry.getKey(), nextActiveVersion),
+
repository.persist(DataSourceMetaDataNodePath.getStorageUnitVersionPath(databaseName,
entry.getKey(), nextActiveVersion),
YamlEngine.marshal(new
YamlDataSourceConfigurationSwapper().swapToMap(entry.getValue())));
if (Strings.isNullOrEmpty(activeVersion)) {
-
repository.persist(DataSourceMetaDataNodePath.getDataSourceUnitActiveVersionPath(databaseName,
entry.getKey()), MetaDataVersion.DEFAULT_VERSION);
+
repository.persist(DataSourceMetaDataNodePath.getStorageUnitActiveVersionPath(databaseName,
entry.getKey()), MetaDataVersion.DEFAULT_VERSION);
}
- result.add(new
MetaDataVersion(DataSourceMetaDataNodePath.getDataSourceUnitPath(databaseName,
entry.getKey()), activeVersion, nextActiveVersion));
+ result.add(new
MetaDataVersion(DataSourceMetaDataNodePath.getStorageUnitPath(databaseName,
entry.getKey()), activeVersion, nextActiveVersion));
}
return result;
}
private String getDataSourceActiveVersion(final String databaseName, final
String dataSourceName) {
- return
repository.query(DataSourceMetaDataNodePath.getDataSourceUnitActiveVersionPath(databaseName,
dataSourceName));
+ return
repository.query(DataSourceMetaDataNodePath.getStorageUnitActiveVersionPath(databaseName,
dataSourceName));
}
/**
@@ -106,6 +106,6 @@ public final class DataSourceUnitPersistService {
* @param dataSourceName data source name
*/
public void delete(final String databaseName, final String dataSourceName)
{
-
repository.delete(DataSourceMetaDataNodePath.getDataSourceUnitPath(databaseName,
dataSourceName));
+
repository.delete(DataSourceMetaDataNodePath.getStorageUnitPath(databaseName,
dataSourceName));
}
}
diff --git
a/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNodePathTest.java
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNodePathTest.java
index 778a54775ba..09f78de50fd 100644
---
a/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNodePathTest.java
+++
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNodePathTest.java
@@ -29,125 +29,110 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
class DataSourceMetaDataNodePathTest {
@Test
- void assertGetDataSourceUnitsPath() {
-
assertThat(DataSourceMetaDataNodePath.getDataSourceUnitsPath("foo_db"),
is("/metadata/foo_db/data_sources/units"));
+ void assertGetDataSourceRootPath() {
+ assertThat(DataSourceMetaDataNodePath.getDataSourceRootPath("foo_db"),
is("/metadata/foo_db/data_sources"));
}
@Test
- void assertGetDataSourceNodesPath() {
-
assertThat(DataSourceMetaDataNodePath.getDataSourceNodesPath("foo_db"),
is("/metadata/foo_db/data_sources/nodes"));
+ void assertGetStorageUnitsPath() {
+ assertThat(DataSourceMetaDataNodePath.getStorageUnitsPath("foo_db"),
is("/metadata/foo_db/data_sources/units"));
}
@Test
- void assertGetDataSourceUnitPath() {
- assertThat(DataSourceMetaDataNodePath.getDataSourceUnitPath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds"));
+ void assertGetStorageNodesPath() {
+ assertThat(DataSourceMetaDataNodePath.getStorageNodesPath("foo_db"),
is("/metadata/foo_db/data_sources/nodes"));
}
@Test
- void assertGetDataSourceNodePath() {
- assertThat(DataSourceMetaDataNodePath.getDataSourceNodePath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/nodes/foo_ds"));
+ void assertGetStorageUnitPath() {
+ assertThat(DataSourceMetaDataNodePath.getStorageUnitPath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds"));
}
@Test
- void assertGetDataSourceUnitVersionPath() {
-
assertThat(DataSourceMetaDataNodePath.getDataSourceUnitVersionPath("foo_db",
"foo_ds", "0"), is("/metadata/foo_db/data_sources/units/foo_ds/versions/0"));
+ void assertGetStorageNodePath() {
+ assertThat(DataSourceMetaDataNodePath.getStorageNodePath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/nodes/foo_ds"));
}
@Test
- void assertGetDataSourceUnitVersionsPath() {
-
assertThat(DataSourceMetaDataNodePath.getDataSourceUnitVersionsPath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds/versions"));
+ void assertGetStorageUnitVersionPath() {
+
assertThat(DataSourceMetaDataNodePath.getStorageUnitVersionPath("foo_db",
"foo_ds", "0"), is("/metadata/foo_db/data_sources/units/foo_ds/versions/0"));
}
@Test
- void assertGetDataSourceUnitActiveVersionPath() {
-
assertThat(DataSourceMetaDataNodePath.getDataSourceUnitActiveVersionPath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds/active_version"));
+ void assertGetStorageUnitVersionsPath() {
+
assertThat(DataSourceMetaDataNodePath.getStorageUnitVersionsPath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds/versions"));
}
@Test
- void assertGetDataSourceNodeVersionsPath() {
-
assertThat(DataSourceMetaDataNodePath.getDataSourceNodeVersionsPath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/nodes/foo_ds/versions"));
+ void assertGetStorageUnitActiveVersionPath() {
+
assertThat(DataSourceMetaDataNodePath.getStorageUnitActiveVersionPath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds/active_version"));
}
@Test
- void assertGetDataSourceNodeVersionPath() {
-
assertThat(DataSourceMetaDataNodePath.getDataSourceNodeVersionPath("foo_db",
"foo_ds", "1"), is("/metadata/foo_db/data_sources/nodes/foo_ds/versions/1"));
+ void assertGetStorageNodeVersionsPath() {
+
assertThat(DataSourceMetaDataNodePath.getStorageNodeVersionsPath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/nodes/foo_ds/versions"));
}
@Test
- void assertGetDataSourceNodeActiveVersionPath() {
-
assertThat(DataSourceMetaDataNodePath.getDataSourceNodeActiveVersionPath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/nodes/foo_ds/active_version"));
+ void assertGetStorageNodeVersionPath() {
+
assertThat(DataSourceMetaDataNodePath.getStorageNodeVersionPath("foo_db",
"foo_ds", "1"), is("/metadata/foo_db/data_sources/nodes/foo_ds/versions/1"));
}
@Test
- void assertIsDataSourcesPath() {
-
assertTrue(DataSourceMetaDataNodePath.isDataSourcesPath("/metadata/logic_db/data_sources/foo_ds"));
+ void assertGetStorageNodeActiveVersionPath() {
+
assertThat(DataSourceMetaDataNodePath.getStorageNodeActiveVersionPath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/nodes/foo_ds/active_version"));
}
@Test
- void assertFindDataSourceNameByDataSourceUnitActiveVersionPath() {
- Optional<String> actual =
DataSourceMetaDataNodePath.findDataSourceNameByDataSourceUnitActiveVersionPath("/metadata/logic_db/data_sources/units/foo_ds/active_version");
+ void assertFindStorageUnitNameByActiveVersionPath() {
+ Optional<String> actual =
DataSourceMetaDataNodePath.findStorageUnitNameByActiveVersionPath("/metadata/foo_db/data_sources/units/foo_ds/active_version");
assertTrue(actual.isPresent());
assertThat(actual.get(), is("foo_ds"));
}
@Test
- void assertFindDataSourceNameByDataSourceUnitActiveVersionPathIfNotFound()
{
-
assertFalse(DataSourceMetaDataNodePath.findDataSourceNameByDataSourceUnitActiveVersionPath("/xxx/logic_db/data_sources/units/foo_ds/active_version").isPresent());
+ void assertFindStorageUnitNameByActiveVersionPathIfNotFound() {
+
assertFalse(DataSourceMetaDataNodePath.findStorageUnitNameByActiveVersionPath("/xxx/foo_db/data_sources/units/foo_ds/active_version").isPresent());
}
@Test
- void assertFindDataSourceNameByDataSourceUnitPath() {
- Optional<String> actual =
DataSourceMetaDataNodePath.findDataSourceNameByDataSourceUnitPath("/metadata/logic_db/data_sources/units/foo_ds");
+ void assertFindStorageUnitNameByStorageUnitPath() {
+ Optional<String> actual =
DataSourceMetaDataNodePath.findStorageUnitNameByStorageUnitPath("/metadata/foo_db/data_sources/units/foo_ds");
assertTrue(actual.isPresent());
assertThat(actual.get(), is("foo_ds"));
}
@Test
- void assertFindDataSourceNameByDataSourceUnitPathIfNotFound() {
-
assertFalse(DataSourceMetaDataNodePath.findDataSourceNameByDataSourceUnitPath("/xxx/logic_db/data_sources/units/foo_ds").isPresent());
+ void assertFindStorageUnitNameByStorageUnitPathIfNotFound() {
+
assertFalse(DataSourceMetaDataNodePath.findStorageUnitNameByStorageUnitPath("/xxx/foo_db/data_sources/units/foo_ds").isPresent());
}
@Test
- void assertFindDataSourceNameByDataSourceNodeActiveVersionPath() {
- Optional<String> actual =
DataSourceMetaDataNodePath.findDataSourceNameByDataSourceNodeActiveVersionPath("/metadata/logic_db/data_sources/nodes/foo_ds/active_version");
+ void assertFindStorageNodeNameByActiveVersionPath() {
+ Optional<String> actual =
DataSourceMetaDataNodePath.findStorageNodeNameByActiveVersionPath("/metadata/foo_db/data_sources/nodes/foo_ds/active_version");
assertTrue(actual.isPresent());
assertThat(actual.get(), is("foo_ds"));
}
@Test
- void assertFindDataSourceNameByDataSourceNodeActiveVersionPathIfNotFound()
{
-
assertFalse(DataSourceMetaDataNodePath.findDataSourceNameByDataSourceNodeActiveVersionPath("/xxx/logic_db/data_sources/nodes/foo_ds/active_version").isPresent());
+ void assertFindStorageNodeNameByActiveVersionPathIfNotFound() {
+
assertFalse(DataSourceMetaDataNodePath.findStorageNodeNameByActiveVersionPath("/xxx/foo_db/data_sources/nodes/foo_ds/active_version").isPresent());
}
@Test
- void assertFindDataSourceNameByDataSourceNodePath() {
- Optional<String> actual =
DataSourceMetaDataNodePath.findDataSourceNameByDataSourceNodePath("/metadata/logic_db/data_sources/nodes/foo_ds");
+ void assertFindStorageNodeNameByStorageNodePath() {
+ Optional<String> actual =
DataSourceMetaDataNodePath.findStorageNodeNameByStorageNodePath("/metadata/foo_db/data_sources/nodes/foo_ds");
assertTrue(actual.isPresent());
assertThat(actual.get(), is("foo_ds"));
}
@Test
- void assertFindDataSourceNameByDataSourceNodePathIfNotFound() {
-
assertFalse(DataSourceMetaDataNodePath.findDataSourceNameByDataSourceNodePath("/xxx/logic_db/data_sources/nodes/foo_ds").isPresent());
+ void assertFindStorageNodeNameByStorageNodePathIfNotFound() {
+
assertFalse(DataSourceMetaDataNodePath.findStorageNodeNameByStorageNodePath("/xxx/foo_db/data_sources/nodes/foo_ds").isPresent());
}
@Test
- void assertIsDataSourceUnitActiveVersionPath() {
-
assertTrue(DataSourceMetaDataNodePath.isDataSourceUnitActiveVersionPath("/metadata/logic_db/data_sources/units/foo_ds/active_version"));
- }
-
- @Test
- void assertIsDataSourceUnitPath() {
-
assertTrue(DataSourceMetaDataNodePath.isDataSourceUnitPath("/metadata/logic_db/data_sources/units/foo_ds"));
- }
-
- @Test
- void assertIsDataSourceNodeActiveVersionPath() {
-
assertTrue(DataSourceMetaDataNodePath.isDataSourceNodeActiveVersionPath("/metadata/logic_db/data_sources/nodes/foo_ds/active_version"));
- }
-
- @Test
- void assertIsDataSourceNodePath() {
-
assertTrue(DataSourceMetaDataNodePath.isDataSourceNodePath("/metadata/logic_db/data_sources/nodes/foo_ds"));
+ void assertIsDataSourceRootPath() {
+
assertTrue(DataSourceMetaDataNodePath.isDataSourceRootPath("/metadata/foo_db/data_sources/foo_ds"));
}
}
diff --git
a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/database/metadata/MetaDataChangedHandler.java
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/database/metadata/MetaDataChangedHandler.java
index 7126140b057..165a9686c18 100644
---
a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/database/metadata/MetaDataChangedHandler.java
+++
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/dispatch/handler/database/metadata/MetaDataChangedHandler.java
@@ -73,7 +73,7 @@ public final class MetaDataChangedHandler {
handleViewChanged(databaseName, schemaName.get(), event);
return true;
}
- if (DataSourceMetaDataNodePath.isDataSourcesPath(eventKey)) {
+ if (DataSourceMetaDataNodePath.isDataSourceRootPath(eventKey)) {
handleDataSourceChanged(databaseName, event);
return true;
}
@@ -113,42 +113,52 @@ public final class MetaDataChangedHandler {
}
private void handleDataSourceChanged(final String databaseName, final
DataChangedEvent event) {
- if
(DataSourceMetaDataNodePath.isDataSourceUnitActiveVersionPath(event.getKey())
|| DataSourceMetaDataNodePath.isDataSourceUnitPath(event.getKey())) {
- handleStorageUnitChanged(databaseName, event);
- } else if
(DataSourceMetaDataNodePath.isDataSourceNodeActiveVersionPath(event.getKey())
|| DataSourceMetaDataNodePath.isDataSourceNodePath(event.getKey())) {
- handleStorageNodeChanged(databaseName, event);
+ Optional<String> storageUnitName =
DataSourceMetaDataNodePath.findStorageUnitNameByActiveVersionPath(event.getKey());
+ boolean isActiveVersion = true;
+ if (!storageUnitName.isPresent()) {
+ storageUnitName =
DataSourceMetaDataNodePath.findStorageUnitNameByStorageUnitPath(event.getKey());
+ isActiveVersion = false;
+ }
+ if (storageUnitName.isPresent()) {
+ handleStorageUnitChanged(databaseName, event,
storageUnitName.get(), isActiveVersion);
+ return;
+ }
+ Optional<String> storageNodeName =
DataSourceMetaDataNodePath.findStorageNodeNameByActiveVersionPath(event.getKey());
+ isActiveVersion = true;
+ if (!storageNodeName.isPresent()) {
+ storageNodeName =
DataSourceMetaDataNodePath.findStorageNodeNameByStorageNodePath(event.getKey());
+ isActiveVersion = false;
+ }
+ if (storageNodeName.isPresent()) {
+ handleStorageNodeChanged(databaseName, event,
storageNodeName.get(), isActiveVersion);
}
}
- private void handleStorageUnitChanged(final String databaseName, final
DataChangedEvent event) {
- Optional<String> dataSourceUnitName =
DataSourceMetaDataNodePath.findDataSourceNameByDataSourceUnitActiveVersionPath(event.getKey());
- if (dataSourceUnitName.isPresent()) {
+ private void handleStorageUnitChanged(final String databaseName, final
DataChangedEvent event, final String storageUnitName, final boolean
isActiveVersion) {
+ if (isActiveVersion) {
if (Type.ADDED == event.getType()) {
- storageUnitChangedHandler.handleRegistered(databaseName,
dataSourceUnitName.get(), event);
+ storageUnitChangedHandler.handleRegistered(databaseName,
storageUnitName, event);
} else if (Type.UPDATED == event.getType()) {
- storageUnitChangedHandler.handleAltered(databaseName,
dataSourceUnitName.get(), event);
+ storageUnitChangedHandler.handleAltered(databaseName,
storageUnitName, event);
}
return;
}
- dataSourceUnitName =
DataSourceMetaDataNodePath.findDataSourceNameByDataSourceUnitPath(event.getKey());
- if (Type.DELETED == event.getType() && dataSourceUnitName.isPresent())
{
- storageUnitChangedHandler.handleUnregistered(databaseName,
dataSourceUnitName.get());
+ if (Type.DELETED == event.getType()) {
+ storageUnitChangedHandler.handleUnregistered(databaseName,
storageUnitName);
}
}
- private void handleStorageNodeChanged(final String databaseName, final
DataChangedEvent event) {
- Optional<String> dataSourceNodeName =
DataSourceMetaDataNodePath.findDataSourceNameByDataSourceNodeActiveVersionPath(event.getKey());
- if (dataSourceNodeName.isPresent()) {
+ private void handleStorageNodeChanged(final String databaseName, final
DataChangedEvent event, final String storageNodeName, final boolean
isActiveVersion) {
+ if (isActiveVersion) {
if (Type.ADDED == event.getType()) {
- storageNodeChangedHandler.handleRegistered(databaseName,
dataSourceNodeName.get(), event);
+ storageNodeChangedHandler.handleRegistered(databaseName,
storageNodeName, event);
} else if (Type.UPDATED == event.getType()) {
- storageNodeChangedHandler.handleAltered(databaseName,
dataSourceNodeName.get(), event);
+ storageNodeChangedHandler.handleAltered(databaseName,
storageNodeName, event);
}
return;
}
- dataSourceNodeName =
DataSourceMetaDataNodePath.findDataSourceNameByDataSourceNodePath(event.getKey());
- if (Type.DELETED == event.getType() && dataSourceNodeName.isPresent())
{
- storageNodeChangedHandler.handleUnregistered(databaseName,
dataSourceNodeName.get());
+ if (Type.DELETED == event.getType()) {
+ storageNodeChangedHandler.handleUnregistered(databaseName,
storageNodeName);
}
}
}
