This is an automated email from the ASF dual-hosted git repository.
yx9o 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 9c45d37b9f5 Refactor
StorageResourceCreator.getStorageUnitNodeMappers() (#28596)
9c45d37b9f5 is described below
commit 9c45d37b9f568b319926d8c79ca441df103415ef
Author: Liang Zhang <[email protected]>
AuthorDate: Wed Sep 27 08:19:12 2023 +0800
Refactor StorageResourceCreator.getStorageUnitNodeMappers() (#28596)
* Decouple ResourceMetaData and StorageResource
* Refactor StorageResourceCreator.getStorageUnitNodeMappers()
---
.../metadata/database/ShardingSphereDatabase.java | 2 +-
.../database/resource/ResourceMetaData.java | 8 +--
.../database/resource/StorageResourceCreator.java | 59 ++++++++++------------
.../context/ConfigurationContextManager.java | 5 +-
.../manager/switcher/NewResourceSwitchManager.java | 41 ++++++++-------
.../manager/switcher/ResourceSwitchManager.java | 58 +++++++++++----------
6 files changed, 88 insertions(+), 85 deletions(-)
diff --git
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/ShardingSphereDatabase.java
b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/ShardingSphereDatabase.java
index 3c83c2bd206..d7571a1280d 100644
---
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/ShardingSphereDatabase.java
+++
b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/ShardingSphereDatabase.java
@@ -124,7 +124,7 @@ public final class ShardingSphereDatabase {
}
private static ResourceMetaData createResourceMetaData(final String
databaseName, final StorageResource storageResource, final Map<String,
DataSourcePoolProperties> propsMap) {
- return new ResourceMetaData(databaseName, storageResource, propsMap);
+ return new ResourceMetaData(databaseName,
storageResource.getDataSourceMap(),
storageResource.getStorageUnitNodeMappers(), propsMap);
}
/**
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 9c4bd9b3e85..c92a0f6aa09 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
@@ -26,6 +26,7 @@ import
org.apache.shardingsphere.infra.datasource.pool.props.creator.DataSourceP
import
org.apache.shardingsphere.infra.metadata.database.resource.node.StorageNode;
import
org.apache.shardingsphere.infra.metadata.database.resource.unit.StorageUnit;
import
org.apache.shardingsphere.infra.metadata.database.resource.unit.StorageUnitMetaData;
+import
org.apache.shardingsphere.infra.metadata.database.resource.unit.StorageUnitNodeMapper;
import javax.sql.DataSource;
import java.util.Collection;
@@ -56,9 +57,10 @@ public final class ResourceMetaData {
StorageResourceUtils.getStorageUnitNodeMappers(dataSources));
}
- public ResourceMetaData(final String databaseName, final StorageResource
storageResource, final Map<String, DataSourcePoolProperties> propsMap) {
- dataSourceMap = storageResource.getDataSourceMap();
- storageUnitMetaData = new StorageUnitMetaData(databaseName,
dataSourceMap, propsMap, storageResource.getStorageUnitNodeMappers());
+ public ResourceMetaData(final String databaseName, final Map<StorageNode,
DataSource> dataSourceMap,
+ final Map<String, StorageUnitNodeMapper>
storageUnitNodeMappers, final Map<String, DataSourcePoolProperties> propsMap) {
+ this.dataSourceMap = dataSourceMap;
+ storageUnitMetaData = new StorageUnitMetaData(databaseName,
dataSourceMap, propsMap, storageUnitNodeMappers);
}
/**
diff --git
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/StorageResourceCreator.java
b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/StorageResourceCreator.java
index 70ed45e9df4..5dd9d6e2468 100644
---
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/StorageResourceCreator.java
+++
b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/StorageResourceCreator.java
@@ -53,18 +53,36 @@ public final class StorageResourceCreator {
Map<String, StorageUnitNodeMapper> mappers = new LinkedHashMap<>();
for (Entry<String, DataSourcePoolProperties> entry :
propsMap.entrySet()) {
String storageUnitName = entry.getKey();
- Map<String, Object> standardProps =
entry.getValue().getConnectionPropertySynonyms().getStandardProperties();
- String url = standardProps.get("url").toString();
- boolean isInstanceConnectionAvailable = new
DatabaseTypeRegistry(DatabaseTypeFactory.get(url)).getDialectDatabaseMetaData().isInstanceConnectionAvailable();
- StorageNode storageNode = new
StorageNode(getStorageNodeName(storageUnitName, url,
standardProps.get("username").toString(), isInstanceConnectionAvailable));
- if (!storageNodes.containsKey(storageNode)) {
- storageNodes.put(storageNode,
DataSourcePoolCreator.create(storageUnitName, entry.getValue(), true,
storageNodes.values()));
- }
- mappers.put(storageUnitName, getStorageUnitNodeMapper(storageNode,
storageUnitName, url, isInstanceConnectionAvailable));
+ StorageUnitNodeMapper mapper =
getStorageUnitNodeMapper(storageUnitName, entry.getValue());
+ mappers.put(storageUnitName, mapper);
+ storageNodes.computeIfAbsent(mapper.getStorageNode(), key ->
DataSourcePoolCreator.create(storageUnitName, entry.getValue(), true,
storageNodes.values()));
}
return new StorageResource(storageNodes, mappers);
}
+ /**
+ * Get storage unit node mappers.
+ *
+ * @param propsMap data source pool properties map
+ * @return storage unit node mappers
+ */
+ public static Map<String, StorageUnitNodeMapper>
getStorageUnitNodeMappers(final Map<String, DataSourcePoolProperties> propsMap)
{
+ Map<String, StorageUnitNodeMapper> result = new LinkedHashMap<>();
+ for (Entry<String, DataSourcePoolProperties> entry :
propsMap.entrySet()) {
+ String storageUnitName = entry.getKey();
+ result.put(storageUnitName,
getStorageUnitNodeMapper(storageUnitName, entry.getValue()));
+ }
+ return result;
+ }
+
+ private static StorageUnitNodeMapper getStorageUnitNodeMapper(final String
storageUnitName, final DataSourcePoolProperties props) {
+ Map<String, Object> standardProps =
props.getConnectionPropertySynonyms().getStandardProperties();
+ String url = standardProps.get("url").toString();
+ boolean isInstanceConnectionAvailable = new
DatabaseTypeRegistry(DatabaseTypeFactory.get(url)).getDialectDatabaseMetaData().isInstanceConnectionAvailable();
+ StorageNode storageNode = new
StorageNode(getStorageNodeName(storageUnitName, url,
standardProps.get("username").toString(), isInstanceConnectionAvailable));
+ return createStorageUnitNodeMapper(storageNode, storageUnitName, url,
isInstanceConnectionAvailable);
+ }
+
private static String getStorageNodeName(final String dataSourceName,
final String url, final String username, final boolean
isInstanceConnectionAvailable) {
try {
JdbcUrl jdbcUrl = new StandardJdbcUrlParser().parse(url);
@@ -78,35 +96,12 @@ public final class StorageResourceCreator {
return String.format("%s_%s_%s", hostname, port, username);
}
- private static StorageUnitNodeMapper getStorageUnitNodeMapper(final
StorageNode storageNode, final String storageUnitName, final String url, final
boolean isInstanceConnectionAvailable) {
+ private static StorageUnitNodeMapper createStorageUnitNodeMapper(final
StorageNode storageNode, final String storageUnitName, final String url, final
boolean isInstanceConnectionAvailable) {
return isInstanceConnectionAvailable
? new StorageUnitNodeMapper(storageUnitName, storageNode, new
StandardJdbcUrlParser().parse(url).getDatabase(), url)
: new StorageUnitNodeMapper(storageUnitName, storageNode, url);
}
- /**
- * Create storage resource without data source.
- *
- * @param propsMap data source pool properties map
- * @return created storage resource
- */
- public static StorageResource createStorageResourceWithoutDataSource(final
Map<String, DataSourcePoolProperties> propsMap) {
- Map<StorageNode, DataSource> storageNodes = new LinkedHashMap<>();
- Map<String, StorageUnitNodeMapper> mappers = new LinkedHashMap<>();
- for (Entry<String, DataSourcePoolProperties> entry :
propsMap.entrySet()) {
- String storageUnitName = entry.getKey();
- Map<String, Object> standardProps =
entry.getValue().getConnectionPropertySynonyms().getStandardProperties();
- String url = standardProps.get("url").toString();
- boolean isInstanceConnectionAvailable = new
DatabaseTypeRegistry(DatabaseTypeFactory.get(url)).getDialectDatabaseMetaData().isInstanceConnectionAvailable();
- StorageNode storageNode = new
StorageNode(getStorageNodeName(storageUnitName, url,
standardProps.get("username").toString(), isInstanceConnectionAvailable));
- if (!storageNodes.containsKey(storageNode)) {
- storageNodes.put(storageNode, null);
- }
- mappers.put(storageUnitName, getStorageUnitNodeMapper(storageNode,
storageUnitName, url, isInstanceConnectionAvailable));
- }
- return new StorageResource(storageNodes, mappers);
- }
-
/**
* Get storage node grouped data source pool properties map.
*
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 6bf91cfe337..02e22e03c09 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
@@ -276,11 +276,10 @@ public final class ConfigurationContextManager {
public Map<String, ShardingSphereDatabase> renewDatabase(final
ShardingSphereDatabase database, final SwitchingResource resource) {
Map<StorageNode, DataSource> newStorageNodes =
getNewStorageNodes(database.getResourceMetaData().getDataSourceMap(), resource);
Map<String, StorageUnitNodeMapper> newStorageUnitNodeMappers =
getNewStorageUnitNodeMappers(database.getResourceMetaData().getStorageUnitMetaData().getStorageUnits(),
resource);
- StorageResource newStorageResource = new
StorageResource(newStorageNodes, newStorageUnitNodeMappers);
Map<String, DataSourcePoolProperties> propsMap =
database.getResourceMetaData().getStorageUnitMetaData().getStorageUnits().entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, entry ->
entry.getValue().getDataSourcePoolProperties(), (oldValue, currentValue) ->
currentValue, LinkedHashMap::new));
- return Collections.singletonMap(database.getName().toLowerCase(), new
ShardingSphereDatabase(
- database.getName(), database.getProtocolType(), new
ResourceMetaData(database.getName(), newStorageResource, propsMap),
database.getRuleMetaData(), database.getSchemas()));
+ return Collections.singletonMap(database.getName().toLowerCase(), new
ShardingSphereDatabase(database.getName(), database.getProtocolType(),
+ new ResourceMetaData(database.getName(), newStorageNodes,
newStorageUnitNodeMappers, propsMap), database.getRuleMetaData(),
database.getSchemas()));
}
private Map<StorageNode, DataSource> getNewStorageNodes(final
Map<StorageNode, DataSource> currentStorageNodes, final SwitchingResource
resource) {
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 709c63526a1..5caa61cfe56 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
@@ -26,11 +26,13 @@ import
org.apache.shardingsphere.infra.metadata.database.resource.node.StorageNo
import
org.apache.shardingsphere.infra.metadata.database.resource.unit.StorageUnitNodeMapper;
import javax.sql.DataSource;
+import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.stream.Collectors;
/**
* TODO Rename ResourceSwitchManager when metadata structure adjustment
completed. #25485
@@ -48,21 +50,22 @@ public final class NewResourceSwitchManager {
public SwitchingResource registerStorageUnit(final ResourceMetaData
resourceMetaData, final Map<String, DataSourcePoolProperties>
storageUnitDataSourcePoolProps) {
Map<String, DataSourcePoolProperties> mergedPropsMap = new
HashMap<>(resourceMetaData.getStorageUnitMetaData().getDataSourcePoolPropertiesMap());
mergedPropsMap.putAll(storageUnitDataSourcePoolProps);
- StorageResource toBeCreatedStorageResource =
StorageResourceCreator.createStorageResourceWithoutDataSource(storageUnitDataSourcePoolProps);
- return new SwitchingResource(resourceMetaData,
getRegisterNewStorageResource(resourceMetaData, toBeCreatedStorageResource,
storageUnitDataSourcePoolProps),
+ Map<String, StorageUnitNodeMapper> toBeCreatedMappers =
StorageResourceCreator.getStorageUnitNodeMappers(storageUnitDataSourcePoolProps);
+ return new SwitchingResource(resourceMetaData,
getRegisterNewStorageResource(resourceMetaData, toBeCreatedMappers,
storageUnitDataSourcePoolProps),
new StorageResource(Collections.emptyMap(),
Collections.emptyMap()), mergedPropsMap);
}
private StorageResource getRegisterNewStorageResource(final
ResourceMetaData resourceMetaData,
- final
StorageResource toBeCreatedStorageResource, final Map<String,
DataSourcePoolProperties> storageUnitDataSourcePoolProps) {
+ final Map<String,
StorageUnitNodeMapper> mappers, final Map<String, DataSourcePoolProperties>
storageUnitDataSourcePoolProps) {
+ Collection<StorageNode> storageNodes =
mappers.values().stream().map(StorageUnitNodeMapper::getStorageNode).collect(Collectors.toSet());
Map<StorageNode, DataSourcePoolProperties>
storageNodeDataSourcePoolProps =
StorageResourceCreator.getStorageNodeDataSourcePoolProperties(storageUnitDataSourcePoolProps);
- Map<StorageNode, DataSource> storageNodes = new
LinkedHashMap<>(toBeCreatedStorageResource.getDataSourceMap().size(), 1F);
- for (StorageNode each :
toBeCreatedStorageResource.getDataSourceMap().keySet()) {
+ Map<StorageNode, DataSource> newStorageNodes = new
LinkedHashMap<>(storageNodes.size(), 1F);
+ for (StorageNode each : storageNodes) {
if (!resourceMetaData.getDataSourceMap().containsKey(each)) {
- storageNodes.put(each,
DataSourcePoolCreator.create(storageNodeDataSourcePoolProps.get(each)));
+ newStorageNodes.put(each,
DataSourcePoolCreator.create(storageNodeDataSourcePoolProps.get(each)));
}
}
- return new StorageResource(storageNodes,
toBeCreatedStorageResource.getStorageUnitNodeMappers());
+ return new StorageResource(newStorageNodes, mappers);
}
/**
@@ -75,28 +78,30 @@ public final class NewResourceSwitchManager {
public SwitchingResource alterStorageUnit(final ResourceMetaData
resourceMetaData, final Map<String, DataSourcePoolProperties> propsMap) {
Map<String, DataSourcePoolProperties>
mergedDataSourcePoolPropertiesMap = new
HashMap<>(resourceMetaData.getStorageUnitMetaData().getDataSourcePoolPropertiesMap());
mergedDataSourcePoolPropertiesMap.putAll(propsMap);
- StorageResource toBeAlteredStorageResource =
StorageResourceCreator.createStorageResourceWithoutDataSource(mergedDataSourcePoolPropertiesMap);
- return new SwitchingResource(resourceMetaData,
getAlterNewStorageResource(toBeAlteredStorageResource,
mergedDataSourcePoolPropertiesMap),
- getStaleStorageResource(resourceMetaData,
toBeAlteredStorageResource), mergedDataSourcePoolPropertiesMap);
+ Map<String, StorageUnitNodeMapper> toBeAlteredMappers =
StorageResourceCreator.getStorageUnitNodeMappers(mergedDataSourcePoolPropertiesMap);
+ return new SwitchingResource(resourceMetaData,
getAlterNewStorageResource(toBeAlteredMappers,
mergedDataSourcePoolPropertiesMap),
+ getStaleStorageResource(resourceMetaData, toBeAlteredMappers),
mergedDataSourcePoolPropertiesMap);
}
- private StorageResource getAlterNewStorageResource(final StorageResource
toBeAlteredStorageResource, final Map<String, DataSourcePoolProperties>
storageUnitDataSourcePoolProps) {
+ private StorageResource getAlterNewStorageResource(final Map<String,
StorageUnitNodeMapper> mappers, final Map<String, DataSourcePoolProperties>
storageUnitDataSourcePoolProps) {
+ Collection<StorageNode> toBeAlteredStorageNodes =
mappers.values().stream().map(StorageUnitNodeMapper::getStorageNode).collect(Collectors.toSet());
Map<StorageNode, DataSourcePoolProperties>
storageNodeDataSourcePoolProps =
StorageResourceCreator.getStorageNodeDataSourcePoolProperties(storageUnitDataSourcePoolProps);
- Map<StorageNode, DataSource> storageNodes = new
LinkedHashMap<>(toBeAlteredStorageResource.getDataSourceMap().size(), 1F);
- for (StorageNode each :
toBeAlteredStorageResource.getDataSourceMap().keySet()) {
+ Map<StorageNode, DataSource> storageNodes = new
LinkedHashMap<>(toBeAlteredStorageNodes.size(), 1F);
+ for (StorageNode each : toBeAlteredStorageNodes) {
storageNodes.put(each,
DataSourcePoolCreator.create(storageNodeDataSourcePoolProps.get(each)));
}
- return new StorageResource(storageNodes,
toBeAlteredStorageResource.getStorageUnitNodeMappers());
+ return new StorageResource(storageNodes, mappers);
}
- private StorageResource getStaleStorageResource(final ResourceMetaData
resourceMetaData, final StorageResource toBeAlteredStorageResource) {
- Map<StorageNode, DataSource> storageNodes = new
LinkedHashMap<>(toBeAlteredStorageResource.getDataSourceMap().size(), 1F);
+ private StorageResource getStaleStorageResource(final ResourceMetaData
resourceMetaData, final Map<String, StorageUnitNodeMapper> mappers) {
+ Collection<StorageNode> toBeAlteredStorageNodes =
mappers.values().stream().map(StorageUnitNodeMapper::getStorageNode).collect(Collectors.toSet());
+ Map<StorageNode, DataSource> storageNodes = new
LinkedHashMap<>(toBeAlteredStorageNodes.size(), 1F);
for (Entry<StorageNode, DataSource> entry :
resourceMetaData.getDataSourceMap().entrySet()) {
- if
(toBeAlteredStorageResource.getDataSourceMap().containsKey(entry.getKey())) {
+ if (toBeAlteredStorageNodes.contains(entry.getKey())) {
storageNodes.put(entry.getKey(), entry.getValue());
}
}
- return new StorageResource(storageNodes,
toBeAlteredStorageResource.getStorageUnitNodeMappers());
+ return new StorageResource(storageNodes, mappers);
}
/**
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 14bd8691222..47abbbf6884 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
@@ -51,9 +51,9 @@ public final class ResourceSwitchManager {
public SwitchingResource create(final ResourceMetaData resourceMetaData,
final Map<String, DataSourcePoolProperties> toBeChangedPropsMap) {
Map<String, DataSourcePoolProperties> mergedPropsMap = new
HashMap<>(resourceMetaData.getStorageUnitMetaData().getDataSourcePoolPropertiesMap());
mergedPropsMap.putAll(toBeChangedPropsMap);
- StorageResource toBeChangedStorageResource =
StorageResourceCreator.createStorageResourceWithoutDataSource(toBeChangedPropsMap);
- return new SwitchingResource(resourceMetaData,
createNewStorageResource(resourceMetaData, toBeChangedStorageResource,
toBeChangedPropsMap),
- getStaleDataSources(resourceMetaData,
toBeChangedStorageResource, mergedPropsMap), mergedPropsMap);
+ Map<String, StorageUnitNodeMapper> toBeChangedMappers =
StorageResourceCreator.getStorageUnitNodeMappers(toBeChangedPropsMap);
+ return new SwitchingResource(resourceMetaData,
createNewStorageResource(resourceMetaData, toBeChangedMappers,
toBeChangedPropsMap),
+ getStaleDataSources(resourceMetaData, toBeChangedMappers,
mergedPropsMap), mergedPropsMap);
}
/**
@@ -66,9 +66,9 @@ public final class ResourceSwitchManager {
public SwitchingResource createByDropResource(final ResourceMetaData
resourceMetaData, final Map<String, DataSourcePoolProperties>
toBeDeletedPropsMap) {
Map<String, DataSourcePoolProperties>
mergedDataSourcePoolPropertiesMap = new
HashMap<>(resourceMetaData.getStorageUnitMetaData().getDataSourcePoolPropertiesMap());
mergedDataSourcePoolPropertiesMap.keySet().removeIf(toBeDeletedPropsMap::containsKey);
- StorageResource toToBeRemovedStorageResource =
StorageResourceCreator.createStorageResourceWithoutDataSource(toBeDeletedPropsMap);
+ Map<String, StorageUnitNodeMapper> toRemovedMappers =
StorageResourceCreator.getStorageUnitNodeMappers(toBeDeletedPropsMap);
return new SwitchingResource(resourceMetaData, new
StorageResource(Collections.emptyMap(), Collections.emptyMap()),
- getToBeRemovedStaleDataSources(resourceMetaData,
toToBeRemovedStorageResource), mergedDataSourcePoolPropertiesMap);
+ getToBeRemovedStaleDataSources(resourceMetaData,
toRemovedMappers), mergedDataSourcePoolPropertiesMap);
}
/**
@@ -82,31 +82,32 @@ public final class ResourceSwitchManager {
Map<String, DataSourcePoolProperties>
mergedDataSourcePoolPropertiesMap = new
HashMap<>(resourceMetaData.getStorageUnitMetaData().getDataSourcePoolPropertiesMap());
mergedDataSourcePoolPropertiesMap.keySet().removeIf(each ->
!toBeChangedPropsMap.containsKey(each));
mergedDataSourcePoolPropertiesMap.putAll(toBeChangedPropsMap);
- StorageResource toBeChangedStorageResource =
StorageResourceCreator.createStorageResourceWithoutDataSource(toBeChangedPropsMap);
- StorageResource staleStorageResource =
getStaleDataSources(resourceMetaData, toBeChangedStorageResource,
toBeChangedPropsMap);
- staleStorageResource.getDataSourceMap()
-
.putAll(getToBeDeletedDataSources(resourceMetaData.getDataSourceMap(),
toBeChangedStorageResource.getDataSourceMap().keySet()));
+ Map<String, StorageUnitNodeMapper> toBeChangedMappers =
StorageResourceCreator.getStorageUnitNodeMappers(toBeChangedPropsMap);
+ StorageResource staleStorageResource =
getStaleDataSources(resourceMetaData, toBeChangedMappers, toBeChangedPropsMap);
+ Collection<StorageNode> toBeChangedStorageNodes =
toBeChangedMappers.values().stream().map(StorageUnitNodeMapper::getStorageNode).collect(Collectors.toSet());
+
staleStorageResource.getDataSourceMap().putAll(getToBeDeletedDataSources(resourceMetaData.getDataSourceMap(),
toBeChangedStorageNodes));
staleStorageResource.getStorageUnitNodeMappers().putAll(
-
getToBeDeletedStorageUnitNodeMappers(resourceMetaData.getStorageUnitMetaData().getStorageUnits(),
toBeChangedStorageResource.getStorageUnitNodeMappers().keySet()));
+
getToBeDeletedStorageUnitNodeMappers(resourceMetaData.getStorageUnitMetaData().getStorageUnits(),
toBeChangedMappers.keySet()));
return new SwitchingResource(resourceMetaData,
- createNewStorageResource(resourceMetaData,
toBeChangedStorageResource, toBeChangedPropsMap), staleStorageResource,
mergedDataSourcePoolPropertiesMap);
+ createNewStorageResource(resourceMetaData, toBeChangedMappers,
toBeChangedPropsMap), staleStorageResource, mergedDataSourcePoolPropertiesMap);
}
private StorageResource createNewStorageResource(final ResourceMetaData
resourceMetaData,
- final StorageResource
toBeChangedStorageResource, final Map<String, DataSourcePoolProperties>
storageUnitDataSourcePoolProps) {
+ final Map<String,
StorageUnitNodeMapper> toBeChangedMappers, final Map<String,
DataSourcePoolProperties> storageUnitDataSourcePoolProps) {
+ Collection<StorageNode> toBeChangedStorageNode =
toBeChangedMappers.values().stream().map(StorageUnitNodeMapper::getStorageNode).collect(Collectors.toSet());
Map<StorageNode, DataSourcePoolProperties>
storageNodeDataSourcePoolProps =
StorageResourceCreator.getStorageNodeDataSourcePoolProperties(storageUnitDataSourcePoolProps);
Map<StorageNode, DataSource> storageNodes =
- getNewStorageNodes(resourceMetaData,
toBeChangedStorageResource.getDataSourceMap(), storageNodeDataSourcePoolProps);
- Map<String, StorageUnitNodeMapper> storageUnitNodeMappers =
getNewStorageUnitNodeMappers(resourceMetaData,
toBeChangedStorageResource.getStorageUnitNodeMappers());
+ getNewStorageNodes(resourceMetaData, toBeChangedStorageNode,
storageNodeDataSourcePoolProps);
+ Map<String, StorageUnitNodeMapper> storageUnitNodeMappers =
getNewStorageUnitNodeMappers(resourceMetaData, toBeChangedMappers);
return new StorageResource(storageNodes, storageUnitNodeMappers);
}
- private Map<StorageNode, DataSource> getNewStorageNodes(final
ResourceMetaData resourceMetaData, final Map<StorageNode, DataSource>
toBeChangedStorageNodes,
+ private Map<StorageNode, DataSource> getNewStorageNodes(final
ResourceMetaData resourceMetaData, final Collection<StorageNode>
toBeChangedStorageNode,
final
Map<StorageNode, DataSourcePoolProperties> propsMap) {
Map<StorageNode, DataSource> result = new
LinkedHashMap<>(resourceMetaData.getDataSourceMap());
-
result.keySet().removeAll(getToBeDeletedDataSources(resourceMetaData.getDataSourceMap(),
toBeChangedStorageNodes.keySet()).keySet());
-
result.putAll(getChangedDataSources(resourceMetaData.getDataSourceMap(),
toBeChangedStorageNodes, propsMap));
-
result.putAll(getToBeAddedDataSources(resourceMetaData.getDataSourceMap(),
toBeChangedStorageNodes, propsMap));
+
result.keySet().removeAll(getToBeDeletedDataSources(resourceMetaData.getDataSourceMap(),
toBeChangedStorageNode).keySet());
+
result.putAll(getChangedDataSources(resourceMetaData.getDataSourceMap(),
toBeChangedStorageNode, propsMap));
+
result.putAll(getToBeAddedDataSources(resourceMetaData.getDataSourceMap(),
toBeChangedStorageNode, propsMap));
return result;
}
@@ -119,10 +120,10 @@ public final class ResourceSwitchManager {
}
private Map<StorageNode, DataSource> getChangedDataSources(final
Map<StorageNode, DataSource> storageNodes,
- final
Map<StorageNode, DataSource> toBeChangedStorageNodes, final Map<StorageNode,
DataSourcePoolProperties> propsMap) {
- Collection<StorageNode> toBeChangedDataSourceNames =
toBeChangedStorageNodes.keySet().stream()
+ final
Collection<StorageNode> toBeChangedStorageNode, final Map<StorageNode,
DataSourcePoolProperties> propsMap) {
+ Collection<StorageNode> toBeChangedDataSourceNames =
toBeChangedStorageNode.stream()
.filter(each -> isModifiedDataSource(storageNodes, each,
propsMap.get(each))).collect(Collectors.toList());
- Map<StorageNode, DataSource> result = new
LinkedHashMap<>(toBeChangedStorageNodes.size(), 1F);
+ Map<StorageNode, DataSource> result = new
LinkedHashMap<>(toBeChangedStorageNode.size(), 1F);
for (StorageNode each : toBeChangedDataSourceNames) {
result.put(each, DataSourcePoolCreator.create(propsMap.get(each)));
}
@@ -133,9 +134,9 @@ public final class ResourceSwitchManager {
return originalDataSources.containsKey(storageNode) &&
!propsMap.equals(DataSourcePoolPropertiesCreator.create(originalDataSources.get(storageNode)));
}
- private Map<StorageNode, DataSource> getToBeAddedDataSources(final
Map<StorageNode, DataSource> storageNodes, final Map<StorageNode, DataSource>
toBeChangedStorageNodes,
+ private Map<StorageNode, DataSource> getToBeAddedDataSources(final
Map<StorageNode, DataSource> storageNodes, final Collection<StorageNode>
toBeChangedStorageNode,
final
Map<StorageNode, DataSourcePoolProperties> propsMap) {
- Collection<StorageNode> toBeAddedDataSourceNames =
toBeChangedStorageNodes.keySet().stream().filter(each ->
!storageNodes.containsKey(each)).collect(Collectors.toList());
+ Collection<StorageNode> toBeAddedDataSourceNames =
toBeChangedStorageNode.stream().filter(each ->
!storageNodes.containsKey(each)).collect(Collectors.toList());
Map<StorageNode, DataSource> result = new LinkedHashMap<>();
for (StorageNode each : toBeAddedDataSourceNames) {
result.put(each, DataSourcePoolCreator.create(propsMap.get(each)));
@@ -143,25 +144,26 @@ public final class ResourceSwitchManager {
return result;
}
- private StorageResource getToBeRemovedStaleDataSources(final
ResourceMetaData resourceMetaData, final StorageResource
toBeRemovedStorageResource) {
+ private StorageResource getToBeRemovedStaleDataSources(final
ResourceMetaData resourceMetaData, final Map<String, StorageUnitNodeMapper>
toRemovedMappers) {
Map<String, StorageUnitNodeMapper> reservedStorageUnitNodeMappers =
resourceMetaData.getStorageUnitMetaData().getStorageUnits().entrySet().stream()
- .filter(entry ->
!toBeRemovedStorageResource.getStorageUnitNodeMappers().containsKey(entry.getKey()))
+ .filter(entry -> !toRemovedMappers.containsKey(entry.getKey()))
.collect(Collectors.toMap(Entry::getKey, entry ->
entry.getValue().getUnitNodeMapper()));
+ Collection<StorageNode> toBeRemovedStorageNodes =
toRemovedMappers.values().stream().map(StorageUnitNodeMapper::getStorageNode).collect(Collectors.toSet());
Collection<StorageNode> inUsedDataSourceNames =
reservedStorageUnitNodeMappers.values().stream().map(StorageUnitNodeMapper::getStorageNode).collect(Collectors.toSet());
Map<StorageNode, DataSource> staleStorageNodes =
resourceMetaData.getDataSourceMap().entrySet().stream()
- .filter(entry ->
toBeRemovedStorageResource.getDataSourceMap().containsKey(entry.getKey()) &&
!inUsedDataSourceNames.contains(entry.getKey()))
+ .filter(entry ->
toBeRemovedStorageNodes.contains(entry.getKey()) &&
!inUsedDataSourceNames.contains(entry.getKey()))
.collect(Collectors.toMap(Entry::getKey, Entry::getValue));
Map<String, StorageUnitNodeMapper> staleStorageUnitNodeMappers =
resourceMetaData.getStorageUnitMetaData().getStorageUnits().entrySet().stream()
.filter(entry ->
!reservedStorageUnitNodeMappers.containsKey(entry.getKey())).collect(Collectors.toMap(Entry::getKey,
entry -> entry.getValue().getUnitNodeMapper()));
return new StorageResource(staleStorageNodes,
staleStorageUnitNodeMappers);
}
- private StorageResource getStaleDataSources(final ResourceMetaData
resourceMetaData, final StorageResource toBeChangedStorageResource,
+ private StorageResource getStaleDataSources(final ResourceMetaData
resourceMetaData, final Map<String, StorageUnitNodeMapper> toBeChangedMappers,
final Map<String,
DataSourcePoolProperties> storageUnitDataSourcePoolProps) {
Map<StorageNode, DataSource> storageNodes = new
LinkedHashMap<>(resourceMetaData.getDataSourceMap().size(), 1F);
Map<String, StorageUnitNodeMapper> storageUnitNodeMappers = new
LinkedHashMap<>(resourceMetaData.getStorageUnitMetaData().getUnitNodeMappers().size(),
1F);
storageNodes.putAll(getToBeChangedDataSources(resourceMetaData.getDataSourceMap(),
StorageResourceCreator.getStorageNodeDataSourcePoolProperties(storageUnitDataSourcePoolProps)));
-
storageUnitNodeMappers.putAll(getChangedStorageUnitNodeMappers(resourceMetaData.getStorageUnitMetaData().getStorageUnits(),
toBeChangedStorageResource.getStorageUnitNodeMappers()));
+
storageUnitNodeMappers.putAll(getChangedStorageUnitNodeMappers(resourceMetaData.getStorageUnitMetaData().getStorageUnits(),
toBeChangedMappers));
return new StorageResource(storageNodes, storageUnitNodeMappers);
}
