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 750cf3b5126 Change the key of storageNodeDataSources from String to
StorageNode (#28031)
750cf3b5126 is described below
commit 750cf3b51262a46a7ad0248834262e8fc5ccda51
Author: Raigor <raigor.ji...@gmail.com>
AuthorDate: Fri Aug 11 10:05:44 2023 +0800
Change the key of storageNodeDataSources from String to StorageNode (#28031)
* Change the key of storageNodeDataSources from String to StorageNode
* merge master
* Optimize StorageUnitMetaData
---
.../DataSourceProvidedDatabaseConfiguration.java | 4 +-
.../database/resource/ResourceMetaData.java | 32 +++-------
.../database/resource/StorageUnitMetaData.java | 66 ++++++++++---------
...taSourceGeneratedDatabaseConfigurationTest.java | 3 +-
...ataSourceProvidedDatabaseConfigurationTest.java | 3 +-
.../pool/creator/DataSourcePoolCreator.java | 28 ++++----
.../pool/props/DataSourcePropertiesCreator.java | 6 +-
.../infra/datasource/storage/StorageNode.java} | 31 +++++++--
.../datasource/storage/StorageNodeProperties.java | 5 +-
.../infra/datasource/storage/StorageResource.java | 8 +--
...StorageUtils.java => StorageResourceUtils.java} | 18 +++++-
.../storage/StorageResourceWithProperties.java | 2 +-
.../datasource/storage/StorageUnitNodeMapper.java | 10 +--
.../datasource/ShardingSphereDataSourceTest.java | 13 ++--
.../metadata/persist/MetaDataPersistService.java | 13 ++--
.../persist/NewMetaDataPersistService.java | 13 ++--
.../context/ConfigurationContextManager.java | 17 ++---
.../manager/switcher/NewResourceSwitchManager.java | 27 ++++----
.../manager/switcher/ResourceSwitchManager.java | 74 ++++++++++++----------
.../mode/manager/switcher/SwitchingResource.java | 2 +-
.../mode/manager/ContextManagerTest.java | 13 ++--
.../switcher/ResourceSwitchManagerTest.java | 13 ++--
.../manager/switcher/SwitchingResourceTest.java | 5 +-
.../ConfigurationChangedSubscriberTest.java | 2 +-
.../swapper/YamlProxyConfigurationSwapperTest.java | 3 +-
25 files changed, 227 insertions(+), 184 deletions(-)
diff --git
a/infra/common/src/main/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceProvidedDatabaseConfiguration.java
b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceProvidedDatabaseConfiguration.java
index 2fef26164ef..f3a92b9cc05 100644
---
a/infra/common/src/main/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceProvidedDatabaseConfiguration.java
+++
b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceProvidedDatabaseConfiguration.java
@@ -23,7 +23,7 @@ import
org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourceProperties;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourcePropertiesCreator;
import org.apache.shardingsphere.infra.datasource.storage.StorageResource;
-import org.apache.shardingsphere.infra.datasource.storage.StorageUtils;
+import org.apache.shardingsphere.infra.datasource.storage.StorageResourceUtils;
import javax.sql.DataSource;
import java.util.Collection;
@@ -46,7 +46,7 @@ public final class DataSourceProvidedDatabaseConfiguration
implements DatabaseCo
public DataSourceProvidedDatabaseConfiguration(final Map<String,
DataSource> dataSources, final Collection<RuleConfiguration>
ruleConfigurations) {
this.ruleConfigurations = ruleConfigurations;
- this.storageResource = new StorageResource(dataSources,
StorageUtils.getStorageUnitNodeMappers(dataSources));
+ this.storageResource = new
StorageResource(StorageResourceUtils.getStorageNodeDataSources(dataSources),
StorageResourceUtils.getStorageUnitNodeMappers(dataSources));
dataSourcePropsMap = createDataSourcePropertiesMap(dataSources);
}
diff --git
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/ResourceMetaData.java
b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/ResourceMetaData.java
index 6a255dc4a67..fc6e62918a3 100644
---
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/ResourceMetaData.java
+++
b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/ResourceMetaData.java
@@ -18,19 +18,17 @@
package org.apache.shardingsphere.infra.metadata.database.resource;
import lombok.Getter;
-import org.apache.shardingsphere.infra.database.DatabaseTypeEngine;
import
org.apache.shardingsphere.infra.database.core.connector.ConnectionProperties;
import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import
org.apache.shardingsphere.infra.datasource.pool.destroyer.DataSourcePoolDestroyer;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourceProperties;
+import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourcePropertiesCreator;
+import org.apache.shardingsphere.infra.datasource.storage.StorageNode;
import org.apache.shardingsphere.infra.datasource.storage.StorageResource;
-import org.apache.shardingsphere.infra.datasource.storage.StorageUtils;
-import org.apache.shardingsphere.infra.state.datasource.DataSourceStateManager;
+import org.apache.shardingsphere.infra.datasource.storage.StorageResourceUtils;
import javax.sql.DataSource;
import java.util.Collection;
-import java.util.Collections;
-import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Map.Entry;
@@ -42,7 +40,7 @@ import java.util.stream.Collectors;
@Getter
public final class ResourceMetaData {
- private final StorageNodeMetaData storageNodeMetaData;
+ private final Map<StorageNode, DataSource> storageNodeDataSources;
private final StorageUnitMetaData storageUnitMetaData;
@@ -51,26 +49,14 @@ public final class ResourceMetaData {
}
public ResourceMetaData(final String databaseName, final Map<String,
DataSource> dataSources) {
- Map<String, DataSource> enabledDataSources =
DataSourceStateManager.getInstance().getEnabledDataSources(databaseName,
dataSources);
- Map<String, DatabaseType> storageTypes =
createStorageTypes(dataSources, enabledDataSources);
- storageNodeMetaData = new StorageNodeMetaData(dataSources);
- storageUnitMetaData = new StorageUnitMetaData(dataSources,
storageTypes, StorageUtils.getStorageUnitNodeMappers(dataSources),
enabledDataSources);
-
+ storageNodeDataSources =
StorageResourceUtils.getStorageNodeDataSources(dataSources);
+ storageUnitMetaData = new StorageUnitMetaData(databaseName,
storageNodeDataSources,
+ DataSourcePropertiesCreator.create(dataSources),
StorageResourceUtils.getStorageUnitNodeMappers(dataSources));
}
public ResourceMetaData(final String databaseName, final StorageResource
storageResource, final Map<String, DataSourceProperties> dataSourcePropsMap) {
- Map<String, DataSource> enabledDataSources =
DataSourceStateManager.getInstance().getEnabledDataSources(databaseName,
storageResource.getStorageNodes());
- Map<String, DatabaseType> storageTypes =
createStorageTypes(storageResource.getStorageNodes(), enabledDataSources);
- storageNodeMetaData = new
StorageNodeMetaData(storageResource.getStorageNodes());
- storageUnitMetaData = new
StorageUnitMetaData(storageResource.getStorageNodes(), dataSourcePropsMap,
storageTypes, storageResource.getStorageUnitNodeMappers(), enabledDataSources);
- }
-
- private Map<String, DatabaseType> createStorageTypes(final Map<String,
DataSource> dataSources, final Map<String, DataSource> enabledDataSources) {
- Map<String, DatabaseType> result = new
LinkedHashMap<>(dataSources.size(), 1F);
- for (Entry<String, DataSource> entry : dataSources.entrySet()) {
- result.put(entry.getKey(),
DatabaseTypeEngine.getStorageType(enabledDataSources.containsKey(entry.getKey())
? Collections.singleton(entry.getValue()) : Collections.emptyList()));
- }
- return result;
+ storageNodeDataSources = storageResource.getStorageNodeDataSources();
+ storageUnitMetaData = new StorageUnitMetaData(databaseName,
storageNodeDataSources, dataSourcePropsMap,
storageResource.getStorageUnitNodeMappers());
}
/**
diff --git
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/StorageUnitMetaData.java
b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/StorageUnitMetaData.java
index f7196b8488b..d833e196276 100644
---
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/StorageUnitMetaData.java
+++
b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/StorageUnitMetaData.java
@@ -19,20 +19,23 @@ package
org.apache.shardingsphere.infra.metadata.database.resource;
import lombok.Getter;
import org.apache.shardingsphere.infra.database.DatabaseTypeEngine;
-import
org.apache.shardingsphere.infra.database.core.spi.DatabaseTypedSPILoader;
-import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import
org.apache.shardingsphere.infra.database.core.connector.ConnectionProperties;
import
org.apache.shardingsphere.infra.database.core.connector.ConnectionPropertiesParser;
+import
org.apache.shardingsphere.infra.database.core.spi.DatabaseTypedSPILoader;
+import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.datasource.CatalogSwitchableDataSource;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourceProperties;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourcePropertiesCreator;
+import org.apache.shardingsphere.infra.datasource.storage.StorageNode;
import
org.apache.shardingsphere.infra.datasource.storage.StorageUnitNodeMapper;
+import org.apache.shardingsphere.infra.state.datasource.DataSourceStateManager;
import javax.sql.DataSource;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.stream.Collectors;
/**
* Storage unit meta data.
@@ -50,48 +53,53 @@ public final class StorageUnitMetaData {
private final Map<String, ConnectionProperties> connectionPropsMap;
- public StorageUnitMetaData(final Map<String, DataSource> dataSources,
final Map<String, DatabaseType> storageTypes, final Map<String,
StorageUnitNodeMapper> unitNodeMappers,
- final Map<String, DataSource>
enabledDataSources) {
- this(dataSources, DataSourcePropertiesCreator.create(dataSources),
storageTypes, unitNodeMappers, enabledDataSources);
- }
-
- public StorageUnitMetaData(final Map<String, DataSource> dataSources,
final Map<String, DataSourceProperties> dataSourcePropsMap,
- final Map<String, DatabaseType> storageTypes,
final Map<String, StorageUnitNodeMapper> unitNodeMappers, final Map<String,
DataSource> enabledDataSources) {
+ public StorageUnitMetaData(final String databaseName, final
Map<StorageNode, DataSource> storageNodeDataSources,
+ final Map<String, DataSourceProperties>
dataSourcePropsMap, final Map<String, StorageUnitNodeMapper> unitNodeMappers) {
this.unitNodeMappers = unitNodeMappers;
- this.dataSources = getStorageUnitDataSources(dataSources,
unitNodeMappers);
+ this.dataSources = getStorageUnitDataSources(storageNodeDataSources,
unitNodeMappers);
this.dataSourcePropsMap = dataSourcePropsMap;
- this.storageTypes = getStorageUnitTypes(storageTypes);
- connectionPropsMap = createConnectionPropertiesMap(enabledDataSources,
storageTypes, unitNodeMappers);
+ Map<StorageNode, DataSource> enabledStorageNodeDataSources =
getEnabledStorageNodeDataSources(databaseName, storageNodeDataSources);
+ storageTypes = createStorageTypes(enabledStorageNodeDataSources,
unitNodeMappers);
+ connectionPropsMap =
createConnectionPropertiesMap(enabledStorageNodeDataSources, storageTypes,
unitNodeMappers);
}
- private Map<String, DataSource> getStorageUnitDataSources(final
Map<String, DataSource> storageNodes, final Map<String, StorageUnitNodeMapper>
storageUnits) {
- Map<String, DataSource> result = new
LinkedHashMap<>(storageUnits.size(), 1F);
- for (Entry<String, StorageUnitNodeMapper> entry :
storageUnits.entrySet()) {
- DataSource dataSource =
storageNodes.get(entry.getValue().getNodeName());
+ private Map<StorageNode, DataSource>
getEnabledStorageNodeDataSources(final String databaseName, final
Map<StorageNode, DataSource> storageNodeDataSources) {
+ Map<String, DataSource> toBeCheckedDataSources = new
LinkedHashMap<>(storageNodeDataSources.size(), 1F);
+ for (Entry<StorageNode, DataSource> entry :
storageNodeDataSources.entrySet()) {
+ toBeCheckedDataSources.put(entry.getKey().getName(),
entry.getValue());
+ }
+ Map<String, DataSource> enabledDataSources =
DataSourceStateManager.getInstance().getEnabledDataSources(databaseName,
toBeCheckedDataSources);
+ return storageNodeDataSources.entrySet().stream()
+ .filter(entry ->
enabledDataSources.containsKey(entry.getKey().getName())).collect(Collectors.toMap(Entry::getKey,
Entry::getValue));
+ }
+
+ private Map<String, DataSource> getStorageUnitDataSources(final
Map<StorageNode, DataSource> storageNodeDataSources, final Map<String,
StorageUnitNodeMapper> unitNodeMappers) {
+ Map<String, DataSource> result = new
LinkedHashMap<>(unitNodeMappers.size(), 1F);
+ for (Entry<String, StorageUnitNodeMapper> entry :
unitNodeMappers.entrySet()) {
+ DataSource dataSource =
storageNodeDataSources.get(entry.getValue().getStorageNode());
result.put(entry.getKey(), new
CatalogSwitchableDataSource(dataSource, entry.getValue().getCatalog(),
entry.getValue().getUrl()));
}
return result;
}
- private Map<String, DatabaseType> getStorageUnitTypes(final Map<String,
DatabaseType> storageTypes) {
+ private Map<String, DatabaseType> createStorageTypes(final
Map<StorageNode, DataSource> enabledStorageNodeDataSources, final Map<String,
StorageUnitNodeMapper> unitNodeMappers) {
Map<String, DatabaseType> result = new
LinkedHashMap<>(unitNodeMappers.size(), 1F);
for (Entry<String, StorageUnitNodeMapper> entry :
unitNodeMappers.entrySet()) {
- DatabaseType storageType =
storageTypes.containsKey(entry.getValue().getNodeName())
- ? storageTypes.get(entry.getValue().getNodeName())
- :
DatabaseTypeEngine.getStorageType(Collections.emptyList());
- result.put(entry.getKey(), storageType);
+ result.put(entry.getKey(),
DatabaseTypeEngine.getStorageType(enabledStorageNodeDataSources.containsKey(entry.getValue().getStorageNode())
+ ?
Collections.singleton(enabledStorageNodeDataSources.get(entry.getValue().getStorageNode()))
+ : Collections.emptyList()));
}
return result;
}
- private Map<String, ConnectionProperties>
createConnectionPropertiesMap(final Map<String, DataSource> enabledDataSources,
-
final Map<String, DatabaseType> storageTypes, final Map<String,
StorageUnitNodeMapper> storageUnits) {
- Map<String, ConnectionProperties> result = new
LinkedHashMap<>(storageUnits.size(), 1F);
- for (Entry<String, StorageUnitNodeMapper> entry :
storageUnits.entrySet()) {
- String nodeName = entry.getValue().getNodeName();
- if (enabledDataSources.containsKey(nodeName)) {
- Map<String, Object> standardProps =
DataSourcePropertiesCreator.create(enabledDataSources.get(nodeName)).getConnectionPropertySynonyms().getStandardProperties();
- DatabaseType storageType = storageTypes.get(nodeName);
+ private Map<String, ConnectionProperties>
createConnectionPropertiesMap(final Map<StorageNode, DataSource>
enabledStorageNodeDataSources,
+
final Map<String, DatabaseType> storageTypes, final Map<String,
StorageUnitNodeMapper> unitNodeMappers) {
+ Map<String, ConnectionProperties> result = new
LinkedHashMap<>(unitNodeMappers.size(), 1F);
+ for (Entry<String, StorageUnitNodeMapper> entry :
unitNodeMappers.entrySet()) {
+ if
(enabledStorageNodeDataSources.containsKey(entry.getValue().getStorageNode())) {
+ Map<String, Object> standardProps =
DataSourcePropertiesCreator.create(enabledStorageNodeDataSources.get(entry.getValue().getStorageNode()))
+
.getConnectionPropertySynonyms().getStandardProperties();
+ DatabaseType storageType = storageTypes.get(entry.getKey());
ConnectionPropertiesParser parser =
DatabaseTypedSPILoader.getService(ConnectionPropertiesParser.class,
storageType);
result.put(entry.getKey(),
parser.parse(standardProps.get("url").toString(),
standardProps.get("username").toString(), entry.getValue().getCatalog()));
}
diff --git
a/infra/common/src/test/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceGeneratedDatabaseConfigurationTest.java
b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceGeneratedDatabaseConfigurationTest.java
index ae9b02039ae..cba32437cf8 100644
---
a/infra/common/src/test/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceGeneratedDatabaseConfigurationTest.java
+++
b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceGeneratedDatabaseConfigurationTest.java
@@ -23,6 +23,7 @@ import
org.apache.shardingsphere.infra.datasource.pool.config.ConnectionConfigur
import
org.apache.shardingsphere.infra.datasource.pool.config.DataSourceConfiguration;
import
org.apache.shardingsphere.infra.datasource.pool.config.PoolConfiguration;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourceProperties;
+import org.apache.shardingsphere.infra.datasource.storage.StorageNode;
import org.apache.shardingsphere.infra.fixture.FixtureRuleConfiguration;
import org.junit.jupiter.api.Test;
@@ -49,7 +50,7 @@ class DataSourceGeneratedDatabaseConfigurationTest {
@Test
void assertGetStorageNodes() {
DataSourceGeneratedDatabaseConfiguration databaseConfig =
createDataSourceGeneratedDatabaseConfiguration();
- HikariDataSource hikariDataSource = (HikariDataSource)
databaseConfig.getStorageResource().getStorageNodes().get("normal_db");
+ HikariDataSource hikariDataSource = (HikariDataSource)
databaseConfig.getStorageResource().getStorageNodeDataSources().get(new
StorageNode("normal_db"));
assertThat(hikariDataSource.getJdbcUrl(),
is("jdbc:mock://127.0.0.1/normal_db"));
assertThat(hikariDataSource.getUsername(), is("root"));
assertThat(hikariDataSource.getPassword(), is(""));
diff --git
a/infra/common/src/test/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceProvidedDatabaseConfigurationTest.java
b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceProvidedDatabaseConfigurationTest.java
index fa036944365..635a45601ce 100644
---
a/infra/common/src/test/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceProvidedDatabaseConfigurationTest.java
+++
b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceProvidedDatabaseConfigurationTest.java
@@ -19,6 +19,7 @@ package org.apache.shardingsphere.infra.config.database.impl;
import org.apache.shardingsphere.infra.datasource.CatalogSwitchableDataSource;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourceProperties;
+import org.apache.shardingsphere.infra.datasource.storage.StorageNode;
import org.apache.shardingsphere.infra.fixture.FixtureRuleConfiguration;
import org.apache.shardingsphere.test.fixture.jdbc.MockedDataSource;
import org.junit.jupiter.api.Test;
@@ -44,7 +45,7 @@ class DataSourceProvidedDatabaseConfigurationTest {
@Test
void assertGetStorageNodes() {
DataSourceProvidedDatabaseConfiguration databaseConfig =
createDataSourceProvidedDatabaseConfiguration();
- MockedDataSource dataSource = (MockedDataSource)
databaseConfig.getStorageResource().getStorageNodes().get("foo_ds");
+ MockedDataSource dataSource = (MockedDataSource)
databaseConfig.getStorageResource().getStorageNodeDataSources().get(new
StorageNode("foo_ds"));
assertThat(dataSource.getUrl(), is("jdbc:mock://127.0.0.1/foo_ds"));
assertThat(dataSource.getUsername(), is("root"));
assertThat(dataSource.getPassword(), is("root"));
diff --git
a/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/pool/creator/DataSourcePoolCreator.java
b/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/pool/creator/DataSourcePoolCreator.java
index 26ecf9b22b0..4e27fe74fcb 100644
---
a/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/pool/creator/DataSourcePoolCreator.java
+++
b/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/pool/creator/DataSourcePoolCreator.java
@@ -33,6 +33,7 @@ import
org.apache.shardingsphere.infra.datasource.pool.metadata.DataSourcePoolMe
import
org.apache.shardingsphere.infra.datasource.pool.metadata.DataSourcePoolMetaDataReflection;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourceProperties;
import
org.apache.shardingsphere.infra.datasource.pool.props.custom.CustomDataSourceProperties;
+import org.apache.shardingsphere.infra.datasource.storage.StorageNode;
import
org.apache.shardingsphere.infra.datasource.storage.StorageNodeProperties;
import org.apache.shardingsphere.infra.datasource.storage.StorageResource;
import
org.apache.shardingsphere.infra.datasource.storage.StorageResourceWithProperties;
@@ -70,11 +71,12 @@ public final class DataSourcePoolCreator {
* @return created storage resource
*/
public static StorageResource createStorageResource(final Map<String,
DataSourceProperties> dataSourcePropsMap, final boolean cacheEnabled) {
- Map<String, DataSource> storageNodes = new LinkedHashMap<>();
+ Map<StorageNode, DataSource> storageNodes = new LinkedHashMap<>();
Map<String, StorageUnitNodeMapper> storageUnitNodeMappers = new
LinkedHashMap<>();
for (Entry<String, DataSourceProperties> entry :
dataSourcePropsMap.entrySet()) {
StorageNodeProperties storageNodeProps =
getStorageNodeProperties(entry.getKey(), entry.getValue());
- if (storageNodes.containsKey(storageNodeProps.getName())) {
+ StorageNode storageNode = new
StorageNode(storageNodeProps.getName());
+ if (storageNodes.containsKey(storageNode)) {
appendStorageUnitNodeMapper(storageUnitNodeMappers,
storageNodeProps, entry.getKey(), entry.getValue());
continue;
}
@@ -89,7 +91,7 @@ public final class DataSourcePoolCreator {
}
throw ex;
}
- storageNodes.put(storageNodeProps.getName(), dataSource);
+ storageNodes.put(storageNode, dataSource);
appendStorageUnitNodeMapper(storageUnitNodeMappers,
storageNodeProps, entry.getKey(), entry.getValue());
}
return new StorageResource(storageNodes, storageUnitNodeMappers);
@@ -102,16 +104,17 @@ public final class DataSourcePoolCreator {
* @return created storage resource
*/
public static StorageResourceWithProperties
createStorageResourceWithoutDataSource(final Map<String, DataSourceProperties>
dataSourcePropsMap) {
- Map<String, DataSource> storageNodes = new LinkedHashMap<>();
+ Map<StorageNode, DataSource> storageNodes = new LinkedHashMap<>();
Map<String, StorageUnitNodeMapper> storageUnitNodeMappers = new
LinkedHashMap<>();
Map<String, DataSourceProperties> dataSourcePropertiesMap = new
LinkedHashMap<>();
for (Entry<String, DataSourceProperties> entry :
dataSourcePropsMap.entrySet()) {
StorageNodeProperties storageNodeProperties =
getStorageNodeProperties(entry.getKey(), entry.getValue());
- if (storageNodes.containsKey(storageNodeProperties.getName())) {
+ StorageNode storageNode = new
StorageNode(storageNodeProperties.getName());
+ if (storageNodes.containsKey(storageNode)) {
appendStorageUnitNodeMapper(storageUnitNodeMappers,
storageNodeProperties, entry.getKey(), entry.getValue());
continue;
}
- storageNodes.put(storageNodeProperties.getName(), null);
+ storageNodes.put(storageNode, null);
appendStorageUnitNodeMapper(storageUnitNodeMappers,
storageNodeProperties, entry.getKey(), entry.getValue());
dataSourcePropertiesMap.put(storageNodeProperties.getName(),
entry.getValue());
}
@@ -127,8 +130,8 @@ public final class DataSourcePoolCreator {
private static StorageUnitNodeMapper getStorageUnitNodeMapper(final
StorageNodeProperties storageNodeProps, final String unitName, final String
url) {
DialectDatabaseMetaData dialectDatabaseMetaData = new
DatabaseTypeRegistry(storageNodeProps.getDatabaseType()).getDialectDatabaseMetaData();
return dialectDatabaseMetaData.isInstanceConnectionAvailable()
- ? new StorageUnitNodeMapper(unitName,
storageNodeProps.getName(), storageNodeProps.getDatabase(), url)
- : new StorageUnitNodeMapper(unitName,
storageNodeProps.getName(), url);
+ ? new StorageUnitNodeMapper(unitName, new
StorageNode(storageNodeProps.getName()), storageNodeProps.getCatalog(), url)
+ : new StorageUnitNodeMapper(unitName, new
StorageNode(storageNodeProps.getName()), url);
}
private static StorageNodeProperties getStorageNodeProperties(final String
dataSourceName, final DataSourceProperties storageNodeProps) {
@@ -136,18 +139,17 @@ public final class DataSourcePoolCreator {
String url = standardProperties.get("url").toString();
String username = standardProperties.get("username").toString();
DatabaseType databaseType = DatabaseTypeFactory.get(url);
- return getStorageNodeProperties(dataSourceName, storageNodeProps, url,
username, databaseType);
+ return getStorageNodeProperties(dataSourceName, url, username,
databaseType);
}
- private static StorageNodeProperties getStorageNodeProperties(final String
dataSourceName, final DataSourceProperties dataSourceProps,
- final String
url, final String username, final DatabaseType databaseType) {
+ private static StorageNodeProperties getStorageNodeProperties(final String
dataSourceName, final String url, final String username, final DatabaseType
databaseType) {
try {
JdbcUrl jdbcUrl = new StandardJdbcUrlParser().parse(url);
DialectDatabaseMetaData dialectDatabaseMetaData = new
DatabaseTypeRegistry(databaseType).getDialectDatabaseMetaData();
String nodeName =
dialectDatabaseMetaData.isInstanceConnectionAvailable() ?
generateStorageNodeName(jdbcUrl.getHostname(), jdbcUrl.getPort(), username) :
dataSourceName;
- return new StorageNodeProperties(nodeName, databaseType,
dataSourceProps, jdbcUrl.getDatabase());
+ return new StorageNodeProperties(nodeName, databaseType,
jdbcUrl.getDatabase());
} catch (final UnrecognizedDatabaseURLException ex) {
- return new StorageNodeProperties(dataSourceName, databaseType,
dataSourceProps, null);
+ return new StorageNodeProperties(dataSourceName, databaseType,
null);
}
}
diff --git
a/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/pool/props/DataSourcePropertiesCreator.java
b/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/pool/props/DataSourcePropertiesCreator.java
index 1c7053e6407..536cbe10e59 100644
---
a/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/pool/props/DataSourcePropertiesCreator.java
+++
b/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/pool/props/DataSourcePropertiesCreator.java
@@ -22,6 +22,7 @@ import lombok.NoArgsConstructor;
import
org.apache.shardingsphere.infra.datasource.pool.config.ConnectionConfiguration;
import
org.apache.shardingsphere.infra.datasource.pool.config.DataSourceConfiguration;
import
org.apache.shardingsphere.infra.datasource.pool.config.PoolConfiguration;
+import org.apache.shardingsphere.infra.datasource.CatalogSwitchableDataSource;
import
org.apache.shardingsphere.infra.datasource.pool.creator.DataSourceReflection;
import
org.apache.shardingsphere.infra.datasource.pool.metadata.DataSourcePoolMetaData;
import
org.apache.shardingsphere.infra.datasource.pool.props.custom.CustomDataSourceProperties;
@@ -85,7 +86,10 @@ public final class DataSourcePropertiesCreator {
* @return created data source properties
*/
public static DataSourceProperties create(final DataSource dataSource) {
- return new DataSourceProperties(dataSource.getClass().getName(),
createProperties(dataSource));
+ return dataSource instanceof CatalogSwitchableDataSource
+ ? new DataSourceProperties(((CatalogSwitchableDataSource)
dataSource).getDataSource().getClass().getName(),
+ createProperties(((CatalogSwitchableDataSource)
dataSource).getDataSource()))
+ : new DataSourceProperties(dataSource.getClass().getName(),
createProperties(dataSource));
}
@SuppressWarnings({"unchecked", "rawtypes"})
diff --git
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/StorageNodeMetaData.java
b/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageNode.java
similarity index 59%
rename from
infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/StorageNodeMetaData.java
rename to
infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageNode.java
index 7fca766ca1b..32c4c3d1d9c 100644
---
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/StorageNodeMetaData.java
+++
b/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageNode.java
@@ -15,20 +15,37 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.infra.metadata.database.resource;
+package org.apache.shardingsphere.infra.datasource.storage;
+import com.google.common.base.Objects;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
-import javax.sql.DataSource;
-import java.util.Map;
-
/**
- * Storage node meta data.
+ * Storage node.
*/
@RequiredArgsConstructor
@Getter
-public final class StorageNodeMetaData {
+public final class StorageNode {
+
+ private final String name;
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (obj instanceof StorageNode) {
+ StorageNode storageNode = (StorageNode) obj;
+ return storageNode.name.equalsIgnoreCase(name);
+ }
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(name.toUpperCase());
+ }
- private final Map<String, DataSource> dataSources;
+ @Override
+ public String toString() {
+ return name;
+ }
}
diff --git
a/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageNodeProperties.java
b/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageNodeProperties.java
index a436adaab10..4721882c997 100644
---
a/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageNodeProperties.java
+++
b/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageNodeProperties.java
@@ -21,7 +21,6 @@ import com.google.common.base.Objects;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
-import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourceProperties;
/**
* Storage node properties.
@@ -34,9 +33,7 @@ public final class StorageNodeProperties {
private final DatabaseType databaseType;
- private final DataSourceProperties dataSourceProperties;
-
- private final String database;
+ private final String catalog;
@Override
public boolean equals(final Object obj) {
diff --git
a/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageResource.java
b/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageResource.java
index 5d708acac26..856bb30b267 100644
---
a/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageResource.java
+++
b/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageResource.java
@@ -31,14 +31,14 @@ import java.util.Map.Entry;
@Getter
public class StorageResource {
- private final Map<String, DataSource> storageNodes;
+ private final Map<StorageNode, DataSource> storageNodeDataSources;
private final Map<String, StorageUnitNodeMapper> storageUnitNodeMappers;
private final Map<String, DataSource> wrappedDataSources;
- public StorageResource(final Map<String, DataSource> storageNodes, final
Map<String, StorageUnitNodeMapper> storageUnitNodeMappers) {
- this.storageNodes = storageNodes;
+ public StorageResource(final Map<StorageNode, DataSource>
storageNodeDataSources, final Map<String, StorageUnitNodeMapper>
storageUnitNodeMappers) {
+ this.storageNodeDataSources = storageNodeDataSources;
this.storageUnitNodeMappers = storageUnitNodeMappers;
wrappedDataSources = createWrappedDataSources();
}
@@ -46,7 +46,7 @@ public class StorageResource {
private Map<String, DataSource> createWrappedDataSources() {
Map<String, DataSource> result = new
LinkedHashMap<>(storageUnitNodeMappers.size(), 1F);
for (Entry<String, StorageUnitNodeMapper> entry :
storageUnitNodeMappers.entrySet()) {
- DataSource dataSource =
storageNodes.get(entry.getValue().getNodeName());
+ DataSource dataSource =
storageNodeDataSources.get(entry.getValue().getStorageNode());
if (null != dataSource) {
result.put(entry.getKey(), new
CatalogSwitchableDataSource(dataSource, entry.getValue().getCatalog(),
entry.getValue().getUrl()));
}
diff --git
a/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageUtils.java
b/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageResourceUtils.java
similarity index 76%
rename from
infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageUtils.java
rename to
infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageResourceUtils.java
index 47b86c6319a..21bd6b72aba 100644
---
a/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageUtils.java
+++
b/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageResourceUtils.java
@@ -31,7 +31,21 @@ import java.util.Map.Entry;
* Storage utility class.
*/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
-public final class StorageUtils {
+public final class StorageResourceUtils {
+
+ /**
+ * Get storage node data sources.
+ *
+ * @param dataSources data sources
+ * @return storage node data sources
+ */
+ public static Map<StorageNode, DataSource> getStorageNodeDataSources(final
Map<String, DataSource> dataSources) {
+ Map<StorageNode, DataSource> result = new
LinkedHashMap<>(dataSources.size(), 1F);
+ for (Entry<String, DataSource> entry : dataSources.entrySet()) {
+ result.put(new StorageNode(entry.getKey()), entry.getValue());
+ }
+ return result;
+ }
/**
* Get storage unit node mappers from provided data sources.
@@ -44,7 +58,7 @@ public final class StorageUtils {
for (Entry<String, DataSource> entry : dataSources.entrySet()) {
DataSourceProperties dataSourceProperties =
DataSourcePropertiesCreator.create(entry.getValue());
String url =
dataSourceProperties.getConnectionPropertySynonyms().getStandardProperties().get("url").toString();
- result.put(entry.getKey(), new
StorageUnitNodeMapper(entry.getKey(), entry.getKey(), url));
+ result.put(entry.getKey(), new
StorageUnitNodeMapper(entry.getKey(), new StorageNode(entry.getKey()), url));
}
return result;
}
diff --git
a/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageResourceWithProperties.java
b/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageResourceWithProperties.java
index 3e46055ba79..fc93e7e4d5c 100644
---
a/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageResourceWithProperties.java
+++
b/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageResourceWithProperties.java
@@ -31,7 +31,7 @@ public final class StorageResourceWithProperties extends
StorageResource {
private final Map<String, DataSourceProperties> dataSourcePropertiesMap;
- public StorageResourceWithProperties(final Map<String, DataSource>
storageNodes,
+ public StorageResourceWithProperties(final Map<StorageNode, DataSource>
storageNodes,
final Map<String,
StorageUnitNodeMapper> storageUnitNodeMappers, final Map<String,
DataSourceProperties> dataSourcePropertiesMap) {
super(storageNodes, storageUnitNodeMappers);
this.dataSourcePropertiesMap = dataSourcePropertiesMap;
diff --git
a/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageUnitNodeMapper.java
b/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageUnitNodeMapper.java
index 76f45297b70..1e41a0f24f3 100644
---
a/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageUnitNodeMapper.java
+++
b/infra/datasource/core/src/main/java/org/apache/shardingsphere/infra/datasource/storage/StorageUnitNodeMapper.java
@@ -30,21 +30,21 @@ public final class StorageUnitNodeMapper {
private final String name;
- private final String nodeName;
+ private final StorageNode storageNode;
private final String catalog;
private final String url;
- public StorageUnitNodeMapper(final String name, final String nodeName,
final String url) {
- this(name, nodeName, null, url);
+ public StorageUnitNodeMapper(final String name, final StorageNode
storageNode, final String url) {
+ this(name, storageNode, null, url);
}
@Override
public boolean equals(final Object obj) {
if (obj instanceof StorageUnitNodeMapper) {
StorageUnitNodeMapper storageUnitNodeMapper =
(StorageUnitNodeMapper) obj;
- return storageUnitNodeMapper.name.equalsIgnoreCase(name) &&
storageUnitNodeMapper.nodeName.equalsIgnoreCase(nodeName) &&
isSameCatalog(storageUnitNodeMapper);
+ return storageUnitNodeMapper.name.equalsIgnoreCase(name) &&
storageUnitNodeMapper.storageNode.equals(storageNode) &&
isSameCatalog(storageUnitNodeMapper);
}
return false;
}
@@ -55,6 +55,6 @@ public final class StorageUnitNodeMapper {
@Override
public int hashCode() {
- return Objects.hashCode(name.toUpperCase(), nodeName.toUpperCase(),
null == catalog ? null : catalog.toUpperCase());
+ return Objects.hashCode(name.toUpperCase(),
storageNode.getName().toUpperCase(), null == catalog ? null :
catalog.toUpperCase());
}
}
diff --git
a/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/datasource/ShardingSphereDataSourceTest.java
b/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/datasource/ShardingSphereDataSourceTest.java
index ebee0d67c9e..2d8d561d1ae 100644
---
a/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/datasource/ShardingSphereDataSourceTest.java
+++
b/jdbc/core/src/test/java/org/apache/shardingsphere/driver/jdbc/core/datasource/ShardingSphereDataSourceTest.java
@@ -22,6 +22,7 @@ import lombok.SneakyThrows;
import
org.apache.shardingsphere.driver.jdbc.core.connection.ShardingSphereConnection;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import org.apache.shardingsphere.infra.database.core.DefaultDatabase;
+import org.apache.shardingsphere.infra.datasource.storage.StorageNode;
import
org.apache.shardingsphere.infra.executor.sql.execute.engine.ConnectionMode;
import org.apache.shardingsphere.infra.state.cluster.ClusterState;
import org.apache.shardingsphere.infra.state.instance.InstanceState;
@@ -131,9 +132,9 @@ class ShardingSphereDataSourceTest {
try (HikariDataSource dataSource = createHikariDataSource()) {
ShardingSphereDataSource actual =
createShardingSphereDataSource(dataSource);
actual.close();
- Map<String, DataSource> dataSourceMap =
getContextManager(actual).getMetaDataContexts().getMetaData()
-
.getDatabase(DefaultDatabase.LOGIC_NAME).getResourceMetaData().getStorageNodeMetaData().getDataSources();
- assertTrue(((HikariDataSource)
dataSourceMap.get("ds")).isClosed());
+ Map<StorageNode, DataSource> dataSourceMap =
getContextManager(actual).getMetaDataContexts().getMetaData()
+
.getDatabase(DefaultDatabase.LOGIC_NAME).getResourceMetaData().getStorageNodeDataSources();
+ assertTrue(((HikariDataSource) dataSourceMap.get(new
StorageNode("ds"))).isClosed());
}
}
@@ -142,9 +143,9 @@ class ShardingSphereDataSourceTest {
try (HikariDataSource dataSource = createHikariDataSource()) {
ShardingSphereDataSource actual =
createShardingSphereDataSource(dataSource);
actual.close(Collections.singleton("ds"));
- Map<String, DataSource> dataSourceMap =
getContextManager(actual).getMetaDataContexts().getMetaData()
-
.getDatabase(DefaultDatabase.LOGIC_NAME).getResourceMetaData().getStorageNodeMetaData().getDataSources();
- assertTrue(((HikariDataSource)
dataSourceMap.get("ds")).isClosed());
+ Map<StorageNode, DataSource> dataSourceMap =
getContextManager(actual).getMetaDataContexts().getMetaData()
+
.getDatabase(DefaultDatabase.LOGIC_NAME).getResourceMetaData().getStorageNodeDataSources();
+ assertTrue(((HikariDataSource) dataSourceMap.get(new
StorageNode("ds"))).isClosed());
}
}
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/MetaDataPersistService.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/MetaDataPersistService.java
index 2e105276c89..ce68f84ca42 100644
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/MetaDataPersistService.java
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/MetaDataPersistService.java
@@ -25,6 +25,7 @@ import
org.apache.shardingsphere.infra.datasource.pool.destroyer.DataSourcePoolD
import
org.apache.shardingsphere.infra.datasource.pool.config.DataSourceConfiguration;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourceProperties;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourcePropertiesCreator;
+import org.apache.shardingsphere.infra.datasource.storage.StorageNode;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import
org.apache.shardingsphere.metadata.persist.data.ShardingSphereDataPersistService;
@@ -114,15 +115,15 @@ public final class MetaDataPersistService implements
MetaDataBasedPersistService
private Map<String, DataSourceProperties> getDataSourcePropertiesMap(final
DatabaseConfiguration databaseConfigs) {
if (!databaseConfigs.getDataSources().isEmpty() &&
databaseConfigs.getDataSourcePropsMap().isEmpty()) {
- return
getDataSourcePropertiesMap(databaseConfigs.getStorageResource().getStorageNodes());
+ return
getDataSourcePropertiesMap(databaseConfigs.getStorageResource().getStorageNodeDataSources());
}
return databaseConfigs.getDataSourcePropsMap();
}
- private Map<String, DataSourceProperties> getDataSourcePropertiesMap(final
Map<String, DataSource> dataSourceMap) {
- Map<String, DataSourceProperties> result = new
LinkedHashMap<>(dataSourceMap.size(), 1F);
- for (Entry<String, DataSource> entry : dataSourceMap.entrySet()) {
- result.put(entry.getKey(),
DataSourcePropertiesCreator.create(entry.getValue()));
+ private Map<String, DataSourceProperties> getDataSourcePropertiesMap(final
Map<StorageNode, DataSource> storageNodeDataSources) {
+ Map<String, DataSourceProperties> result = new
LinkedHashMap<>(storageNodeDataSources.size(), 1F);
+ for (Entry<StorageNode, DataSource> entry :
storageNodeDataSources.entrySet()) {
+ result.put(entry.getKey().getName(),
DataSourcePropertiesCreator.create(entry.getValue()));
}
return result;
}
@@ -131,7 +132,7 @@ public final class MetaDataPersistService implements
MetaDataBasedPersistService
public Map<String, DataSourceConfiguration> getEffectiveDataSources(final
String databaseName, final Map<String, ? extends DatabaseConfiguration>
databaseConfigs) {
Map<String, DataSourceProperties> persistedDataPropsMap =
dataSourceUnitService.load(databaseName);
if (databaseConfigs.containsKey(databaseName) &&
!databaseConfigs.get(databaseName).getDataSources().isEmpty()) {
-
databaseConfigs.get(databaseName).getStorageResource().getStorageNodes().values().forEach(each
-> new DataSourcePoolDestroyer(each).asyncDestroy());
+
databaseConfigs.get(databaseName).getStorageResource().getStorageNodeDataSources().values().forEach(each
-> new DataSourcePoolDestroyer(each).asyncDestroy());
}
return
persistedDataPropsMap.entrySet().stream().collect(Collectors.toMap(Entry::getKey,
entry ->
DataSourcePropertiesCreator.createConfiguration(entry.getValue()), (key, value)
-> value, LinkedHashMap::new));
diff --git
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/NewMetaDataPersistService.java
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/NewMetaDataPersistService.java
index 2e4020a6dc8..58183642946 100644
---
a/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/NewMetaDataPersistService.java
+++
b/kernel/metadata/core/src/main/java/org/apache/shardingsphere/metadata/persist/NewMetaDataPersistService.java
@@ -25,6 +25,7 @@ import
org.apache.shardingsphere.infra.datasource.pool.config.DataSourceConfigur
import
org.apache.shardingsphere.infra.datasource.pool.destroyer.DataSourcePoolDestroyer;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourceProperties;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourcePropertiesCreator;
+import org.apache.shardingsphere.infra.datasource.storage.StorageNode;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import
org.apache.shardingsphere.metadata.persist.data.ShardingSphereDataPersistService;
@@ -121,15 +122,15 @@ public final class NewMetaDataPersistService implements
MetaDataBasedPersistServ
private Map<String, DataSourceProperties> getDataSourcePropertiesMap(final
DatabaseConfiguration databaseConfigs) {
if (!databaseConfigs.getDataSources().isEmpty() &&
databaseConfigs.getDataSourcePropsMap().isEmpty()) {
- return
getDataSourcePropertiesMap(databaseConfigs.getStorageResource().getStorageNodes());
+ return
getDataSourcePropertiesMap(databaseConfigs.getStorageResource().getStorageNodeDataSources());
}
return databaseConfigs.getDataSourcePropsMap();
}
- private Map<String, DataSourceProperties> getDataSourcePropertiesMap(final
Map<String, DataSource> dataSourceMap) {
- Map<String, DataSourceProperties> result = new
LinkedHashMap<>(dataSourceMap.size(), 1F);
- for (Entry<String, DataSource> entry : dataSourceMap.entrySet()) {
- result.put(entry.getKey(),
DataSourcePropertiesCreator.create(entry.getValue()));
+ private Map<String, DataSourceProperties> getDataSourcePropertiesMap(final
Map<StorageNode, DataSource> storageNodeDataSources) {
+ Map<String, DataSourceProperties> result = new
LinkedHashMap<>(storageNodeDataSources.size(), 1F);
+ for (Entry<StorageNode, DataSource> entry :
storageNodeDataSources.entrySet()) {
+ result.put(entry.getKey().getName(),
DataSourcePropertiesCreator.create(entry.getValue()));
}
return result;
}
@@ -145,7 +146,7 @@ public final class NewMetaDataPersistService implements
MetaDataBasedPersistServ
public Map<String, DataSourceConfiguration> getEffectiveDataSources(final
String databaseName, final Map<String, ? extends DatabaseConfiguration>
databaseConfigs) {
Map<String, DataSourceProperties> persistedDataPropsMap =
dataSourceUnitService.load(databaseName);
if (databaseConfigs.containsKey(databaseName) &&
!databaseConfigs.get(databaseName).getDataSources().isEmpty()) {
-
databaseConfigs.get(databaseName).getStorageResource().getStorageNodes().values().forEach(each
-> new DataSourcePoolDestroyer(each).asyncDestroy());
+
databaseConfigs.get(databaseName).getStorageResource().getStorageNodeDataSources().values().forEach(each
-> new DataSourcePoolDestroyer(each).asyncDestroy());
}
return
persistedDataPropsMap.entrySet().stream().collect(Collectors.toMap(Entry::getKey,
entry ->
DataSourcePropertiesCreator.createConfiguration(entry.getValue()), (key, value)
-> value, LinkedHashMap::new));
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/context/ConfigurationContextManager.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/context/ConfigurationContextManager.java
index 04fea6bc451..588cac79f8c 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/context/ConfigurationContextManager.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/context/ConfigurationContextManager.java
@@ -25,6 +25,7 @@ import
org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import
org.apache.shardingsphere.infra.config.rule.scope.DatabaseRuleConfiguration;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourceProperties;
+import org.apache.shardingsphere.infra.datasource.storage.StorageNode;
import org.apache.shardingsphere.infra.datasource.storage.StorageResource;
import
org.apache.shardingsphere.infra.datasource.storage.StorageUnitNodeMapper;
import org.apache.shardingsphere.infra.instance.InstanceContext;
@@ -269,7 +270,7 @@ public final class ConfigurationContextManager {
* @return ShardingSphere databases
*/
public Map<String, ShardingSphereDatabase> renewDatabase(final
ShardingSphereDatabase database, final SwitchingResource resource) {
- Map<String, DataSource> newStorageNodes =
getNewStorageNodes(database.getResourceMetaData().getStorageNodeMetaData().getDataSources(),
resource);
+ Map<StorageNode, DataSource> newStorageNodes =
getNewStorageNodes(database.getResourceMetaData().getStorageNodeDataSources(),
resource);
Map<String, StorageUnitNodeMapper> newStorageUnitNodeMappers =
getNewStorageUnitNodeMappers(database.getResourceMetaData().getStorageUnitMetaData().getUnitNodeMappers(),
resource);
StorageResource newStorageResource = new
StorageResource(newStorageNodes, newStorageUnitNodeMappers);
return Collections.singletonMap(database.getName().toLowerCase(),
@@ -278,10 +279,10 @@ public final class ConfigurationContextManager {
database.getRuleMetaData(), database.getSchemas()));
}
- private Map<String, DataSource> getNewStorageNodes(final Map<String,
DataSource> currentStorageNodes, final SwitchingResource resource) {
- Map<String, DataSource> result = new LinkedHashMap<>();
- for (Entry<String, DataSource> entry : currentStorageNodes.entrySet())
{
- if
(!resource.getStaleStorageResource().getStorageNodes().containsKey(entry.getKey()))
{
+ private Map<StorageNode, DataSource> getNewStorageNodes(final
Map<StorageNode, DataSource> currentStorageNodes, final SwitchingResource
resource) {
+ Map<StorageNode, DataSource> result = new LinkedHashMap<>();
+ for (Entry<StorageNode, DataSource> entry :
currentStorageNodes.entrySet()) {
+ if
(!resource.getStaleStorageResource().getStorageNodeDataSources().containsKey(entry.getKey()))
{
result.put(entry.getKey(), entry.getValue());
}
}
@@ -338,8 +339,8 @@ public final class ConfigurationContextManager {
public synchronized Map<String, ShardingSphereDatabase>
createChangedDatabases(final String databaseName, final boolean
internalLoadMetaData,
final SwitchingResource switchingResource, final
Collection<RuleConfiguration> ruleConfigs) throws SQLException {
ResourceMetaData resourceMetaData =
metaDataContexts.get().getMetaData().getDatabase(databaseName).getResourceMetaData();
- if (null != switchingResource && null !=
switchingResource.getNewStorageResource() &&
!switchingResource.getNewStorageResource().getStorageNodes().isEmpty()) {
-
resourceMetaData.getStorageNodeMetaData().getDataSources().putAll(switchingResource.getNewStorageResource().getStorageNodes());
+ if (null != switchingResource && null !=
switchingResource.getNewStorageResource() &&
!switchingResource.getNewStorageResource().getStorageNodeDataSources().isEmpty())
{
+
resourceMetaData.getStorageNodeDataSources().putAll(switchingResource.getNewStorageResource().getStorageNodeDataSources());
}
if (null != switchingResource && null !=
switchingResource.getNewStorageResource() &&
!switchingResource.getNewStorageResource().getStorageUnitNodeMappers().isEmpty())
{
resourceMetaData.getStorageUnitMetaData().getUnitNodeMappers().putAll(switchingResource.getNewStorageResource().getStorageUnitNodeMappers());
@@ -347,7 +348,7 @@ public final class ConfigurationContextManager {
Collection<RuleConfiguration> toBeCreatedRuleConfigs = null ==
ruleConfigs
?
metaDataContexts.get().getMetaData().getDatabase(databaseName).getRuleMetaData().getConfigurations()
: ruleConfigs;
- StorageResource storageResource = new
StorageResource(resourceMetaData.getStorageNodeMetaData().getDataSources(),
resourceMetaData.getStorageUnitMetaData().getUnitNodeMappers());
+ StorageResource storageResource = new
StorageResource(resourceMetaData.getStorageNodeDataSources(),
resourceMetaData.getStorageUnitMetaData().getUnitNodeMappers());
DatabaseConfiguration toBeCreatedDatabaseConfig = new
DataSourceProvidedDatabaseConfiguration(
storageResource, toBeCreatedRuleConfigs,
resourceMetaData.getStorageUnitMetaData().getDataSourcePropsMap());
ShardingSphereDatabase changedDatabase =
createChangedDatabase(metaDataContexts.get().getMetaData().getDatabase(databaseName).getName(),
internalLoadMetaData,
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/switcher/NewResourceSwitchManager.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/switcher/NewResourceSwitchManager.java
index 871afefa696..ee2fd671c84 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/switcher/NewResourceSwitchManager.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/switcher/NewResourceSwitchManager.java
@@ -19,6 +19,7 @@ package org.apache.shardingsphere.mode.manager.switcher;
import
org.apache.shardingsphere.infra.datasource.pool.creator.DataSourcePoolCreator;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourceProperties;
+import org.apache.shardingsphere.infra.datasource.storage.StorageNode;
import org.apache.shardingsphere.infra.datasource.storage.StorageResource;
import
org.apache.shardingsphere.infra.datasource.storage.StorageResourceWithProperties;
import
org.apache.shardingsphere.infra.datasource.storage.StorageUnitNodeMapper;
@@ -51,10 +52,10 @@ public final class NewResourceSwitchManager {
}
private StorageResource getRegisterNewStorageResource(final
ResourceMetaData resourceMetaData, final StorageResourceWithProperties
toBeCreatedStorageResource) {
- Map<String, DataSource> storageNodes = new
LinkedHashMap<>(toBeCreatedStorageResource.getStorageNodes().size(), 1F);
- for (String each :
toBeCreatedStorageResource.getStorageNodes().keySet()) {
- if
(!resourceMetaData.getStorageNodeMetaData().getDataSources().containsKey(each))
{
- storageNodes.put(each,
DataSourcePoolCreator.create(toBeCreatedStorageResource.getDataSourcePropertiesMap().get(each)));
+ Map<StorageNode, DataSource> storageNodes = new
LinkedHashMap<>(toBeCreatedStorageResource.getStorageNodeDataSources().size(),
1F);
+ for (StorageNode each :
toBeCreatedStorageResource.getStorageNodeDataSources().keySet()) {
+ if
(!resourceMetaData.getStorageNodeDataSources().containsKey(each)) {
+ storageNodes.put(each,
DataSourcePoolCreator.create(toBeCreatedStorageResource.getDataSourcePropertiesMap().get(each.getName())));
}
}
return new StorageResource(storageNodes,
toBeCreatedStorageResource.getStorageUnitNodeMappers());
@@ -75,17 +76,17 @@ public final class NewResourceSwitchManager {
}
private StorageResource getAlterNewStorageResource(final
StorageResourceWithProperties toBeAlteredStorageResource) {
- Map<String, DataSource> storageNodes = new
LinkedHashMap<>(toBeAlteredStorageResource.getStorageNodes().size(), 1F);
- for (String each :
toBeAlteredStorageResource.getStorageNodes().keySet()) {
- storageNodes.put(each,
DataSourcePoolCreator.create(toBeAlteredStorageResource.getDataSourcePropertiesMap().get(each)));
+ Map<StorageNode, DataSource> storageNodes = new
LinkedHashMap<>(toBeAlteredStorageResource.getStorageNodeDataSources().size(),
1F);
+ for (StorageNode each :
toBeAlteredStorageResource.getStorageNodeDataSources().keySet()) {
+ storageNodes.put(each,
DataSourcePoolCreator.create(toBeAlteredStorageResource.getDataSourcePropertiesMap().get(each.getName())));
}
return new StorageResource(storageNodes,
toBeAlteredStorageResource.getStorageUnitNodeMappers());
}
private StorageResource getStaleStorageResource(final ResourceMetaData
resourceMetaData, final StorageResourceWithProperties
toBeAlteredStorageResource) {
- Map<String, DataSource> storageNodes = new
LinkedHashMap<>(toBeAlteredStorageResource.getStorageNodes().size(), 1F);
- for (Entry<String, DataSource> entry :
resourceMetaData.getStorageNodeMetaData().getDataSources().entrySet()) {
- if
(toBeAlteredStorageResource.getStorageNodes().containsKey(entry.getKey())) {
+ Map<StorageNode, DataSource> storageNodes = new
LinkedHashMap<>(toBeAlteredStorageResource.getStorageNodeDataSources().size(),
1F);
+ for (Entry<StorageNode, DataSource> entry :
resourceMetaData.getStorageNodeDataSources().entrySet()) {
+ if
(toBeAlteredStorageResource.getStorageNodeDataSources().containsKey(entry.getKey()))
{
storageNodes.put(entry.getKey(), entry.getValue());
}
}
@@ -108,9 +109,9 @@ public final class NewResourceSwitchManager {
private StorageResource getToBeRemovedStaleStorageResource(final
ResourceMetaData resourceMetaData, final String storageUnitName) {
StorageUnitNodeMapper storageUnitNodeMapper =
resourceMetaData.getStorageUnitMetaData().getUnitNodeMappers().remove(storageUnitName);
Map<String, StorageUnitNodeMapper> reservedStorageUnitNodeMappers =
resourceMetaData.getStorageUnitMetaData().getUnitNodeMappers();
- Map<String, DataSource> storageNodes = new LinkedHashMap<>(1, 1F);
- if (reservedStorageUnitNodeMappers.values().stream().noneMatch(each ->
each.getNodeName().equals(storageUnitNodeMapper.getNodeName()))) {
- storageNodes.put(storageUnitNodeMapper.getNodeName(),
resourceMetaData.getStorageNodeMetaData().getDataSources().get(storageUnitNodeMapper.getNodeName()));
+ Map<StorageNode, DataSource> storageNodes = new LinkedHashMap<>(1, 1F);
+ if (reservedStorageUnitNodeMappers.values().stream().noneMatch(each ->
each.getStorageNode().equals(storageUnitNodeMapper.getStorageNode()))) {
+ storageNodes.put(storageUnitNodeMapper.getStorageNode(),
resourceMetaData.getStorageNodeDataSources().get(storageUnitNodeMapper.getStorageNode()));
}
return new StorageResource(storageNodes,
Collections.singletonMap(storageUnitName, storageUnitNodeMapper));
}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/switcher/ResourceSwitchManager.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/switcher/ResourceSwitchManager.java
index caba3d2e413..076a4b79b8e 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/switcher/ResourceSwitchManager.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/switcher/ResourceSwitchManager.java
@@ -20,6 +20,7 @@ package org.apache.shardingsphere.mode.manager.switcher;
import
org.apache.shardingsphere.infra.datasource.pool.creator.DataSourcePoolCreator;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourceProperties;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourcePropertiesCreator;
+import org.apache.shardingsphere.infra.datasource.storage.StorageNode;
import org.apache.shardingsphere.infra.datasource.storage.StorageResource;
import
org.apache.shardingsphere.infra.datasource.storage.StorageResourceWithProperties;
import
org.apache.shardingsphere.infra.datasource.storage.StorageUnitNodeMapper;
@@ -83,24 +84,26 @@ public final class ResourceSwitchManager {
resourceMetaData.getStorageUnitMetaData().getDataSourcePropsMap().putAll(toBeChangedDataSourceProps);
StorageResourceWithProperties toBeChangedStorageResource =
DataSourcePoolCreator.createStorageResourceWithoutDataSource(toBeChangedDataSourceProps);
StorageResource staleStorageResource =
getStaleDataSources(resourceMetaData, toBeChangedStorageResource);
-
staleStorageResource.getStorageNodes().putAll(getToBeDeletedDataSources(resourceMetaData.getStorageNodeMetaData().getDataSources(),
toBeChangedStorageResource.getStorageNodes().keySet()));
+ staleStorageResource.getStorageNodeDataSources()
+
.putAll(getToBeDeletedDataSources(resourceMetaData.getStorageNodeDataSources(),
toBeChangedStorageResource.getStorageNodeDataSources().keySet()));
staleStorageResource.getStorageUnitNodeMappers().putAll(
getToBeDeletedStorageUnitNodeMappers(resourceMetaData.getStorageUnitMetaData().getUnitNodeMappers(),
toBeChangedStorageResource.getStorageUnitNodeMappers().keySet()));
return new SwitchingResource(resourceMetaData,
createNewStorageResource(resourceMetaData, toBeChangedStorageResource),
staleStorageResource, toBeChangedDataSourceProps);
}
private StorageResource createNewStorageResource(final ResourceMetaData
resourceMetaData, final StorageResourceWithProperties
toBeChangedStorageResource) {
- Map<String, DataSource> storageNodes =
getNewStorageNodes(resourceMetaData,
toBeChangedStorageResource.getStorageNodes(),
toBeChangedStorageResource.getDataSourcePropertiesMap());
+ Map<StorageNode, DataSource> storageNodes =
+ getNewStorageNodes(resourceMetaData,
toBeChangedStorageResource.getStorageNodeDataSources(),
toBeChangedStorageResource.getDataSourcePropertiesMap());
Map<String, StorageUnitNodeMapper> storageUnitNodeMappers =
getNewStorageUnitNodeMappers(resourceMetaData,
toBeChangedStorageResource.getStorageUnitNodeMappers());
return new StorageResource(storageNodes, storageUnitNodeMappers);
}
- private Map<String, DataSource> getNewStorageNodes(final ResourceMetaData
resourceMetaData, final Map<String, DataSource> toBeChangedStorageNodes,
- final Map<String,
DataSourceProperties> dataSourcePropertiesMap) {
- Map<String, DataSource> result = new
LinkedHashMap<>(resourceMetaData.getStorageNodeMetaData().getDataSources());
-
result.keySet().removeAll(getToBeDeletedDataSources(resourceMetaData.getStorageNodeMetaData().getDataSources(),
toBeChangedStorageNodes.keySet()).keySet());
-
result.putAll(getChangedDataSources(resourceMetaData.getStorageNodeMetaData().getDataSources(),
toBeChangedStorageNodes, dataSourcePropertiesMap));
-
result.putAll(getToBeAddedDataSources(resourceMetaData.getStorageNodeMetaData().getDataSources(),
toBeChangedStorageNodes, dataSourcePropertiesMap));
+ private Map<StorageNode, DataSource> getNewStorageNodes(final
ResourceMetaData resourceMetaData, final Map<StorageNode, DataSource>
toBeChangedStorageNodes,
+ final Map<String,
DataSourceProperties> dataSourcePropertiesMap) {
+ Map<StorageNode, DataSource> result = new
LinkedHashMap<>(resourceMetaData.getStorageNodeDataSources());
+
result.keySet().removeAll(getToBeDeletedDataSources(resourceMetaData.getStorageNodeDataSources(),
toBeChangedStorageNodes.keySet()).keySet());
+
result.putAll(getChangedDataSources(resourceMetaData.getStorageNodeDataSources(),
toBeChangedStorageNodes, dataSourcePropertiesMap));
+
result.putAll(getToBeAddedDataSources(resourceMetaData.getStorageNodeDataSources(),
toBeChangedStorageNodes, dataSourcePropertiesMap));
return result;
}
@@ -112,27 +115,27 @@ public final class ResourceSwitchManager {
return result;
}
- private Map<String, DataSource> getChangedDataSources(final Map<String,
DataSource> storageNodes, final Map<String, DataSource> toBeChangedStorageNodes,
- final Map<String,
DataSourceProperties> dataSourcePropertiesMap) {
- Collection<String> toBeChangedDataSourceNames =
toBeChangedStorageNodes.keySet().stream()
- .filter(each -> isModifiedDataSource(storageNodes, each,
dataSourcePropertiesMap.get(each))).collect(Collectors.toList());
- Map<String, DataSource> result = new
LinkedHashMap<>(toBeChangedStorageNodes.size(), 1F);
- for (String each : toBeChangedDataSourceNames) {
- result.put(each,
DataSourcePoolCreator.create(dataSourcePropertiesMap.get(each)));
+ private Map<StorageNode, DataSource> getChangedDataSources(final
Map<StorageNode, DataSource> storageNodes, final Map<StorageNode, DataSource>
toBeChangedStorageNodes,
+ final
Map<String, DataSourceProperties> dataSourcePropertiesMap) {
+ Collection<StorageNode> toBeChangedDataSourceNames =
toBeChangedStorageNodes.keySet().stream()
+ .filter(each -> isModifiedDataSource(storageNodes, each,
dataSourcePropertiesMap.get(each.getName()))).collect(Collectors.toList());
+ Map<StorageNode, DataSource> result = new
LinkedHashMap<>(toBeChangedStorageNodes.size(), 1F);
+ for (StorageNode each : toBeChangedDataSourceNames) {
+ result.put(each,
DataSourcePoolCreator.create(dataSourcePropertiesMap.get(each.getName())));
}
return result;
}
- private boolean isModifiedDataSource(final Map<String, DataSource>
originalDataSources, final String dataSourceName, final DataSourceProperties
dataSourceProps) {
- return originalDataSources.containsKey(dataSourceName) &&
!dataSourceProps.equals(DataSourcePropertiesCreator.create(originalDataSources.get(dataSourceName)));
+ private boolean isModifiedDataSource(final Map<StorageNode, DataSource>
originalDataSources, final StorageNode storageNode, final DataSourceProperties
dataSourceProps) {
+ return originalDataSources.containsKey(storageNode) &&
!dataSourceProps.equals(DataSourcePropertiesCreator.create(originalDataSources.get(storageNode)));
}
- private Map<String, DataSource> getToBeAddedDataSources(final Map<String,
DataSource> storageNodes, final Map<String, DataSource> toBeChangedStorageNodes,
- final Map<String,
DataSourceProperties> dataSourcePropertiesMap) {
- Collection<String> toBeAddedDataSourceNames =
toBeChangedStorageNodes.keySet().stream().filter(each ->
!storageNodes.containsKey(each)).collect(Collectors.toList());
- Map<String, DataSource> result = new LinkedHashMap<>();
- for (String each : toBeAddedDataSourceNames) {
- result.put(each,
DataSourcePoolCreator.create(dataSourcePropertiesMap.get(each)));
+ private Map<StorageNode, DataSource> getToBeAddedDataSources(final
Map<StorageNode, DataSource> storageNodes, final Map<StorageNode, DataSource>
toBeChangedStorageNodes,
+ final
Map<String, DataSourceProperties> dataSourcePropertiesMap) {
+ Collection<StorageNode> toBeAddedDataSourceNames =
toBeChangedStorageNodes.keySet().stream().filter(each ->
!storageNodes.containsKey(each)).collect(Collectors.toList());
+ Map<StorageNode, DataSource> result = new LinkedHashMap<>();
+ for (StorageNode each : toBeAddedDataSourceNames) {
+ result.put(each,
DataSourcePoolCreator.create(dataSourcePropertiesMap.get(each.getName())));
}
return result;
}
@@ -140,9 +143,9 @@ public final class ResourceSwitchManager {
private StorageResource getToBeRemovedStaleDataSources(final
ResourceMetaData resourceMetaData, final StorageResourceWithProperties
toBeRemovedStorageResource) {
Map<String, StorageUnitNodeMapper> reservedStorageUnitNodeMappers =
resourceMetaData.getStorageUnitMetaData().getUnitNodeMappers().entrySet().stream()
.filter(entry ->
!toBeRemovedStorageResource.getStorageUnitNodeMappers().containsKey(entry.getKey())).collect(Collectors.toMap(Entry::getKey,
Entry::getValue));
- Collection<String> inUsedDataSourceNames =
reservedStorageUnitNodeMappers.values().stream().map(StorageUnitNodeMapper::getNodeName).collect(Collectors.toSet());
- Map<String, DataSource> staleStorageNodes =
resourceMetaData.getStorageNodeMetaData().getDataSources().entrySet().stream()
- .filter(entry ->
toBeRemovedStorageResource.getStorageNodes().containsKey(entry.getKey()) &&
!inUsedDataSourceNames.contains(entry.getKey()))
+ Collection<StorageNode> inUsedDataSourceNames =
reservedStorageUnitNodeMappers.values().stream().map(StorageUnitNodeMapper::getStorageNode).collect(Collectors.toSet());
+ Map<StorageNode, DataSource> staleStorageNodes =
resourceMetaData.getStorageNodeDataSources().entrySet().stream()
+ .filter(entry ->
toBeRemovedStorageResource.getStorageNodeDataSources().containsKey(entry.getKey())
&& !inUsedDataSourceNames.contains(entry.getKey()))
.collect(Collectors.toMap(Entry::getKey, Entry::getValue));
Map<String, StorageUnitNodeMapper> staleStorageUnitNodeMappers =
resourceMetaData.getStorageUnitMetaData().getUnitNodeMappers().entrySet().stream()
.filter(entry ->
!reservedStorageUnitNodeMappers.containsKey(entry.getKey())).collect(Collectors.toMap(Entry::getKey,
Entry::getValue));
@@ -150,26 +153,27 @@ public final class ResourceSwitchManager {
}
private StorageResource getStaleDataSources(final ResourceMetaData
resourceMetaData, final StorageResourceWithProperties
toBeChangedStorageResource) {
- Map<String, DataSource> storageNodes = new
LinkedHashMap<>(resourceMetaData.getStorageNodeMetaData().getDataSources().size(),
1F);
+ Map<StorageNode, DataSource> storageNodes = new
LinkedHashMap<>(resourceMetaData.getStorageNodeDataSources().size(), 1F);
Map<String, StorageUnitNodeMapper> storageUnitNodeMappers = new
LinkedHashMap<>(resourceMetaData.getStorageUnitMetaData().getUnitNodeMappers().size(),
1F);
-
storageNodes.putAll(getToBeChangedDataSources(resourceMetaData.getStorageNodeMetaData().getDataSources(),
toBeChangedStorageResource.getDataSourcePropertiesMap()));
+
storageNodes.putAll(getToBeChangedDataSources(resourceMetaData.getStorageNodeDataSources(),
toBeChangedStorageResource.getDataSourcePropertiesMap()));
storageUnitNodeMappers.putAll(getChangedStorageUnitNodeMappers(resourceMetaData.getStorageUnitMetaData().getUnitNodeMappers(),
toBeChangedStorageResource.getStorageUnitNodeMappers()));
return new StorageResource(storageNodes, storageUnitNodeMappers);
}
- private Map<String, DataSource> getToBeChangedDataSources(final
Map<String, DataSource> storageNodes, final Map<String, DataSourceProperties>
dataSourcePropertiesMap) {
- Map<String, DataSource> result = new
LinkedHashMap<>(storageNodes.size(), 1F);
+ private Map<StorageNode, DataSource> getToBeChangedDataSources(final
Map<StorageNode, DataSource> storageNodes, final Map<String,
DataSourceProperties> dataSourcePropertiesMap) {
+ Map<StorageNode, DataSource> result = new
LinkedHashMap<>(storageNodes.size(), 1F);
for (Entry<String, DataSourceProperties> entry :
dataSourcePropertiesMap.entrySet()) {
- if (isModifiedDataSource(storageNodes, entry.getKey(),
entry.getValue())) {
- result.put(entry.getKey(), storageNodes.get(entry.getKey()));
+ StorageNode storageNode = new StorageNode(entry.getKey());
+ if (isModifiedDataSource(storageNodes, storageNode,
entry.getValue())) {
+ result.put(storageNode, storageNodes.get(storageNode));
}
}
return result;
}
- private Map<String, DataSource> getToBeDeletedDataSources(final
Map<String, DataSource> storageNodes, final Collection<String>
toBeChangedDataSourceNames) {
- Map<String, DataSource> result = new
LinkedHashMap<>(storageNodes.size(), 1F);
- for (Entry<String, DataSource> entry : storageNodes.entrySet()) {
+ private Map<StorageNode, DataSource> getToBeDeletedDataSources(final
Map<StorageNode, DataSource> storageNodes, final Collection<StorageNode>
toBeChangedDataSourceNames) {
+ Map<StorageNode, DataSource> result = new
LinkedHashMap<>(storageNodes.size(), 1F);
+ for (Entry<StorageNode, DataSource> entry : storageNodes.entrySet()) {
if (!toBeChangedDataSourceNames.contains(entry.getKey())) {
result.put(entry.getKey(), entry.getValue());
}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/switcher/SwitchingResource.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/switcher/SwitchingResource.java
index c17aa5ed5bb..6be8230a314 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/switcher/SwitchingResource.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/switcher/SwitchingResource.java
@@ -47,6 +47,6 @@ public final class SwitchingResource {
* Close stale data sources.
*/
public void closeStaleDataSources() {
-
staleStorageResource.getStorageNodes().values().stream().filter(Objects::nonNull).forEach(resourceMetaData::close);
+
staleStorageResource.getStorageNodeDataSources().values().stream().filter(Objects::nonNull).forEach(resourceMetaData::close);
}
}
diff --git
a/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
b/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
index 37f55859eb1..af5dca51d1f 100644
---
a/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
+++
b/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
@@ -24,7 +24,8 @@ import
org.apache.shardingsphere.infra.database.core.DefaultDatabase;
import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.datanode.DataNode;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourceProperties;
-import org.apache.shardingsphere.infra.datasource.storage.StorageUtils;
+import org.apache.shardingsphere.infra.datasource.storage.StorageNode;
+import org.apache.shardingsphere.infra.datasource.storage.StorageResourceUtils;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.instance.mode.ModeContextManager;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
@@ -214,8 +215,8 @@ class ContextManagerTest {
void assertAlterRuleConfiguration() {
ResourceMetaData resourceMetaData = mock(ResourceMetaData.class,
RETURNS_DEEP_STUBS);
Map<String, DataSource> dataSources = Collections.singletonMap("ds_0",
new MockedDataSource());
-
when(resourceMetaData.getStorageNodeMetaData().getDataSources()).thenReturn(dataSources);
-
when(resourceMetaData.getStorageUnitMetaData().getUnitNodeMappers()).thenReturn(StorageUtils.getStorageUnitNodeMappers(dataSources));
+
when(resourceMetaData.getStorageNodeDataSources()).thenReturn(StorageResourceUtils.getStorageNodeDataSources(dataSources));
+
when(resourceMetaData.getStorageUnitMetaData().getUnitNodeMappers()).thenReturn(StorageResourceUtils.getStorageUnitNodeMappers(dataSources));
ShardingSphereDatabase database = new ShardingSphereDatabase("foo_db",
TypedSPILoader.getService(DatabaseType.class, "FIXTURE"),
resourceMetaData, mock(RuleMetaData.class), Collections.emptyMap());
when(metaDataContexts.getMetaData().getDatabase("foo_db")).thenReturn(database);
@@ -235,7 +236,7 @@ class ContextManagerTest {
Collections.singletonMap("foo_ds", new
DataSourceProperties(MockedDataSource.class.getName(), createProperties("test",
"test"))));
assertThat(contextManager.getMetaDataContexts().getMetaData().getDatabase("foo_db").getResourceMetaData().getDataSources().size(),
is(3));
assertAlteredDataSource((MockedDataSource)
contextManager.getMetaDataContexts().getMetaData().getDatabase("foo_db")
-
.getResourceMetaData().getStorageNodeMetaData().getDataSources().get("foo_ds"));
+ .getResourceMetaData().getStorageNodeDataSources().get(new
StorageNode("foo_ds")));
}
private ResourceMetaData createOriginalResource() {
@@ -244,8 +245,8 @@ class ContextManagerTest {
originalDataSources.put("ds_1", new MockedDataSource());
originalDataSources.put("ds_2", new MockedDataSource());
when(result.getDataSources()).thenReturn(originalDataSources);
-
when(result.getStorageNodeMetaData().getDataSources()).thenReturn(originalDataSources);
-
when(result.getStorageUnitMetaData().getUnitNodeMappers()).thenReturn(StorageUtils.getStorageUnitNodeMappers(originalDataSources));
+
when(result.getStorageNodeDataSources()).thenReturn(StorageResourceUtils.getStorageNodeDataSources(originalDataSources));
+
when(result.getStorageUnitMetaData().getUnitNodeMappers()).thenReturn(StorageResourceUtils.getStorageUnitNodeMappers(originalDataSources));
return result;
}
diff --git
a/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/switcher/ResourceSwitchManagerTest.java
b/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/switcher/ResourceSwitchManagerTest.java
index 9b727c951a0..30431edb774 100644
---
a/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/switcher/ResourceSwitchManagerTest.java
+++
b/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/switcher/ResourceSwitchManagerTest.java
@@ -18,6 +18,7 @@
package org.apache.shardingsphere.mode.manager.switcher;
import
org.apache.shardingsphere.infra.datasource.pool.props.DataSourceProperties;
+import org.apache.shardingsphere.infra.datasource.storage.StorageNode;
import
org.apache.shardingsphere.infra.metadata.database.resource.ResourceMetaData;
import org.apache.shardingsphere.test.fixture.jdbc.MockedDataSource;
import org.awaitility.Awaitility;
@@ -52,8 +53,8 @@ class ResourceSwitchManagerTest {
dataSourceMap.put("ds_0", new MockedDataSource());
dataSourceMap.put("ds_1", new MockedDataSource());
SwitchingResource actual = new
ResourceSwitchManager().createByAlterDataSourceProps(new
ResourceMetaData("sharding_db", dataSourceMap), Collections.emptyMap());
- assertTrue(actual.getNewStorageResource().getStorageNodes().isEmpty());
- assertThat(actual.getStaleStorageResource().getStorageNodes().size(),
is(2));
+
assertTrue(actual.getNewStorageResource().getStorageNodeDataSources().isEmpty());
+
assertThat(actual.getStaleStorageResource().getStorageNodeDataSources().size(),
is(2));
actual.closeStaleDataSources();
assertStaleDataSource((MockedDataSource) dataSourceMap.get("ds_0"));
assertStaleDataSource((MockedDataSource) dataSourceMap.get("ds_1"));
@@ -84,10 +85,10 @@ class ResourceSwitchManagerTest {
}
private void assertNewDataSources(final SwitchingResource actual) {
- assertThat(actual.getNewStorageResource().getStorageNodes().size(),
is(3));
-
assertTrue(actual.getNewStorageResource().getStorageNodes().containsKey("not_change"));
-
assertTrue(actual.getNewStorageResource().getStorageNodes().containsKey("new"));
-
assertTrue(actual.getNewStorageResource().getStorageNodes().containsKey("replace"));
+
assertThat(actual.getNewStorageResource().getStorageNodeDataSources().size(),
is(3));
+
assertTrue(actual.getNewStorageResource().getStorageNodeDataSources().containsKey(new
StorageNode("not_change")));
+
assertTrue(actual.getNewStorageResource().getStorageNodeDataSources().containsKey(new
StorageNode("new")));
+
assertTrue(actual.getNewStorageResource().getStorageNodeDataSources().containsKey(new
StorageNode("replace")));
}
private void assertStaleDataSources(final Map<String, DataSource>
originalDataSourceMap) {
diff --git
a/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/switcher/SwitchingResourceTest.java
b/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/switcher/SwitchingResourceTest.java
index 6cc4f6f1b50..bfd163b17fb 100644
---
a/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/switcher/SwitchingResourceTest.java
+++
b/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/switcher/SwitchingResourceTest.java
@@ -17,6 +17,7 @@
package org.apache.shardingsphere.mode.manager.switcher;
+import org.apache.shardingsphere.infra.datasource.storage.StorageNode;
import org.apache.shardingsphere.infra.datasource.storage.StorageResource;
import
org.apache.shardingsphere.infra.metadata.database.resource.ResourceMetaData;
import org.apache.shardingsphere.test.fixture.jdbc.MockedDataSource;
@@ -33,8 +34,8 @@ class SwitchingResourceTest {
void assertCloseStaleDataSources() {
MockedDataSource staleDataSource = new MockedDataSource();
ResourceMetaData resourceMetaData = mock(ResourceMetaData.class);
- StorageResource newStorageResource = new
StorageResource(Collections.singletonMap("new_ds", new MockedDataSource()),
Collections.emptyMap());
- StorageResource staleStorageResource = new
StorageResource(Collections.singletonMap("stale_ds", staleDataSource),
Collections.emptyMap());
+ StorageResource newStorageResource = new
StorageResource(Collections.singletonMap(new StorageNode("new_ds"), new
MockedDataSource()), Collections.emptyMap());
+ StorageResource staleStorageResource = new
StorageResource(Collections.singletonMap(new StorageNode("stale_ds"),
staleDataSource), Collections.emptyMap());
new SwitchingResource(resourceMetaData, newStorageResource,
staleStorageResource, Collections.emptyMap()).closeStaleDataSources();
verify(resourceMetaData).close(staleDataSource);
}
diff --git
a/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/coordinator/subscriber/ConfigurationChangedSubscriberTest.java
b/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/coordinator/subscriber/ConfigurationChangedSubscriberTest.java
index 7da9bc530ec..300ea1f75d8 100644
---
a/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/coordinator/subscriber/ConfigurationChangedSubscriberTest.java
+++
b/mode/type/cluster/core/src/test/java/org/apache/shardingsphere/mode/manager/cluster/coordinator/subscriber/ConfigurationChangedSubscriberTest.java
@@ -114,7 +114,7 @@ class ConfigurationChangedSubscriberTest {
when(database.getName()).thenReturn("db");
ResourceMetaData resourceMetaData = mock(ResourceMetaData.class,
RETURNS_DEEP_STUBS);
when(database.getResourceMetaData()).thenReturn(resourceMetaData);
-
when(resourceMetaData.getStorageNodeMetaData().getDataSources()).thenReturn(Collections.emptyMap());
+
when(resourceMetaData.getStorageNodeDataSources()).thenReturn(Collections.emptyMap());
when(resourceMetaData.getStorageUnitMetaData().getUnitNodeMappers()).thenReturn(Collections.emptyMap());
when(database.getSchemas()).thenReturn(Collections.singletonMap("foo_schema",
new ShardingSphereSchema()));
when(database.getProtocolType()).thenReturn(TypedSPILoader.getService(DatabaseType.class,
"FIXTURE"));
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/config/yaml/swapper/YamlProxyConfigurationSwapperTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/config/yaml/swapper/YamlProxyConfigurationSwapperTest.java
index 7dc6539e7d2..6f133fc59a5 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/config/yaml/swapper/YamlProxyConfigurationSwapperTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/config/yaml/swapper/YamlProxyConfigurationSwapperTest.java
@@ -22,6 +22,7 @@ import
org.apache.shardingsphere.authority.config.AuthorityRuleConfiguration;
import org.apache.shardingsphere.infra.config.algorithm.AlgorithmConfiguration;
import org.apache.shardingsphere.infra.config.database.DatabaseConfiguration;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
+import org.apache.shardingsphere.infra.datasource.storage.StorageNode;
import org.apache.shardingsphere.proxy.backend.config.ProxyConfiguration;
import org.apache.shardingsphere.proxy.backend.config.ProxyConfigurationLoader;
import org.apache.shardingsphere.proxy.backend.config.YamlProxyConfiguration;
@@ -55,7 +56,7 @@ class YamlProxyConfigurationSwapperTest {
private void assertDataSources(final ProxyConfiguration proxyConfig) {
Map<String, DatabaseConfiguration> actual =
proxyConfig.getDatabaseConfigurations();
assertThat(actual.size(), is(1));
- HikariDataSource dataSource = (HikariDataSource)
actual.get("swapper_test").getStorageResource().getStorageNodes().get("foo_db");
+ HikariDataSource dataSource = (HikariDataSource)
actual.get("swapper_test").getStorageResource().getStorageNodeDataSources().get(new
StorageNode("foo_db"));
assertThat(dataSource.getJdbcUrl(),
is("jdbc:h2:mem:foo_db;DB_CLOSE_DELAY=-1"));
assertThat(dataSource.getUsername(), is("sa"));
assertThat(dataSource.getPassword(), is(""));
