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 801a9dc51d3 Refactor DataSourceMetaDataNodePath (#34277)
801a9dc51d3 is described below
commit 801a9dc51d3660b42918ddd054bd5c158871716b
Author: Liang Zhang <[email protected]>
AuthorDate: Wed Jan 8 01:58:45 2025 +0800
Refactor DataSourceMetaDataNodePath (#34277)
---
.../node/metadata/DataSourceMetaDataNode.java | 262 ---------------------
.../node/metadata/DataSourceMetaDataNodePath.java | 258 ++++++++++++++++++++
.../database/DataSourceNodePersistService.java | 18 +-
.../database/DataSourceUnitPersistService.java | 18 +-
.../metadata/DataSourceMetaDataNodePathTest.java | 153 ++++++++++++
.../node/metadata/DataSourceMetaDataNodeTest.java | 153 ------------
.../database/metadata/MetaDataChangedHandler.java | 16 +-
7 files changed, 437 insertions(+), 441 deletions(-)
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNode.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNode.java
deleted file mode 100644
index f87855d8917..00000000000
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNode.java
+++ /dev/null
@@ -1,262 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.shardingsphere.metadata.persist.node.metadata;
-
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
-
-import java.util.Optional;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-/**
- * Data source meta data node.
- */
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
-public final class DataSourceMetaDataNode {
-
- private static final String ROOT_NODE = "metadata";
-
- private static final String DATA_SOURCES_NODE = "data_sources";
-
- private static final String DATA_SOURCE_NODES_NODE = "nodes";
-
- private static final String DATA_SOURCE_UNITS_NODE = "units";
-
- private static final String ACTIVE_VERSION = "active_version";
-
- private static final String VERSIONS = "versions";
-
- 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\\-]+)$";
-
- /**
- * Get data source units node.
- *
- * @param databaseName database name
- * @return data sources node
- */
- public static String getDataSourceUnitsNode(final String databaseName) {
- return String.join("/", getMetaDataNode(), databaseName,
DATA_SOURCES_NODE, DATA_SOURCE_UNITS_NODE);
- }
-
- /**
- * Get data source nodes node.
- *
- * @param databaseName database name
- * @return data sources node
- */
- public static String getDataSourceNodesNode(final String databaseName) {
- return String.join("/", getMetaDataNode(), databaseName,
DATA_SOURCES_NODE, DATA_SOURCE_NODES_NODE);
- }
-
- /**
- * Get data source unit node.
- *
- * @param databaseName database name
- * @param dataSourceName data source name
- * @return data source node
- */
- public static String getDataSourceUnitNode(final String databaseName,
final String dataSourceName) {
- return String.join("/", getDataSourceUnitsNode(databaseName),
dataSourceName);
- }
-
- /**
- * Get data source node node.
- *
- * @param databaseName database name
- * @param dataSourceName data source name
- * @return data source node
- */
- public static String getDataSourceNodeNode(final String databaseName,
final String dataSourceName) {
- return String.join("/", getDataSourceNodesNode(databaseName),
dataSourceName);
- }
-
- /**
- * Get data source unit version node.
- *
- * @param databaseName database name
- * @param dataSourceName data source name
- * @param version version
- * @return data source unit version node
- */
- public static String getDataSourceUnitVersionNode(final String
databaseName, final String dataSourceName, final String version) {
- return String.join("/", getDataSourceUnitVersionsNode(databaseName,
dataSourceName), version);
- }
-
- /**
- * Get data source unit versions node.
- *
- * @param databaseName database name
- * @param dataSourceName data source name
- * @return data source versions node
- */
- public static String getDataSourceUnitVersionsNode(final String
databaseName, final String dataSourceName) {
- return String.join("/", getDataSourceUnitsNode(databaseName),
dataSourceName, VERSIONS);
- }
-
- /**
- * Get data source unit active version node.
- *
- * @param databaseName database name
- * @param dataSourceName data source name
- * @return data source active version node
- */
- public static String getDataSourceUnitActiveVersionNode(final String
databaseName, final String dataSourceName) {
- return String.join("/", getDataSourceUnitsNode(databaseName),
dataSourceName, ACTIVE_VERSION);
- }
-
- /**
- * Get data source node versions node.
- *
- * @param databaseName database name
- * @param dataSourceName data source name
- * @return data source versions node
- */
- public static String getDataSourceNodeVersionsNode(final String
databaseName, final String dataSourceName) {
- return String.join("/", getDataSourceNodesNode(databaseName),
dataSourceName, VERSIONS);
- }
-
- /**
- * Get data source node version node.
- *
- * @param databaseName database name
- * @param dataSourceName data source name
- * @param version version
- * @return data source node version node
- */
- public static String getDataSourceNodeVersionNode(final String
databaseName, final String dataSourceName, final String version) {
- return String.join("/", getDataSourceNodeVersionsNode(databaseName,
dataSourceName), version);
- }
-
- /**
- * Get data source node active version node.
- *
- * @param databaseName database name
- * @param dataSourceName data source name
- * @return data source active version node
- */
- public static String getDataSourceNodeActiveVersionNode(final String
databaseName, final String dataSourceName) {
- return String.join("/", getDataSourceNodesNode(databaseName),
dataSourceName, ACTIVE_VERSION);
- }
-
- /**
- * Is data sources node.
- *
- * @param path path
- * @return true or false
- */
- public static boolean isDataSourcesNode(final String path) {
- return Pattern.compile(getMetaDataNode() + DATABASE_DATA_SOURCES_NODE
+ "?", Pattern.CASE_INSENSITIVE).matcher(path).find();
- }
-
- /**
- * Get data source name by data source unit active version node.
- *
- * @param path path
- * @return data source name
- */
- public static Optional<String>
getDataSourceNameByDataSourceUnitActiveVersionNode(final String path) {
- Pattern pattern = Pattern.compile(getMetaDataNode() +
DATABASE_DATA_SOURCES_NODE + DATA_SOURCE_UNITS_NODE + ACTIVE_VERSION_SUFFIX,
Pattern.CASE_INSENSITIVE);
- Matcher matcher = pattern.matcher(path);
- return matcher.find() ? Optional.of(matcher.group(2)) :
Optional.empty();
- }
-
- /**
- * Get data source name by data source unit node.
- *
- * @param path path
- * @return data source name
- */
- public static Optional<String> getDataSourceNameByDataSourceUnitNode(final
String path) {
- Pattern pattern = Pattern.compile(getMetaDataNode() +
DATABASE_DATA_SOURCES_NODE + DATA_SOURCE_UNITS_NODE + DATA_SOURCE_SUFFIX,
Pattern.CASE_INSENSITIVE);
- Matcher matcher = pattern.matcher(path);
- return matcher.find() ? Optional.of(matcher.group(2)) :
Optional.empty();
- }
-
- /**
- * Get data source name by data source node active version node.
- *
- * @param path path
- * @return data source name
- */
- public static Optional<String>
getDataSourceNameByDataSourceNodeActiveVersionNode(final String path) {
- Pattern pattern = Pattern.compile(getMetaDataNode() +
DATABASE_DATA_SOURCES_NODE + DATA_SOURCE_NODES_NODE + ACTIVE_VERSION_SUFFIX,
Pattern.CASE_INSENSITIVE);
- Matcher matcher = pattern.matcher(path);
- return matcher.find() ? Optional.of(matcher.group(2)) :
Optional.empty();
- }
-
- /**
- * Get data source name by data source node.
- *
- * @param path path
- * @return data source name
- */
- public static Optional<String> getDataSourceNameByDataSourceNodeNode(final
String path) {
- Pattern pattern = Pattern.compile(getMetaDataNode() +
DATABASE_DATA_SOURCES_NODE + DATA_SOURCE_NODES_NODE + DATA_SOURCE_SUFFIX,
Pattern.CASE_INSENSITIVE);
- Matcher matcher = pattern.matcher(path);
- return matcher.find() ? Optional.of(matcher.group(2)) :
Optional.empty();
- }
-
- /**
- * Is data source unit active version node.
- *
- * @param path path
- * @return true or false
- */
- public static boolean isDataSourceUnitActiveVersionNode(final String path)
{
- return Pattern.compile(getMetaDataNode() + DATABASE_DATA_SOURCES_NODE
+ DATA_SOURCE_UNITS_NODE + ACTIVE_VERSION_SUFFIX,
Pattern.CASE_INSENSITIVE).matcher(path).find();
- }
-
- /**
- * Is data source unit node.
- *
- * @param path path
- * @return true or false
- */
- public static boolean isDataSourceUnitNode(final String path) {
- return Pattern.compile(getMetaDataNode() + DATABASE_DATA_SOURCES_NODE
+ DATA_SOURCE_UNITS_NODE + DATA_SOURCE_SUFFIX,
Pattern.CASE_INSENSITIVE).matcher(path).find();
- }
-
- /**
- * Is data source node active version node.
- *
- * @param path path
- * @return true or false
- */
- public static boolean isDataSourceNodeActiveVersionNode(final String path)
{
- return Pattern.compile(getMetaDataNode() + DATABASE_DATA_SOURCES_NODE
+ DATA_SOURCE_NODES_NODE + ACTIVE_VERSION_SUFFIX,
Pattern.CASE_INSENSITIVE).matcher(path).find();
- }
-
- /**
- * Is data source node node.
- *
- * @param path path
- * @return true or false
- */
- public static boolean isDataSourceNodeNode(final String path) {
- return Pattern.compile(getMetaDataNode() + DATABASE_DATA_SOURCES_NODE
+ DATA_SOURCE_NODES_NODE + DATA_SOURCE_SUFFIX,
Pattern.CASE_INSENSITIVE).matcher(path).find();
- }
-
- private static String getMetaDataNode() {
- return String.join("/", "", ROOT_NODE);
- }
-}
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
new file mode 100644
index 00000000000..c04edad6b8b
--- /dev/null
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNodePath.java
@@ -0,0 +1,258 @@
+/*
+ * 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.node.metadata;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Data source meta data node path.
+ */
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class DataSourceMetaDataNodePath {
+
+ private static final String ROOT_NODE = "/metadata";
+
+ private static final String DATA_SOURCES_NODE = "data_sources";
+
+ private static final String DATA_SOURCE_NODES_NODE = "nodes";
+
+ private static final String DATA_SOURCE_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\\-]+)$";
+
+ /**
+ * Get data source units path.
+ *
+ * @param databaseName database name
+ * @return data sources path
+ */
+ public static String getDataSourceUnitsPath(final String databaseName) {
+ return String.join("/", ROOT_NODE, databaseName, DATA_SOURCES_NODE,
DATA_SOURCE_UNITS_NODE);
+ }
+
+ /**
+ * Get data source nodes path.
+ *
+ * @param databaseName database name
+ * @return data sources path
+ */
+ public static String getDataSourceNodesPath(final String databaseName) {
+ return String.join("/", ROOT_NODE, databaseName, DATA_SOURCES_NODE,
DATA_SOURCE_NODES_NODE);
+ }
+
+ /**
+ * Get data source unit path.
+ *
+ * @param databaseName database name
+ * @param dataSourceName data source name
+ * @return data source path
+ */
+ public static String getDataSourceUnitPath(final String databaseName,
final String dataSourceName) {
+ return String.join("/", getDataSourceUnitsPath(databaseName),
dataSourceName);
+ }
+
+ /**
+ * Get data source node path.
+ *
+ * @param databaseName database name
+ * @param dataSourceName data source name
+ * @return data source path
+ */
+ public static String getDataSourceNodePath(final String databaseName,
final String dataSourceName) {
+ return String.join("/", getDataSourceNodesPath(databaseName),
dataSourceName);
+ }
+
+ /**
+ * Get data source unit version path.
+ *
+ * @param databaseName database name
+ * @param dataSourceName data source name
+ * @param version version
+ * @return data source unit version path
+ */
+ public static String getDataSourceUnitVersionPath(final String
databaseName, final String dataSourceName, final String version) {
+ return String.join("/", getDataSourceUnitVersionsPath(databaseName,
dataSourceName), version);
+ }
+
+ /**
+ * Get data source unit versions path.
+ *
+ * @param databaseName database name
+ * @param dataSourceName data source name
+ * @return data source versions path
+ */
+ public static String getDataSourceUnitVersionsPath(final String
databaseName, final String dataSourceName) {
+ return String.join("/", getDataSourceUnitsPath(databaseName),
dataSourceName, VERSIONS_NODE);
+ }
+
+ /**
+ * Get data source unit active version path.
+ *
+ * @param databaseName database name
+ * @param dataSourceName data source name
+ * @return data source active version path
+ */
+ public static String getDataSourceUnitActiveVersionPath(final String
databaseName, final String dataSourceName) {
+ return String.join("/", getDataSourceUnitsPath(databaseName),
dataSourceName, ACTIVE_VERSION_NODE);
+ }
+
+ /**
+ * Get data source node versions path.
+ *
+ * @param databaseName database name
+ * @param dataSourceName data source name
+ * @return data source versions path
+ */
+ public static String getDataSourceNodeVersionsPath(final String
databaseName, final String dataSourceName) {
+ return String.join("/", getDataSourceNodesPath(databaseName),
dataSourceName, VERSIONS_NODE);
+ }
+
+ /**
+ * Get data source node version path.
+ *
+ * @param databaseName database name
+ * @param dataSourceName data source name
+ * @param version version
+ * @return data source node version path
+ */
+ public static String getDataSourceNodeVersionPath(final String
databaseName, final String dataSourceName, final String version) {
+ return String.join("/", getDataSourceNodeVersionsPath(databaseName,
dataSourceName), version);
+ }
+
+ /**
+ * Get data source node active version path.
+ *
+ * @param databaseName database name
+ * @param dataSourceName data source name
+ * @return data source active version path
+ */
+ public static String getDataSourceNodeActiveVersionPath(final String
databaseName, final String dataSourceName) {
+ return String.join("/", getDataSourceNodesPath(databaseName),
dataSourceName, ACTIVE_VERSION_NODE);
+ }
+
+ /**
+ * Is data sources path.
+ *
+ * @param path path
+ * @return true or false
+ */
+ public static boolean isDataSourcesPath(final String path) {
+ return Pattern.compile(ROOT_NODE + DATABASE_DATA_SOURCES_NODE + "?",
Pattern.CASE_INSENSITIVE).matcher(path).find();
+ }
+
+ /**
+ * Find data source name by data source unit active version path.
+ *
+ * @param path path
+ * @return found data source 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);
+ Matcher matcher = pattern.matcher(path);
+ return matcher.find() ? Optional.of(matcher.group(2)) :
Optional.empty();
+ }
+
+ /**
+ * Find data source name by data source unit path.
+ *
+ * @param path path
+ * @return data source 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);
+ 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.
+ *
+ * @param path path
+ * @return data source 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);
+ Matcher matcher = pattern.matcher(path);
+ return matcher.find() ? Optional.of(matcher.group(2)) :
Optional.empty();
+ }
+
+ /**
+ * Find data source name by data source path.
+ *
+ * @param path path
+ * @return data source 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);
+ 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.
+ *
+ * @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();
+ }
+}
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 1090edfc2b5..fabf578c6de 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
@@ -22,7 +22,7 @@ import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePo
import org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
import org.apache.shardingsphere.infra.util.yaml.YamlEngine;
import
org.apache.shardingsphere.infra.yaml.config.swapper.resource.YamlDataSourceConfigurationSwapper;
-import
org.apache.shardingsphere.metadata.persist.node.metadata.DataSourceMetaDataNode;
+import
org.apache.shardingsphere.metadata.persist.node.metadata.DataSourceMetaDataNodePath;
import
org.apache.shardingsphere.metadata.persist.service.version.MetaDataVersionPersistService;
import org.apache.shardingsphere.mode.spi.PersistRepository;
@@ -54,10 +54,10 @@ public final class DataSourceNodePersistService {
*/
@SuppressWarnings("unchecked")
public Map<String, DataSourcePoolProperties> load(final String
databaseName) {
- Collection<String> childrenKeys =
repository.getChildrenKeys(DataSourceMetaDataNode.getDataSourceNodesNode(databaseName));
+ Collection<String> childrenKeys =
repository.getChildrenKeys(DataSourceMetaDataNodePath.getDataSourceNodesPath(databaseName));
Map<String, DataSourcePoolProperties> result = new
LinkedHashMap<>(childrenKeys.size(), 1F);
for (String each : childrenKeys) {
- String dataSourceValue =
repository.query(DataSourceMetaDataNode.getDataSourceNodeVersionNode(databaseName,
each, getDataSourceActiveVersion(databaseName, each)));
+ String dataSourceValue =
repository.query(DataSourceMetaDataNodePath.getDataSourceNodeVersionPath(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(DataSourceMetaDataNode.getDataSourceNodeVersionNode(databaseName,
dataSourceName, getDataSourceActiveVersion(databaseName, dataSourceName)));
+ String dataSourceValue =
repository.query(DataSourceMetaDataNodePath.getDataSourceNodeVersionPath(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(DataSourceMetaDataNode.getDataSourceNodeVersionsNode(databaseName,
entry.getKey()));
-
repository.persist(DataSourceMetaDataNode.getDataSourceNodeVersionNode(databaseName,
entry.getKey(), versions.isEmpty()
+ List<String> versions =
metaDataVersionPersistService.getVersions(DataSourceMetaDataNodePath.getDataSourceNodeVersionsPath(databaseName,
entry.getKey()));
+
repository.persist(DataSourceMetaDataNodePath.getDataSourceNodeVersionPath(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(DataSourceMetaDataNode.getDataSourceNodeActiveVersionNode(databaseName,
entry.getKey()), MetaDataVersion.DEFAULT_VERSION);
+
repository.persist(DataSourceMetaDataNodePath.getDataSourceNodeActiveVersionPath(databaseName,
entry.getKey()), MetaDataVersion.DEFAULT_VERSION);
}
}
}
private String getDataSourceActiveVersion(final String databaseName, final
String dataSourceName) {
- return
repository.query(DataSourceMetaDataNode.getDataSourceNodeActiveVersionNode(databaseName,
dataSourceName));
+ return
repository.query(DataSourceMetaDataNodePath.getDataSourceNodeActiveVersionPath(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(DataSourceMetaDataNode.getDataSourceNodeNode(databaseName,
dataSourceName));
+
repository.delete(DataSourceMetaDataNodePath.getDataSourceNodePath(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 4e9a4cc2b98..5fd34ee57c5 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
@@ -22,7 +22,7 @@ import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePo
import org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
import org.apache.shardingsphere.infra.util.yaml.YamlEngine;
import
org.apache.shardingsphere.infra.yaml.config.swapper.resource.YamlDataSourceConfigurationSwapper;
-import
org.apache.shardingsphere.metadata.persist.node.metadata.DataSourceMetaDataNode;
+import
org.apache.shardingsphere.metadata.persist.node.metadata.DataSourceMetaDataNodePath;
import
org.apache.shardingsphere.metadata.persist.service.version.MetaDataVersionPersistService;
import org.apache.shardingsphere.mode.spi.PersistRepository;
@@ -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(DataSourceMetaDataNode.getDataSourceUnitsNode(databaseName));
+ Collection<String> childrenKeys =
repository.getChildrenKeys(DataSourceMetaDataNodePath.getDataSourceUnitsPath(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(DataSourceMetaDataNode.getDataSourceUnitVersionNode(databaseName,
dataSourceName, getDataSourceActiveVersion(databaseName, dataSourceName)));
+ String dataSourceValue =
repository.query(DataSourceMetaDataNodePath.getDataSourceUnitVersionPath(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(DataSourceMetaDataNode.getDataSourceUnitVersionsNode(databaseName,
entry.getKey()));
+ List<String> versions =
metaDataVersionPersistService.getVersions(DataSourceMetaDataNodePath.getDataSourceUnitVersionsPath(databaseName,
entry.getKey()));
String nextActiveVersion = versions.isEmpty() ?
MetaDataVersion.DEFAULT_VERSION :
String.valueOf(Integer.parseInt(versions.get(0)) + 1);
-
repository.persist(DataSourceMetaDataNode.getDataSourceUnitVersionNode(databaseName,
entry.getKey(), nextActiveVersion),
+
repository.persist(DataSourceMetaDataNodePath.getDataSourceUnitVersionPath(databaseName,
entry.getKey(), nextActiveVersion),
YamlEngine.marshal(new
YamlDataSourceConfigurationSwapper().swapToMap(entry.getValue())));
if (Strings.isNullOrEmpty(activeVersion)) {
-
repository.persist(DataSourceMetaDataNode.getDataSourceUnitActiveVersionNode(databaseName,
entry.getKey()), MetaDataVersion.DEFAULT_VERSION);
+
repository.persist(DataSourceMetaDataNodePath.getDataSourceUnitActiveVersionPath(databaseName,
entry.getKey()), MetaDataVersion.DEFAULT_VERSION);
}
- result.add(new
MetaDataVersion(DataSourceMetaDataNode.getDataSourceUnitNode(databaseName,
entry.getKey()), activeVersion, nextActiveVersion));
+ result.add(new
MetaDataVersion(DataSourceMetaDataNodePath.getDataSourceUnitPath(databaseName,
entry.getKey()), activeVersion, nextActiveVersion));
}
return result;
}
private String getDataSourceActiveVersion(final String databaseName, final
String dataSourceName) {
- return
repository.query(DataSourceMetaDataNode.getDataSourceUnitActiveVersionNode(databaseName,
dataSourceName));
+ return
repository.query(DataSourceMetaDataNodePath.getDataSourceUnitActiveVersionPath(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(DataSourceMetaDataNode.getDataSourceUnitNode(databaseName,
dataSourceName));
+
repository.delete(DataSourceMetaDataNodePath.getDataSourceUnitPath(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
new file mode 100644
index 00000000000..778a54775ba
--- /dev/null
+++
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNodePathTest.java
@@ -0,0 +1,153 @@
+/*
+ * 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.node.metadata;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+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"));
+ }
+
+ @Test
+ void assertGetDataSourceNodesPath() {
+
assertThat(DataSourceMetaDataNodePath.getDataSourceNodesPath("foo_db"),
is("/metadata/foo_db/data_sources/nodes"));
+ }
+
+ @Test
+ void assertGetDataSourceUnitPath() {
+ assertThat(DataSourceMetaDataNodePath.getDataSourceUnitPath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds"));
+ }
+
+ @Test
+ void assertGetDataSourceNodePath() {
+ assertThat(DataSourceMetaDataNodePath.getDataSourceNodePath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/nodes/foo_ds"));
+ }
+
+ @Test
+ void assertGetDataSourceUnitVersionPath() {
+
assertThat(DataSourceMetaDataNodePath.getDataSourceUnitVersionPath("foo_db",
"foo_ds", "0"), is("/metadata/foo_db/data_sources/units/foo_ds/versions/0"));
+ }
+
+ @Test
+ void assertGetDataSourceUnitVersionsPath() {
+
assertThat(DataSourceMetaDataNodePath.getDataSourceUnitVersionsPath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds/versions"));
+ }
+
+ @Test
+ void assertGetDataSourceUnitActiveVersionPath() {
+
assertThat(DataSourceMetaDataNodePath.getDataSourceUnitActiveVersionPath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds/active_version"));
+ }
+
+ @Test
+ void assertGetDataSourceNodeVersionsPath() {
+
assertThat(DataSourceMetaDataNodePath.getDataSourceNodeVersionsPath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/nodes/foo_ds/versions"));
+ }
+
+ @Test
+ void assertGetDataSourceNodeVersionPath() {
+
assertThat(DataSourceMetaDataNodePath.getDataSourceNodeVersionPath("foo_db",
"foo_ds", "1"), is("/metadata/foo_db/data_sources/nodes/foo_ds/versions/1"));
+ }
+
+ @Test
+ void assertGetDataSourceNodeActiveVersionPath() {
+
assertThat(DataSourceMetaDataNodePath.getDataSourceNodeActiveVersionPath("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/nodes/foo_ds/active_version"));
+ }
+
+ @Test
+ void assertIsDataSourcesPath() {
+
assertTrue(DataSourceMetaDataNodePath.isDataSourcesPath("/metadata/logic_db/data_sources/foo_ds"));
+ }
+
+ @Test
+ void assertFindDataSourceNameByDataSourceUnitActiveVersionPath() {
+ Optional<String> actual =
DataSourceMetaDataNodePath.findDataSourceNameByDataSourceUnitActiveVersionPath("/metadata/logic_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());
+ }
+
+ @Test
+ void assertFindDataSourceNameByDataSourceUnitPath() {
+ Optional<String> actual =
DataSourceMetaDataNodePath.findDataSourceNameByDataSourceUnitPath("/metadata/logic_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());
+ }
+
+ @Test
+ void assertFindDataSourceNameByDataSourceNodeActiveVersionPath() {
+ Optional<String> actual =
DataSourceMetaDataNodePath.findDataSourceNameByDataSourceNodeActiveVersionPath("/metadata/logic_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());
+ }
+
+ @Test
+ void assertFindDataSourceNameByDataSourceNodePath() {
+ Optional<String> actual =
DataSourceMetaDataNodePath.findDataSourceNameByDataSourceNodePath("/metadata/logic_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());
+ }
+
+ @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"));
+ }
+}
diff --git
a/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNodeTest.java
b/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNodeTest.java
deleted file mode 100644
index d41477b0e96..00000000000
---
a/kernel/metadata/core/src/test/java/org/apache/shardingsphere/metadata/persist/node/metadata/DataSourceMetaDataNodeTest.java
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.shardingsphere.metadata.persist.node.metadata;
-
-import org.junit.jupiter.api.Test;
-
-import java.util.Optional;
-
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-class DataSourceMetaDataNodeTest {
-
- @Test
- void assertGetDataSourceUnitsNode() {
- assertThat(DataSourceMetaDataNode.getDataSourceUnitsNode("foo_db"),
is("/metadata/foo_db/data_sources/units"));
- }
-
- @Test
- void assertGetDataSourceNodesNode() {
- assertThat(DataSourceMetaDataNode.getDataSourceNodesNode("foo_db"),
is("/metadata/foo_db/data_sources/nodes"));
- }
-
- @Test
- void assertGetDataSourceUnitNode() {
- assertThat(DataSourceMetaDataNode.getDataSourceUnitNode("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds"));
- }
-
- @Test
- void assertGetDataSourceNodeNode() {
- assertThat(DataSourceMetaDataNode.getDataSourceNodeNode("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/nodes/foo_ds"));
- }
-
- @Test
- void assertGetDataSourceUnitVersionNode() {
-
assertThat(DataSourceMetaDataNode.getDataSourceUnitVersionNode("foo_db",
"foo_ds", "0"), is("/metadata/foo_db/data_sources/units/foo_ds/versions/0"));
- }
-
- @Test
- void assertGetDataSourceUnitVersionsNode() {
-
assertThat(DataSourceMetaDataNode.getDataSourceUnitVersionsNode("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds/versions"));
- }
-
- @Test
- void assertGetDataSourceUnitActiveVersionNode() {
-
assertThat(DataSourceMetaDataNode.getDataSourceUnitActiveVersionNode("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/units/foo_ds/active_version"));
- }
-
- @Test
- void assertGetDataSourceNodeVersionsNode() {
-
assertThat(DataSourceMetaDataNode.getDataSourceNodeVersionsNode("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/nodes/foo_ds/versions"));
- }
-
- @Test
- void assertGetDataSourceNodeVersionNode() {
-
assertThat(DataSourceMetaDataNode.getDataSourceNodeVersionNode("foo_db",
"foo_ds", "1"), is("/metadata/foo_db/data_sources/nodes/foo_ds/versions/1"));
- }
-
- @Test
- void assertGetDataSourceNodeActiveVersionNode() {
-
assertThat(DataSourceMetaDataNode.getDataSourceNodeActiveVersionNode("foo_db",
"foo_ds"), is("/metadata/foo_db/data_sources/nodes/foo_ds/active_version"));
- }
-
- @Test
- void assertIsDataSourcesNode() {
-
assertTrue(DataSourceMetaDataNode.isDataSourcesNode("/metadata/logic_db/data_sources/foo_ds"));
- }
-
- @Test
- void assertGetDataSourceNameByDataSourceUnitActiveVersionNode() {
- Optional<String> actual =
DataSourceMetaDataNode.getDataSourceNameByDataSourceUnitActiveVersionNode("/metadata/logic_db/data_sources/units/foo_ds/active_version");
- assertTrue(actual.isPresent());
- assertThat(actual.get(), is("foo_ds"));
- }
-
- @Test
- void assertGetDataSourceNameByDataSourceUnitActiveVersionNodeIfNotFound() {
-
assertFalse(DataSourceMetaDataNode.getDataSourceNameByDataSourceUnitActiveVersionNode("/xxx/logic_db/data_sources/units/foo_ds/active_version").isPresent());
- }
-
- @Test
- void assertGetDataSourceNameByDataSourceUnitNode() {
- Optional<String> actual =
DataSourceMetaDataNode.getDataSourceNameByDataSourceUnitNode("/metadata/logic_db/data_sources/units/foo_ds");
- assertTrue(actual.isPresent());
- assertThat(actual.get(), is("foo_ds"));
- }
-
- @Test
- void assertGetDataSourceNameByDataSourceUnitNodeIfNotFound() {
-
assertFalse(DataSourceMetaDataNode.getDataSourceNameByDataSourceUnitNode("/xxx/logic_db/data_sources/units/foo_ds").isPresent());
- }
-
- @Test
- void assertGetDataSourceNameByDataSourceNodeActiveVersionNode() {
- Optional<String> actual =
DataSourceMetaDataNode.getDataSourceNameByDataSourceNodeActiveVersionNode("/metadata/logic_db/data_sources/nodes/foo_ds/active_version");
- assertTrue(actual.isPresent());
- assertThat(actual.get(), is("foo_ds"));
- }
-
- @Test
- void assertGetDataSourceNameByDataSourceNodeActiveVersionNodeIfNotFound() {
-
assertFalse(DataSourceMetaDataNode.getDataSourceNameByDataSourceNodeActiveVersionNode("/xxx/logic_db/data_sources/nodes/foo_ds/active_version").isPresent());
- }
-
- @Test
- void assertGetDataSourceNameByDataSourceNodeNode() {
- Optional<String> actual =
DataSourceMetaDataNode.getDataSourceNameByDataSourceNodeNode("/metadata/logic_db/data_sources/nodes/foo_ds");
- assertTrue(actual.isPresent());
- assertThat(actual.get(), is("foo_ds"));
- }
-
- @Test
- void assertGetDataSourceNameByDataSourceNodeNodeIfNotFound() {
-
assertFalse(DataSourceMetaDataNode.getDataSourceNameByDataSourceNodeNode("/xxx/logic_db/data_sources/nodes/foo_ds").isPresent());
- }
-
- @Test
- void assertIsDataSourceUnitActiveVersionNode() {
-
assertTrue(DataSourceMetaDataNode.isDataSourceUnitActiveVersionNode("/metadata/logic_db/data_sources/units/foo_ds/active_version"));
- }
-
- @Test
- void assertIsDataSourceUnitNode() {
-
assertTrue(DataSourceMetaDataNode.isDataSourceUnitNode("/metadata/logic_db/data_sources/units/foo_ds"));
- }
-
- @Test
- void assertIsDataSourceNodeActiveVersionNode() {
-
assertTrue(DataSourceMetaDataNode.isDataSourceNodeActiveVersionNode("/metadata/logic_db/data_sources/nodes/foo_ds/active_version"));
- }
-
- @Test
- void assertIsDataSourceNodeNode() {
-
assertTrue(DataSourceMetaDataNode.isDataSourceNodeNode("/metadata/logic_db/data_sources/nodes/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 405cb3216a6..03244aa6d89 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
@@ -18,7 +18,7 @@
package
org.apache.shardingsphere.mode.manager.cluster.dispatch.handler.database.metadata;
import
org.apache.shardingsphere.metadata.persist.node.DatabaseMetaDataNodePath;
-import
org.apache.shardingsphere.metadata.persist.node.metadata.DataSourceMetaDataNode;
+import
org.apache.shardingsphere.metadata.persist.node.metadata.DataSourceMetaDataNodePath;
import
org.apache.shardingsphere.metadata.persist.node.metadata.TableMetaDataNode;
import
org.apache.shardingsphere.metadata.persist.node.metadata.ViewMetaDataNode;
import org.apache.shardingsphere.mode.event.DataChangedEvent;
@@ -73,7 +73,7 @@ public final class MetaDataChangedHandler {
handleViewChanged(databaseName, schemaName.get(), event);
return true;
}
- if (DataSourceMetaDataNode.isDataSourcesNode(eventKey)) {
+ if (DataSourceMetaDataNodePath.isDataSourcesPath(eventKey)) {
handleDataSourceChanged(databaseName, event);
return true;
}
@@ -113,15 +113,15 @@ public final class MetaDataChangedHandler {
}
private void handleDataSourceChanged(final String databaseName, final
DataChangedEvent event) {
- if
(DataSourceMetaDataNode.isDataSourceUnitActiveVersionNode(event.getKey()) ||
DataSourceMetaDataNode.isDataSourceUnitNode(event.getKey())) {
+ if
(DataSourceMetaDataNodePath.isDataSourceUnitActiveVersionPath(event.getKey())
|| DataSourceMetaDataNodePath.isDataSourceUnitPath(event.getKey())) {
handleStorageUnitChanged(databaseName, event);
- } else if
(DataSourceMetaDataNode.isDataSourceNodeActiveVersionNode(event.getKey()) ||
DataSourceMetaDataNode.isDataSourceNodeNode(event.getKey())) {
+ } else if
(DataSourceMetaDataNodePath.isDataSourceNodeActiveVersionPath(event.getKey())
|| DataSourceMetaDataNodePath.isDataSourceNodePath(event.getKey())) {
handleStorageNodeChanged(databaseName, event);
}
}
private void handleStorageUnitChanged(final String databaseName, final
DataChangedEvent event) {
- Optional<String> dataSourceUnitName =
DataSourceMetaDataNode.getDataSourceNameByDataSourceUnitActiveVersionNode(event.getKey());
+ Optional<String> dataSourceUnitName =
DataSourceMetaDataNodePath.findDataSourceNameByDataSourceUnitActiveVersionPath(event.getKey());
if (dataSourceUnitName.isPresent()) {
if (Type.ADDED == event.getType()) {
storageUnitChangedHandler.handleRegistered(databaseName,
dataSourceUnitName.get(), event);
@@ -130,14 +130,14 @@ public final class MetaDataChangedHandler {
}
return;
}
- dataSourceUnitName =
DataSourceMetaDataNode.getDataSourceNameByDataSourceUnitNode(event.getKey());
+ dataSourceUnitName =
DataSourceMetaDataNodePath.findDataSourceNameByDataSourceUnitPath(event.getKey());
if (Type.DELETED == event.getType() && dataSourceUnitName.isPresent())
{
storageUnitChangedHandler.handleUnregistered(databaseName,
dataSourceUnitName.get());
}
}
private void handleStorageNodeChanged(final String databaseName, final
DataChangedEvent event) {
- Optional<String> dataSourceNodeName =
DataSourceMetaDataNode.getDataSourceNameByDataSourceNodeActiveVersionNode(event.getKey());
+ Optional<String> dataSourceNodeName =
DataSourceMetaDataNodePath.findDataSourceNameByDataSourceNodeActiveVersionPath(event.getKey());
if (dataSourceNodeName.isPresent()) {
if (Type.ADDED == event.getType()) {
storageNodeChangedHandler.handleRegistered(databaseName,
dataSourceNodeName.get(), event);
@@ -146,7 +146,7 @@ public final class MetaDataChangedHandler {
}
return;
}
- dataSourceNodeName =
DataSourceMetaDataNode.getDataSourceNameByDataSourceNodeNode(event.getKey());
+ dataSourceNodeName =
DataSourceMetaDataNodePath.findDataSourceNameByDataSourceNodePath(event.getKey());
if (Type.DELETED == event.getType() && dataSourceNodeName.isPresent())
{
storageNodeChangedHandler.handleUnregistered(databaseName,
dataSourceNodeName.get());
}
