From f3fafa9cdfa285f709e5f8220e22a75ec1ce1a39 Mon Sep 17 00:00:00 2001 From: zhangliang Date: Fri, 10 Jan 2025 00:52:53 +0800 Subject: [PATCH 1/2] Refactor DataSourceMetaDataNodePath --- .../metadata/DataSourceMetaDataNodePath.java | 188 +++++++----------- .../DataSourceNodePersistService.java | 16 +- .../DataSourceUnitPersistService.java | 16 +- .../DataSourceMetaDataNodePathTest.java | 95 ++++----- .../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 c04edad6b8b62..493c3e9002fa9 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 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 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 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 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 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 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 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 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 fabf578c6dea2..6327eb582e1ea 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 DataSourceNodePersistService(final PersistRepository repository) { */ @SuppressWarnings("unchecked") public Map load(final String databaseName) { - Collection childrenKeys = repository.getChildrenKeys(DataSourceMetaDataNodePath.getDataSourceNodesPath(databaseName)); + Collection childrenKeys = repository.getChildrenKeys(DataSourceMetaDataNodePath.getStorageNodesPath(databaseName)); Map 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 Map load(final String databaseName) { */ @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 DataSourcePoolProperties load(final String databaseName, final String dat public void persist(final String databaseName, final Map dataSourceConfigs) { for (Entry entry : dataSourceConfigs.entrySet()) { String activeVersion = getDataSourceActiveVersion(databaseName, entry.getKey()); - List versions = metaDataVersionPersistService.getVersions(DataSourceMetaDataNodePath.getDataSourceNodeVersionsPath(databaseName, entry.getKey())); - repository.persist(DataSourceMetaDataNodePath.getDataSourceNodeVersionPath(databaseName, entry.getKey(), versions.isEmpty() + List 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 @@ private String getDataSourceActiveVersion(final String databaseName, final Strin * @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 5fd34ee57c559..b546fe5fcba88 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 DataSourceUnitPersistService(final PersistRepository repository) { * @return data source pool properties map */ public Map load(final String databaseName) { - Collection childrenKeys = repository.getChildrenKeys(DataSourceMetaDataNodePath.getDataSourceUnitsPath(databaseName)); + Collection 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 Map load(final String databaseName) { */ @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 Collection persist(final String databaseName, final Map< Collection result = new LinkedList<>(); for (Entry entry : dataSourcePropsMap.entrySet()) { String activeVersion = getDataSourceActiveVersion(databaseName, entry.getKey()); - List versions = metaDataVersionPersistService.getVersions(DataSourceMetaDataNodePath.getDataSourceUnitVersionsPath(databaseName, entry.getKey())); + List 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 @@ private String getDataSourceActiveVersion(final String databaseName, final Strin * @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 778a54775ba9a..09f78de50fde5 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 @@ 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 actual = DataSourceMetaDataNodePath.findDataSourceNameByDataSourceUnitActiveVersionPath("/metadata/logic_db/data_sources/units/foo_ds/active_version"); + void assertFindStorageUnitNameByActiveVersionPath() { + Optional 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 actual = DataSourceMetaDataNodePath.findDataSourceNameByDataSourceUnitPath("/metadata/logic_db/data_sources/units/foo_ds"); + void assertFindStorageUnitNameByStorageUnitPath() { + Optional 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 actual = DataSourceMetaDataNodePath.findDataSourceNameByDataSourceNodeActiveVersionPath("/metadata/logic_db/data_sources/nodes/foo_ds/active_version"); + void assertFindStorageNodeNameByActiveVersionPath() { + Optional 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 actual = DataSourceMetaDataNodePath.findDataSourceNameByDataSourceNodePath("/metadata/logic_db/data_sources/nodes/foo_ds"); + void assertFindStorageNodeNameByStorageNodePath() { + Optional 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 7126140b05730..165a9686c18ea 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 boolean handle(final String databaseName, final DataChangedEvent event) { handleViewChanged(databaseName, schemaName.get(), event); return true; } - if (DataSourceMetaDataNodePath.isDataSourcesPath(eventKey)) { + if (DataSourceMetaDataNodePath.isDataSourceRootPath(eventKey)) { handleDataSourceChanged(databaseName, event); return true; } @@ -113,42 +113,52 @@ private void handleViewChanged(final String databaseName, final String schemaNam } 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 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 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 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 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); } } } From d9898dedbeb254054f39d30e965576a3979276f6 Mon Sep 17 00:00:00 2001 From: zhangliang Date: Fri, 10 Jan 2025 00:56:17 +0800 Subject: [PATCH 2/2] Refactor DataSourceMetaDataNodePath --- .../persist/node/metadata/DataSourceMetaDataNodePath.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 493c3e9002fa9..620f684a8a47b 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 @@ -50,7 +50,7 @@ public final class DataSourceMetaDataNodePath { * @param databaseName database name * @return data source root path */ - public static String getDataSourceRootPath(final String databaseName) { + public static String getDataSourceRootPath(final String databaseName) { return String.join("/", ROOT_NODE, databaseName, DATA_SOURCES_NODE); }