This is an automated email from the ASF dual-hosted git repository.
duanzhengqiang 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 3d3967bea8d Move rebuild MetaDataContext by switch resource to
MetaDataContextsFactory (#32080)
3d3967bea8d is described below
commit 3d3967bea8dd43e2a45bbb8f49547c40e24ed24b
Author: Haoran Meng <[email protected]>
AuthorDate: Fri Jul 12 18:11:45 2024 +0800
Move rebuild MetaDataContext by switch resource to MetaDataContextsFactory
(#32080)
* Move rebuild MetaDataContext by switch resource to MetaDataContextsFactory
* fix checkstyle
---
.../mode/manager/ContextManager.java | 7 +-
.../mode/metadata/MetaDataContextManager.java | 7 +-
.../mode/metadata/MetaDataContextsFactory.java | 108 +++++++++++++
.../metadata/manager/ConfigurationManager.java | 173 ---------------------
.../metadata/manager/ResourceSwitchManager.java | 24 +--
.../mode/metadata/manager/StorageUnitManager.java | 6 +-
.../StandaloneMetaDataManagerPersistService.java | 30 ++--
7 files changed, 145 insertions(+), 210 deletions(-)
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
index 4a0349f7c69..1231a898d22 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/manager/ContextManager.java
@@ -45,7 +45,6 @@ import
org.apache.shardingsphere.mode.manager.listener.ContextManagerLifecycleLi
import org.apache.shardingsphere.mode.metadata.MetaDataContextManager;
import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
import org.apache.shardingsphere.mode.metadata.MetaDataContextsFactory;
-import org.apache.shardingsphere.mode.metadata.manager.ConfigurationManager;
import org.apache.shardingsphere.mode.metadata.manager.SwitchingResource;
import org.apache.shardingsphere.mode.persist.PersistServiceFacade;
import org.apache.shardingsphere.mode.spi.PersistRepository;
@@ -173,11 +172,11 @@ public final class ContextManager implements
AutoCloseable {
private MetaDataContexts createMetaDataContexts(final
ShardingSphereDatabase database) throws SQLException {
MetaDataPersistService metaDataPersistService =
persistServiceFacade.getMetaDataPersistService();
- ConfigurationManager configurationManager =
metaDataContextManager.getConfigurationManager();
Map<String, DataSourcePoolProperties> dataSourcePoolPropsFromRegCenter
= metaDataPersistService.getDataSourceUnitService().load(database.getName());
- SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager().alterStorageUnit(database.getResourceMetaData(),
dataSourcePoolPropsFromRegCenter);
+ SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager().switchByAlterStorageUnit(database.getResourceMetaData(),
dataSourcePoolPropsFromRegCenter);
Collection<RuleConfiguration> ruleConfigs =
metaDataPersistService.getDatabaseRulePersistService().load(database.getName());
- Map<String, ShardingSphereDatabase> changedDatabases =
configurationManager.createChangedDatabases(database.getName(), false,
switchingResource, ruleConfigs);
+ Map<String, ShardingSphereDatabase> changedDatabases =
MetaDataContextsFactory
+ .createChangedDatabases(database.getName(), false,
switchingResource, ruleConfigs, metaDataContexts.get(), metaDataPersistService,
computeNodeInstanceContext);
ConfigurationProperties props = new
ConfigurationProperties(metaDataPersistService.getPropsService().load());
Collection<RuleConfiguration> globalRuleConfigs =
metaDataPersistService.getGlobalRuleService().load();
RuleMetaData changedGlobalMetaData = new
RuleMetaData(GlobalRulesBuilder.buildRules(globalRuleConfigs, changedDatabases,
props));
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextManager.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextManager.java
index cb79560374c..4eb0b16957b 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextManager.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextManager.java
@@ -22,7 +22,6 @@ import
org.apache.shardingsphere.infra.instance.ComputeNodeInstanceContext;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import
org.apache.shardingsphere.infra.metadata.database.schema.manager.GenericSchemaManager;
import org.apache.shardingsphere.metadata.persist.MetaDataPersistService;
-import org.apache.shardingsphere.mode.metadata.manager.ConfigurationManager;
import
org.apache.shardingsphere.mode.metadata.manager.DatabaseRuleConfigurationManager;
import
org.apache.shardingsphere.mode.metadata.manager.GlobalConfigurationManager;
import org.apache.shardingsphere.mode.metadata.manager.ResourceSwitchManager;
@@ -42,9 +41,9 @@ public class MetaDataContextManager {
private final AtomicReference<MetaDataContexts> metaDataContexts;
- private final ShardingSphereDatabaseDataManager databaseManager;
+ private final ComputeNodeInstanceContext computeNodeInstanceContext;
- private final ConfigurationManager configurationManager;
+ private final ShardingSphereDatabaseDataManager databaseManager;
private final SchemaMetaDataManager schemaMetaDataManager;
@@ -63,11 +62,11 @@ public class MetaDataContextManager {
public MetaDataContextManager(final AtomicReference<MetaDataContexts>
metaDataContexts, final ComputeNodeInstanceContext computeNodeInstanceContext,
final PersistRepository repository) {
this.metaDataContexts = metaDataContexts;
+ this.computeNodeInstanceContext = computeNodeInstanceContext;
resourceSwitchManager = new ResourceSwitchManager();
databaseManager = new
ShardingSphereDatabaseDataManager(metaDataContexts);
storageUnitManager = new StorageUnitManager(metaDataContexts,
computeNodeInstanceContext, repository, resourceSwitchManager);
databaseRuleConfigurationManager = new
DatabaseRuleConfigurationManager(metaDataContexts, computeNodeInstanceContext,
repository);
- configurationManager = new ConfigurationManager(metaDataContexts,
computeNodeInstanceContext, repository);
schemaMetaDataManager = new SchemaMetaDataManager(metaDataContexts,
repository);
ruleItemManager = new RuleItemManager(metaDataContexts, repository,
databaseRuleConfigurationManager);
globalConfigurationManager = new
GlobalConfigurationManager(metaDataContexts, repository);
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextsFactory.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextsFactory.java
index 564fd412dca..c90bd7f6bb5 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextsFactory.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/MetaDataContextsFactory.java
@@ -21,6 +21,7 @@ import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.apache.shardingsphere.infra.config.database.DatabaseConfiguration;
import
org.apache.shardingsphere.infra.config.database.impl.DataSourceGeneratedDatabaseConfiguration;
+import
org.apache.shardingsphere.infra.config.database.impl.DataSourceProvidedDatabaseConfiguration;
import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import
org.apache.shardingsphere.infra.database.core.metadata.database.DialectDatabaseMetaData;
@@ -29,11 +30,14 @@ import
org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.database.core.type.DatabaseTypeRegistry;
import
org.apache.shardingsphere.infra.datasource.pool.config.DataSourceConfiguration;
import
org.apache.shardingsphere.infra.datasource.pool.destroyer.DataSourcePoolDestroyer;
+import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
import org.apache.shardingsphere.infra.instance.ComputeNodeInstanceContext;
import
org.apache.shardingsphere.infra.instance.metadata.jdbc.JDBCInstanceMetaData;
import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import
org.apache.shardingsphere.infra.metadata.database.resource.ResourceMetaData;
+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.rule.RuleMetaData;
import
org.apache.shardingsphere.infra.metadata.statistics.ShardingSphereDatabaseData;
import
org.apache.shardingsphere.infra.metadata.statistics.ShardingSphereSchemaData;
@@ -46,6 +50,7 @@ import
org.apache.shardingsphere.metadata.factory.ExternalMetaDataFactory;
import org.apache.shardingsphere.metadata.factory.InternalMetaDataFactory;
import org.apache.shardingsphere.metadata.persist.MetaDataPersistService;
import org.apache.shardingsphere.mode.manager.ContextManagerBuilderParameter;
+import org.apache.shardingsphere.mode.metadata.manager.SwitchingResource;
import javax.sql.DataSource;
import java.sql.SQLException;
@@ -191,4 +196,107 @@ public final class MetaDataContextsFactory {
metaDataContexts.getStatistics().getDatabaseData().forEach((databaseName,
databaseData) -> databaseData.getSchemaData().forEach((schemaName, schemaData)
-> persistService
.getShardingSphereDataPersistService().persist(databaseName,
schemaName, schemaData, metaDataContexts.getMetaData().getDatabases())));
}
+
+ /**
+ * Create meta data contexts by switch resource.
+ *
+ * @param databaseName database name
+ * @param internalLoadMetaData internal load meta data
+ * @param switchingResource switching resource
+ * @param orginalMetaDataContexts original meta data contexts
+ * @param metaDataPersistService meta data persist service
+ * @param computeNodeInstanceContext compute node instance context
+ * @return meta data contexts
+ * @throws SQLException SQL exception
+ */
+ public static MetaDataContexts createBySwitchResource(final String
databaseName, final boolean internalLoadMetaData, final SwitchingResource
switchingResource,
+ final
MetaDataContexts orginalMetaDataContexts, final MetaDataPersistService
metaDataPersistService,
+ final
ComputeNodeInstanceContext computeNodeInstanceContext) throws SQLException {
+ Map<String, ShardingSphereDatabase> changedDatabases =
+ createChangedDatabases(databaseName, internalLoadMetaData,
switchingResource, null, orginalMetaDataContexts, metaDataPersistService,
computeNodeInstanceContext);
+ ConfigurationProperties props =
orginalMetaDataContexts.getMetaData().getProps();
+ RuleMetaData changedGlobalMetaData = new RuleMetaData(
+
GlobalRulesBuilder.buildRules(orginalMetaDataContexts.getMetaData().getGlobalRuleMetaData().getConfigurations(),
changedDatabases, props));
+ return create(metaDataPersistService, new
ShardingSphereMetaData(changedDatabases,
orginalMetaDataContexts.getMetaData().getGlobalResourceMetaData(),
changedGlobalMetaData, props));
+ }
+
+ /**
+ * Create changed databases by switch resource.
+ *
+ * @param databaseName database name
+ * @param internalLoadMetaData internal load meta data
+ * @param switchingResource switching resource
+ * @param ruleConfigs rule configurations
+ * @param originalMetaDataContext original meta data contexts
+ * @param metaDataPersistService meta data persist service
+ * @param computeNodeInstanceContext compute node instance context
+ * @return changed databases
+ * @throws SQLException SQL exception
+ */
+ public static Map<String, ShardingSphereDatabase>
createChangedDatabases(final String databaseName, final boolean
internalLoadMetaData,
+
final SwitchingResource switchingResource, final Collection<RuleConfiguration>
ruleConfigs,
+
final MetaDataContexts originalMetaDataContext,
+
final MetaDataPersistService metaDataPersistService,
+
final ComputeNodeInstanceContext computeNodeInstanceContext) throws
SQLException {
+ ResourceMetaData effectiveResourceMetaData =
getEffectiveResourceMetaData(originalMetaDataContext.getMetaData().getDatabase(databaseName),
switchingResource);
+ Collection<RuleConfiguration> toBeCreatedRuleConfigs = null ==
ruleConfigs
+ ?
originalMetaDataContext.getMetaData().getDatabase(databaseName).getRuleMetaData().getConfigurations()
+ : ruleConfigs;
+ DatabaseConfiguration toBeCreatedDatabaseConfig =
getDatabaseConfiguration(effectiveResourceMetaData, switchingResource,
toBeCreatedRuleConfigs);
+ ShardingSphereDatabase changedDatabase =
createChangedDatabase(originalMetaDataContext.getMetaData().getDatabase(databaseName).getName(),
internalLoadMetaData,
+ metaDataPersistService, toBeCreatedDatabaseConfig,
originalMetaDataContext.getMetaData().getProps(), computeNodeInstanceContext);
+ Map<String, ShardingSphereDatabase> result = new
LinkedHashMap<>(originalMetaDataContext.getMetaData().getDatabases());
+ result.put(databaseName.toLowerCase(), changedDatabase);
+ return result;
+ }
+
+ private static ResourceMetaData getEffectiveResourceMetaData(final
ShardingSphereDatabase database, final SwitchingResource resource) {
+ Map<StorageNode, DataSource> storageNodes =
getStorageNodes(database.getResourceMetaData().getDataSources(), resource);
+ Map<String, StorageUnit> storageUnits =
getStorageUnits(database.getResourceMetaData().getStorageUnits(), resource);
+ return new ResourceMetaData(storageNodes, storageUnits);
+ }
+
+ private static Map<StorageNode, DataSource> getStorageNodes(final
Map<StorageNode, DataSource> currentStorageNodes, final SwitchingResource
resource) {
+ Map<StorageNode, DataSource> result = new
LinkedHashMap<>(currentStorageNodes.size(), 1F);
+ for (Entry<StorageNode, DataSource> entry :
currentStorageNodes.entrySet()) {
+ if (null == resource ||
!resource.getStaleDataSources().containsKey(entry.getKey())) {
+ result.put(entry.getKey(), entry.getValue());
+ }
+ }
+ return result;
+ }
+
+ private static Map<String, StorageUnit> getStorageUnits(final Map<String,
StorageUnit> currentStorageUnits, final SwitchingResource resource) {
+ Map<String, StorageUnit> result = new
LinkedHashMap<>(currentStorageUnits.size(), 1F);
+ for (Entry<String, StorageUnit> entry :
currentStorageUnits.entrySet()) {
+ if (null == resource ||
!resource.getStaleStorageUnitNames().contains(entry.getKey())) {
+ result.put(entry.getKey(), entry.getValue());
+ }
+ }
+ return result;
+ }
+
+ private static DatabaseConfiguration getDatabaseConfiguration(final
ResourceMetaData resourceMetaData, final SwitchingResource switchingResource,
+ final
Collection<RuleConfiguration> toBeCreatedRuleConfigs) {
+ Map<String, DataSourcePoolProperties> propsMap = null ==
switchingResource ? resourceMetaData.getStorageUnits().entrySet().stream()
+ .collect(Collectors.toMap(Entry::getKey, entry ->
entry.getValue().getDataSourcePoolProperties(), (oldValue, currentValue) ->
oldValue, LinkedHashMap::new))
+ : switchingResource.getMergedDataSourcePoolPropertiesMap();
+ return new
DataSourceProvidedDatabaseConfiguration(getMergedStorageNodeDataSources(resourceMetaData,
switchingResource), toBeCreatedRuleConfigs, propsMap);
+ }
+
+ private static Map<StorageNode, DataSource>
getMergedStorageNodeDataSources(final ResourceMetaData currentResourceMetaData,
final SwitchingResource switchingResource) {
+ Map<StorageNode, DataSource> result =
currentResourceMetaData.getDataSources();
+ if (null != switchingResource &&
!switchingResource.getNewDataSources().isEmpty()) {
+ result.putAll(switchingResource.getNewDataSources());
+ }
+ return result;
+ }
+
+ private static ShardingSphereDatabase createChangedDatabase(final String
databaseName, final boolean internalLoadMetaData, final MetaDataPersistService
persistService,
+ final
DatabaseConfiguration databaseConfig, final ConfigurationProperties props,
+ final
ComputeNodeInstanceContext computeNodeInstanceContext) throws SQLException {
+ return internalLoadMetaData
+ ? InternalMetaDataFactory.create(databaseName, persistService,
databaseConfig, props, computeNodeInstanceContext)
+ : ExternalMetaDataFactory.create(databaseName, databaseConfig,
props, computeNodeInstanceContext);
+ }
}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/ConfigurationManager.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/ConfigurationManager.java
deleted file mode 100644
index ba8226f46fa..00000000000
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/ConfigurationManager.java
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.shardingsphere.mode.metadata.manager;
-
-import lombok.extern.slf4j.Slf4j;
-import org.apache.shardingsphere.infra.config.database.DatabaseConfiguration;
-import
org.apache.shardingsphere.infra.config.database.impl.DataSourceProvidedDatabaseConfiguration;
-import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
-import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
-import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
-import org.apache.shardingsphere.infra.instance.ComputeNodeInstanceContext;
-import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
-import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
-import
org.apache.shardingsphere.infra.metadata.database.resource.ResourceMetaData;
-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.rule.RuleMetaData;
-import org.apache.shardingsphere.infra.rule.builder.global.GlobalRulesBuilder;
-import org.apache.shardingsphere.metadata.factory.ExternalMetaDataFactory;
-import org.apache.shardingsphere.metadata.factory.InternalMetaDataFactory;
-import org.apache.shardingsphere.metadata.persist.MetaDataPersistService;
-import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
-import org.apache.shardingsphere.mode.metadata.MetaDataContextsFactory;
-import org.apache.shardingsphere.mode.spi.PersistRepository;
-
-import javax.sql.DataSource;
-import java.sql.SQLException;
-import java.util.Collection;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.stream.Collectors;
-
-/**
- * Configuration context manager.
- */
-@Slf4j
-public final class ConfigurationManager {
-
- private final AtomicReference<MetaDataContexts> metaDataContexts;
-
- private final ComputeNodeInstanceContext computeNodeInstanceContext;
-
- private final MetaDataPersistService metaDataPersistService;
-
- public ConfigurationManager(final AtomicReference<MetaDataContexts>
metaDataContexts, final ComputeNodeInstanceContext computeNodeInstanceContext,
- final PersistRepository repository) {
- this.metaDataContexts = metaDataContexts;
- this.computeNodeInstanceContext = computeNodeInstanceContext;
- metaDataPersistService = new MetaDataPersistService(repository);
- }
-
- /**
- * Get effective resource meta data.
- *
- * @param database database
- * @param resource resource
- * @return effective resource meta data
- */
- public ResourceMetaData getEffectiveResourceMetaData(final
ShardingSphereDatabase database, final SwitchingResource resource) {
- Map<StorageNode, DataSource> storageNodes =
getStorageNodes(database.getResourceMetaData().getDataSources(), resource);
- Map<String, StorageUnit> storageUnits =
getStorageUnits(database.getResourceMetaData().getStorageUnits(), resource);
- return new ResourceMetaData(storageNodes, storageUnits);
- }
-
- private Map<StorageNode, DataSource> getStorageNodes(final
Map<StorageNode, DataSource> currentStorageNodes, final SwitchingResource
resource) {
- Map<StorageNode, DataSource> result = new
LinkedHashMap<>(currentStorageNodes.size(), 1F);
- for (Entry<StorageNode, DataSource> entry :
currentStorageNodes.entrySet()) {
- if (null == resource ||
!resource.getStaleDataSources().containsKey(entry.getKey())) {
- result.put(entry.getKey(), entry.getValue());
- }
- }
- return result;
- }
-
- private Map<String, StorageUnit> getStorageUnits(final Map<String,
StorageUnit> currentStorageUnits, final SwitchingResource resource) {
- Map<String, StorageUnit> result = new
LinkedHashMap<>(currentStorageUnits.size(), 1F);
- for (Entry<String, StorageUnit> entry :
currentStorageUnits.entrySet()) {
- if (null == resource ||
!resource.getStaleStorageUnitNames().contains(entry.getKey())) {
- result.put(entry.getKey(), entry.getValue());
- }
- }
- return result;
- }
-
- /**
- * Create meta data contexts.
- *
- * @param databaseName database name
- * @param internalLoadMetaData internal load meta data
- * @param switchingResource switching resource
- * @param ruleConfigs rule configs
- * @return MetaDataContexts meta data contexts
- * @throws SQLException SQL exception
- */
- public MetaDataContexts createMetaDataContexts(final String databaseName,
final boolean internalLoadMetaData,
- final SwitchingResource
switchingResource, final Collection<RuleConfiguration> ruleConfigs) throws
SQLException {
- Map<String, ShardingSphereDatabase> changedDatabases =
createChangedDatabases(databaseName, internalLoadMetaData, switchingResource,
ruleConfigs);
- ConfigurationProperties props =
metaDataContexts.get().getMetaData().getProps();
- RuleMetaData changedGlobalMetaData = new RuleMetaData(
-
GlobalRulesBuilder.buildRules(metaDataContexts.get().getMetaData().getGlobalRuleMetaData().getConfigurations(),
changedDatabases, props));
- return newMetaDataContexts(new
ShardingSphereMetaData(changedDatabases,
metaDataContexts.get().getMetaData().getGlobalResourceMetaData(),
changedGlobalMetaData, props));
- }
-
- /**
- * Create changed databases.
- *
- * @param databaseName database name
- * @param internalLoadMetaData internal load meta data
- * @param switchingResource switching resource
- * @param ruleConfigs rule configs
- * @return ShardingSphere databases
- * @throws SQLException SQL exception
- */
- public synchronized Map<String, ShardingSphereDatabase>
createChangedDatabases(final String databaseName, final boolean
internalLoadMetaData,
-
final SwitchingResource switchingResource, final
Collection<RuleConfiguration> ruleConfigs) throws SQLException {
- ResourceMetaData effectiveResourceMetaData =
getEffectiveResourceMetaData(metaDataContexts.get().getMetaData().getDatabase(databaseName),
switchingResource);
- Collection<RuleConfiguration> toBeCreatedRuleConfigs = null ==
ruleConfigs
- ?
metaDataContexts.get().getMetaData().getDatabase(databaseName).getRuleMetaData().getConfigurations()
- : ruleConfigs;
- DatabaseConfiguration toBeCreatedDatabaseConfig =
getDatabaseConfiguration(effectiveResourceMetaData, switchingResource,
toBeCreatedRuleConfigs);
- ShardingSphereDatabase changedDatabase =
createChangedDatabase(metaDataContexts.get().getMetaData().getDatabase(databaseName).getName(),
internalLoadMetaData,
- metaDataPersistService, toBeCreatedDatabaseConfig,
metaDataContexts.get().getMetaData().getProps(), computeNodeInstanceContext);
- Map<String, ShardingSphereDatabase> result = new
LinkedHashMap<>(metaDataContexts.get().getMetaData().getDatabases());
- result.put(databaseName.toLowerCase(), changedDatabase);
- return result;
- }
-
- private DatabaseConfiguration getDatabaseConfiguration(final
ResourceMetaData resourceMetaData, final SwitchingResource switchingResource,
- final
Collection<RuleConfiguration> toBeCreatedRuleConfigs) {
- Map<String, DataSourcePoolProperties> propsMap = null ==
switchingResource
- ? resourceMetaData.getStorageUnits().entrySet().stream()
- .collect(Collectors.toMap(Entry::getKey, entry ->
entry.getValue().getDataSourcePoolProperties(), (oldValue, currentValue) ->
oldValue, LinkedHashMap::new))
- : switchingResource.getMergedDataSourcePoolPropertiesMap();
- return new
DataSourceProvidedDatabaseConfiguration(getMergedStorageNodeDataSources(resourceMetaData,
switchingResource), toBeCreatedRuleConfigs, propsMap);
- }
-
- private Map<StorageNode, DataSource> getMergedStorageNodeDataSources(final
ResourceMetaData currentResourceMetaData, final SwitchingResource
switchingResource) {
- Map<StorageNode, DataSource> result =
currentResourceMetaData.getDataSources();
- if (null != switchingResource &&
!switchingResource.getNewDataSources().isEmpty()) {
- result.putAll(switchingResource.getNewDataSources());
- }
- return result;
- }
-
- private ShardingSphereDatabase createChangedDatabase(final String
databaseName, final boolean internalLoadMetaData, final MetaDataPersistService
persistService,
- final
DatabaseConfiguration databaseConfig, final ConfigurationProperties props,
- final
ComputeNodeInstanceContext computeNodeInstanceContext) throws SQLException {
- return internalLoadMetaData
- ? InternalMetaDataFactory.create(databaseName, persistService,
databaseConfig, props, computeNodeInstanceContext)
- : ExternalMetaDataFactory.create(databaseName, databaseConfig,
props, computeNodeInstanceContext);
- }
-
- private MetaDataContexts newMetaDataContexts(final ShardingSphereMetaData
metaData) {
- return MetaDataContextsFactory.create(metaDataPersistService,
metaData);
- }
-}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/ResourceSwitchManager.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/ResourceSwitchManager.java
index ad0cd0567e7..83e663dab17 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/ResourceSwitchManager.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/ResourceSwitchManager.java
@@ -41,18 +41,18 @@ import java.util.stream.Collectors;
public final class ResourceSwitchManager {
/**
- * Register storage unit.
+ * switch resource by register storage unit.
*
* @param resourceMetaData resource meta data
- * @param storageUnitDataSourcePoolPropsMap storage unit grouped data
source pool properties map
+ * @param toBeRegisteredProps to be registered storage unit grouped data
source pool properties map
* @return created switching resource
*/
- public SwitchingResource registerStorageUnit(final ResourceMetaData
resourceMetaData, final Map<String, DataSourcePoolProperties>
storageUnitDataSourcePoolPropsMap) {
+ public SwitchingResource switchByRegisterStorageUnit(final
ResourceMetaData resourceMetaData, final Map<String, DataSourcePoolProperties>
toBeRegisteredProps) {
Map<String, DataSourcePoolProperties> mergedPropsMap = new
LinkedHashMap<>(resourceMetaData.getStorageUnits().entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, entry ->
entry.getValue().getDataSourcePoolProperties(), (oldValue, currentValue) ->
oldValue, LinkedHashMap::new)));
- mergedPropsMap.putAll(storageUnitDataSourcePoolPropsMap);
- Map<String, StorageNode> toBeCreatedStorageUintNodeMap =
StorageUnitNodeMapCreator.create(storageUnitDataSourcePoolPropsMap);
- Map<StorageNode, DataSourcePoolProperties> dataSourcePoolPropsMap =
StorageNodeAggregator.aggregateDataSourcePoolProperties(storageUnitDataSourcePoolPropsMap);
+ mergedPropsMap.putAll(toBeRegisteredProps);
+ Map<String, StorageNode> toBeCreatedStorageUintNodeMap =
StorageUnitNodeMapCreator.create(toBeRegisteredProps);
+ Map<StorageNode, DataSourcePoolProperties> dataSourcePoolPropsMap =
StorageNodeAggregator.aggregateDataSourcePoolProperties(toBeRegisteredProps);
return new SwitchingResource(getNewDataSources(resourceMetaData,
toBeCreatedStorageUintNodeMap, dataSourcePoolPropsMap), Collections.emptyMap(),
Collections.emptyList(), mergedPropsMap);
}
@@ -68,16 +68,16 @@ public final class ResourceSwitchManager {
}
/**
- * Alter storage unit.
+ * switch resource by alter storage unit.
*
* @param resourceMetaData resource meta data
- * @param propsMap data source pool properties map
+ * @param toBeAlteredProps to be altered data source pool properties map
* @return created switching resource
*/
- public SwitchingResource alterStorageUnit(final ResourceMetaData
resourceMetaData, final Map<String, DataSourcePoolProperties> propsMap) {
+ public SwitchingResource switchByAlterStorageUnit(final ResourceMetaData
resourceMetaData, final Map<String, DataSourcePoolProperties> toBeAlteredProps)
{
Map<String, DataSourcePoolProperties> mergedDataSourcePoolPropsMap =
new LinkedHashMap<>(resourceMetaData.getStorageUnits().entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, entry ->
entry.getValue().getDataSourcePoolProperties(), (oldValue, currentValue) ->
oldValue, LinkedHashMap::new)));
- mergedDataSourcePoolPropsMap.putAll(propsMap);
+ mergedDataSourcePoolPropsMap.putAll(toBeAlteredProps);
Map<String, StorageNode> toBeAlteredStorageUintNodeMap =
StorageUnitNodeMapCreator.create(mergedDataSourcePoolPropsMap);
Map<StorageNode, DataSourcePoolProperties> dataSourcePoolPropsMap =
StorageNodeAggregator.aggregateDataSourcePoolProperties(mergedDataSourcePoolPropsMap);
return new
SwitchingResource(getAlterNewDataSources(toBeAlteredStorageUintNodeMap,
dataSourcePoolPropsMap),
@@ -103,13 +103,13 @@ public final class ResourceSwitchManager {
}
/**
- * Unregister storage unit.
+ * switch resource by unregister storage unit.
*
* @param resourceMetaData resource meta data
* @param storageUnitNames storage unit names
* @return created switching resource
*/
- public SwitchingResource unregisterStorageUnit(final ResourceMetaData
resourceMetaData, final Collection<String> storageUnitNames) {
+ public SwitchingResource switchByUnregisterStorageUnit(final
ResourceMetaData resourceMetaData, final Collection<String> storageUnitNames) {
Map<String, DataSourcePoolProperties>
mergedDataSourcePoolPropertiesMap = new
LinkedHashMap<>(resourceMetaData.getStorageUnits().entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, entry ->
entry.getValue().getDataSourcePoolProperties(), (oldValue, currentValue) ->
oldValue, LinkedHashMap::new)));
SwitchingResource result = new
SwitchingResource(Collections.emptyMap(),
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/StorageUnitManager.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/StorageUnitManager.java
index b4e1bee37f0..9b2ec0017e1 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/StorageUnitManager.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/StorageUnitManager.java
@@ -82,7 +82,7 @@ public final class StorageUnitManager {
public synchronized void registerStorageUnit(final String databaseName,
final Map<String, DataSourcePoolProperties> propsMap) {
try {
closeStaleRules(databaseName);
- SwitchingResource switchingResource =
resourceSwitchManager.registerStorageUnit(metaDataContexts.get().getMetaData().getDatabase(databaseName).getResourceMetaData(),
propsMap);
+ SwitchingResource switchingResource =
resourceSwitchManager.switchByRegisterStorageUnit(metaDataContexts.get().getMetaData().getDatabase(databaseName).getResourceMetaData(),
propsMap);
buildNewMetaDataContext(databaseName, switchingResource);
} catch (final SQLException ex) {
log.error("Alter database: {} register storage unit failed",
databaseName, ex);
@@ -98,7 +98,7 @@ public final class StorageUnitManager {
public synchronized void alterStorageUnit(final String databaseName, final
Map<String, DataSourcePoolProperties> propsMap) {
try {
closeStaleRules(databaseName);
- SwitchingResource switchingResource =
resourceSwitchManager.alterStorageUnit(metaDataContexts.get().getMetaData().getDatabase(databaseName).getResourceMetaData(),
propsMap);
+ SwitchingResource switchingResource =
resourceSwitchManager.switchByAlterStorageUnit(metaDataContexts.get().getMetaData().getDatabase(databaseName).getResourceMetaData(),
propsMap);
buildNewMetaDataContext(databaseName, switchingResource);
} catch (final SQLException ex) {
log.error("Alter database: {} register storage unit failed",
databaseName, ex);
@@ -114,7 +114,7 @@ public final class StorageUnitManager {
public synchronized void unregisterStorageUnit(final String databaseName,
final String storageUnitName) {
try {
closeStaleRules(databaseName);
- SwitchingResource switchingResource =
resourceSwitchManager.unregisterStorageUnit(metaDataContexts.get().getMetaData().getDatabase(databaseName).getResourceMetaData(),
+ SwitchingResource switchingResource =
resourceSwitchManager.switchByUnregisterStorageUnit(metaDataContexts.get().getMetaData().getDatabase(databaseName).getResourceMetaData(),
Collections.singletonList(storageUnitName));
buildNewMetaDataContext(databaseName, switchingResource);
} catch (final SQLException ex) {
diff --git
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/StandaloneMetaDataManagerPersistService.java
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/StandaloneMetaDataManagerPersistService.java
index 48d8e480b1b..cd609053dcd 100644
---
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/StandaloneMetaDataManagerPersistService.java
+++
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/StandaloneMetaDataManagerPersistService.java
@@ -29,9 +29,6 @@ import
org.apache.shardingsphere.infra.metadata.database.schema.pojo.AlterSchema
import
org.apache.shardingsphere.infra.metadata.database.schema.pojo.AlterSchemaPOJO;
import org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
import
org.apache.shardingsphere.infra.rule.attribute.datanode.MutableDataNodeRuleAttribute;
-import org.apache.shardingsphere.mode.event.dispatch.DispatchEvent;
-import
org.apache.shardingsphere.mode.event.dispatch.rule.alter.AlterRuleItemEvent;
-import
org.apache.shardingsphere.mode.event.dispatch.rule.drop.DropRuleItemEvent;
import org.apache.shardingsphere.infra.rule.scope.GlobalRule;
import
org.apache.shardingsphere.infra.rule.scope.GlobalRule.GlobalRuleChangedType;
import
org.apache.shardingsphere.infra.spi.type.ordered.cache.OrderedServicesCache;
@@ -40,10 +37,13 @@ import
org.apache.shardingsphere.metadata.persist.service.config.database.DataSo
import
org.apache.shardingsphere.metadata.persist.service.database.DatabaseMetaDataPersistService;
import org.apache.shardingsphere.mode.event.DataChangedEvent;
import org.apache.shardingsphere.mode.event.DataChangedEvent.Type;
+import
org.apache.shardingsphere.mode.event.builder.RuleConfigurationEventBuilder;
+import org.apache.shardingsphere.mode.event.dispatch.DispatchEvent;
+import
org.apache.shardingsphere.mode.event.dispatch.rule.alter.AlterRuleItemEvent;
+import
org.apache.shardingsphere.mode.event.dispatch.rule.drop.DropRuleItemEvent;
import org.apache.shardingsphere.mode.metadata.MetaDataContextManager;
import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
-import
org.apache.shardingsphere.mode.event.builder.RuleConfigurationEventBuilder;
-import org.apache.shardingsphere.mode.metadata.manager.ConfigurationManager;
+import org.apache.shardingsphere.mode.metadata.MetaDataContextsFactory;
import org.apache.shardingsphere.mode.metadata.manager.SwitchingResource;
import
org.apache.shardingsphere.mode.metadata.refresher.util.TableRefreshUtils;
import
org.apache.shardingsphere.mode.persist.service.MetaDataManagerPersistService;
@@ -222,10 +222,11 @@ public final class
StandaloneMetaDataManagerPersistService implements MetaDataMa
@Override
public void registerStorageUnits(final String databaseName, final
Map<String, DataSourcePoolProperties> toBeRegisteredProps) throws SQLException {
- SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager().registerStorageUnit(metaDataContextManager.getMetaDataContexts().get()
+ SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager().switchByRegisterStorageUnit(metaDataContextManager.getMetaDataContexts().get()
.getMetaData().getDatabase(databaseName).getResourceMetaData(),
toBeRegisteredProps);
-
metaDataContextManager.getMetaDataContexts().get().getMetaData().getDatabases().putAll(metaDataContextManager.getConfigurationManager()
- .createChangedDatabases(databaseName, false,
switchingResource, null));
+ Map<String, ShardingSphereDatabase> changedDatabases =
MetaDataContextsFactory.createChangedDatabases(databaseName, false,
switchingResource, null,
+ metaDataContextManager.getMetaDataContexts().get(),
metaDataPersistService, metaDataContextManager.getComputeNodeInstanceContext());
+
metaDataContextManager.getMetaDataContexts().get().getMetaData().getDatabases().putAll(changedDatabases);
metaDataContextManager.getMetaDataContexts().get().getMetaData().getGlobalRuleMetaData().getRules()
.forEach(each -> ((GlobalRule)
each).refresh(metaDataContextManager.getMetaDataContexts().get().getMetaData().getDatabases(),
GlobalRuleChangedType.DATABASE_CHANGED));
metaDataContextManager.getMetaDataContexts().get().getMetaData().getDatabase(databaseName).getSchemas()
@@ -239,10 +240,11 @@ public final class
StandaloneMetaDataManagerPersistService implements MetaDataMa
@Override
public void alterStorageUnits(final String databaseName, final Map<String,
DataSourcePoolProperties> toBeUpdatedProps) throws SQLException {
- SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager().alterStorageUnit(metaDataContextManager.getMetaDataContexts().get().getMetaData()
+ SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager().switchByAlterStorageUnit(metaDataContextManager.getMetaDataContexts().get().getMetaData()
.getDatabase(databaseName).getResourceMetaData(),
toBeUpdatedProps);
-
metaDataContextManager.getMetaDataContexts().get().getMetaData().getDatabases().putAll(metaDataContextManager.getConfigurationManager()
- .createChangedDatabases(databaseName, true, switchingResource,
null));
+ Map<String, ShardingSphereDatabase> changedDatabases =
MetaDataContextsFactory.createChangedDatabases(databaseName, true,
switchingResource, null,
+ metaDataContextManager.getMetaDataContexts().get(),
metaDataPersistService, metaDataContextManager.getComputeNodeInstanceContext());
+
metaDataContextManager.getMetaDataContexts().get().getMetaData().getDatabases().putAll(changedDatabases);
metaDataContextManager.getMetaDataContexts().get().getMetaData().getGlobalRuleMetaData().getRules()
.forEach(each -> ((GlobalRule)
each).refresh(metaDataContextManager.getMetaDataContexts().get().getMetaData().getDatabases(),
GlobalRuleChangedType.DATABASE_CHANGED));
DataSourceUnitPersistService dataSourceService =
metaDataPersistService.getDataSourceUnitService();
@@ -254,10 +256,10 @@ public final class
StandaloneMetaDataManagerPersistService implements MetaDataMa
@Override
public void unregisterStorageUnits(final String databaseName, final
Collection<String> toBeDroppedStorageUnitNames) throws SQLException {
- SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager().unregisterStorageUnit(metaDataContextManager.getMetaDataContexts().get().getMetaData()
+ SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager().switchByUnregisterStorageUnit(metaDataContextManager.getMetaDataContexts().get().getMetaData()
.getDatabase(databaseName).getResourceMetaData(),
toBeDroppedStorageUnitNames);
- ConfigurationManager configurationManager =
metaDataContextManager.getConfigurationManager();
- MetaDataContexts reloadMetaDataContexts =
configurationManager.createMetaDataContexts(databaseName, false,
switchingResource, null);
+ MetaDataContexts reloadMetaDataContexts =
MetaDataContextsFactory.createBySwitchResource(databaseName, false,
switchingResource,
+ metaDataContextManager.getMetaDataContexts().get(),
metaDataPersistService, metaDataContextManager.getComputeNodeInstanceContext());
metaDataPersistService.persistMetaDataByReloadDatabase(databaseName,
reloadMetaDataContexts.getMetaData().getDatabase(databaseName),
metaDataContextManager.getMetaDataContexts().get().getMetaData().getDatabase(databaseName),
true);
metaDataContextManager.deletedSchemaNames(databaseName,
reloadMetaDataContexts.getMetaData().getDatabase(databaseName),
