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 1d89663060f Refactor MetaDataContextsFactory (#34396)
1d89663060f is described below
commit 1d89663060ff3fd7850521d69e9f8f4e48a11edb
Author: Liang Zhang <[email protected]>
AuthorDate: Sun Jan 19 12:18:06 2025 +0800
Refactor MetaDataContextsFactory (#34396)
---
.../mode/metadata/MetaDataContextManager.java | 4 +-
.../mode/metadata/MetaDataContextsFactory.java | 113 +++++++++------------
.../manager/DatabaseRuleConfigurationManager.java | 2 +-
.../mode/metadata/manager/StorageUnitManager.java | 4 +-
.../mode/metadata/MetaDataContextsFactoryTest.java | 4 +-
.../cluster/ClusterContextManagerBuilder.java | 3 +-
.../ClusterMetaDataManagerPersistService.java | 12 +--
.../StandaloneContextManagerBuilder.java | 5 +-
.../StandaloneMetaDataManagerPersistService.java | 12 +--
9 files changed, 72 insertions(+), 87 deletions(-)
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 081c6aba5ab..38a4942e969 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
@@ -145,8 +145,8 @@ public class MetaDataContextManager {
Map<String, DataSourcePoolProperties> dataSourcePoolPropsFromRegCenter
= metaDataPersistService.getDataSourceUnitService().load(database.getName());
SwitchingResource switchingResource =
resourceSwitchManager.switchByAlterStorageUnit(database.getResourceMetaData(),
dataSourcePoolPropsFromRegCenter);
Collection<RuleConfiguration> ruleConfigs =
metaDataPersistService.getDatabaseRulePersistService().load(database.getName());
- ShardingSphereDatabase changedDatabase = MetaDataContextsFactory
- .createChangedDatabase(database.getName(), false,
switchingResource, ruleConfigs, metaDataContexts, metaDataPersistService,
computeNodeInstanceContext);
+ ShardingSphereDatabase changedDatabase = new
MetaDataContextsFactory(metaDataPersistService)
+ .createChangedDatabase(database.getName(), false,
switchingResource, ruleConfigs, metaDataContexts, computeNodeInstanceContext);
metaDataContexts.getMetaData().putDatabase(changedDatabase);
ConfigurationProperties props = new
ConfigurationProperties(metaDataPersistService.getPropsService().load());
Collection<RuleConfiguration> globalRuleConfigs =
metaDataPersistService.getGlobalRuleService().load();
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 7f804c71251..2fb10a2090e 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
@@ -17,8 +17,7 @@
package org.apache.shardingsphere.mode.metadata;
-import lombok.AccessLevel;
-import lombok.NoArgsConstructor;
+import lombok.RequiredArgsConstructor;
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;
@@ -60,59 +59,57 @@ import java.util.stream.Collectors;
/**
* Meta data contexts factory.
*/
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
+@RequiredArgsConstructor
public final class MetaDataContextsFactory {
+ private final MetaDataPersistService persistService;
+
/**
* Create meta data contexts.
*
- * @param persistService persist service
* @param param context manager builder parameter
* @param instanceContext compute node instance context
* @return meta data contexts
* @throws SQLException SQL exception
*/
- public static MetaDataContexts create(final MetaDataPersistService
persistService,
- final ContextManagerBuilderParameter
param, final ComputeNodeInstanceContext instanceContext) throws SQLException {
- return isCreateByLocal(persistService) ? createByLocal(persistService,
param, instanceContext) : createByRepository(persistService, param,
instanceContext);
- }
-
- private static boolean isCreateByLocal(final MetaDataPersistService
persistService) {
- return
persistService.getDatabaseMetaDataFacade().getDatabase().loadAllDatabaseNames().isEmpty();
+ public MetaDataContexts create(final ContextManagerBuilderParameter param,
final ComputeNodeInstanceContext instanceContext) throws SQLException {
+ return containsRegisteredDatabases() ? createFromRegisterCenter(param,
instanceContext) : createFromLocalConfiguration(param, instanceContext);
}
- private static MetaDataContexts createByLocal(final MetaDataPersistService
persistService,
- final
ContextManagerBuilderParameter param, final ComputeNodeInstanceContext
instanceContext) throws SQLException {
- ConfigurationProperties props = new
ConfigurationProperties(param.getProps());
- Collection<ShardingSphereDatabase> databases =
ShardingSphereDatabasesFactory.create(param.getDatabaseConfigs(), props,
instanceContext);
- MetaDataContexts result = createMetaDataContexts(persistService,
param.getGlobalRuleConfigs(), param.getGlobalDataSources(), databases, props);
- persistDatabaseConfigurations(result, param, persistService);
- persistMetaData(result, persistService);
- return result;
+ private boolean containsRegisteredDatabases() {
+ return
!persistService.getDatabaseMetaDataFacade().getDatabase().loadAllDatabaseNames().isEmpty();
}
- private static MetaDataContexts createByRepository(final
MetaDataPersistService persistService, final ContextManagerBuilderParameter
param, final ComputeNodeInstanceContext instanceContext) {
+ private MetaDataContexts createFromRegisterCenter(final
ContextManagerBuilderParameter param, final ComputeNodeInstanceContext
instanceContext) {
Map<String, DatabaseConfiguration> effectiveDatabaseConfigs =
createEffectiveDatabaseConfigurations(
- getDatabaseNames(persistService, param.getDatabaseConfigs(),
instanceContext), param.getDatabaseConfigs(), persistService);
+ getDatabaseNames(param.getDatabaseConfigs(), instanceContext),
param.getDatabaseConfigs());
Collection<RuleConfiguration> globalRuleConfigs =
persistService.getGlobalRuleService().load();
// TODO load global data sources from persist service
Map<String, DataSource> globalDataSources =
param.getGlobalDataSources();
ConfigurationProperties props = new
ConfigurationProperties(persistService.getPropsService().load());
Collection<ShardingSphereDatabase> databases =
ShardingSphereDatabasesFactory.create(
- effectiveDatabaseConfigs, loadSchemas(persistService,
effectiveDatabaseConfigs.keySet()), props, instanceContext);
- return createMetaDataContexts(persistService, globalRuleConfigs,
globalDataSources, databases, props);
+ effectiveDatabaseConfigs,
loadSchemas(effectiveDatabaseConfigs.keySet()), props, instanceContext);
+ return createMetaDataContexts(globalRuleConfigs, globalDataSources,
databases, props);
+ }
+
+ private MetaDataContexts createFromLocalConfiguration(final
ContextManagerBuilderParameter param, final ComputeNodeInstanceContext
instanceContext) throws SQLException {
+ ConfigurationProperties props = new
ConfigurationProperties(param.getProps());
+ Collection<ShardingSphereDatabase> databases =
ShardingSphereDatabasesFactory.create(param.getDatabaseConfigs(), props,
instanceContext);
+ MetaDataContexts result =
createMetaDataContexts(param.getGlobalRuleConfigs(),
param.getGlobalDataSources(), databases, props);
+ persistDatabaseConfigurations(result, param);
+ persistMetaData(result);
+ return result;
}
- private static MetaDataContexts createMetaDataContexts(final
MetaDataPersistService persistService,
- final
Collection<RuleConfiguration> globalRuleConfigs, final Map<String, DataSource>
globalDataSources,
- final
Collection<ShardingSphereDatabase> databases, final ConfigurationProperties
props) {
+ private MetaDataContexts createMetaDataContexts(final
Collection<RuleConfiguration> globalRuleConfigs, final Map<String, DataSource>
globalDataSources,
+ final
Collection<ShardingSphereDatabase> databases, final ConfigurationProperties
props) {
Collection<ShardingSphereRule> globalRules =
GlobalRulesBuilder.buildRules(globalRuleConfigs, databases, props);
ShardingSphereMetaData metaData = new
ShardingSphereMetaData(databases, new ResourceMetaData(globalDataSources), new
RuleMetaData(globalRules), props);
ShardingSphereStatistics statistics =
ShardingSphereStatisticsFactory.create(metaData,
persistService.getShardingSphereDataPersistService().load(metaData));
return new MetaDataContexts(metaData, statistics);
}
- private static void persistDatabaseConfigurations(final MetaDataContexts
metadataContexts, final ContextManagerBuilderParameter param, final
MetaDataPersistService persistService) {
+ private void persistDatabaseConfigurations(final MetaDataContexts
metadataContexts, final ContextManagerBuilderParameter param) {
Collection<RuleConfiguration> globalRuleConfigs =
metadataContexts.getMetaData().getGlobalRuleMetaData().getConfigurations();
persistService.persistGlobalRuleConfiguration(globalRuleConfigs,
param.getProps());
for (Entry<String, ? extends DatabaseConfiguration> entry :
param.getDatabaseConfigs().entrySet()) {
@@ -124,7 +121,7 @@ public final class MetaDataContextsFactory {
}
}
- private static void persistMetaData(final MetaDataContexts
metaDataContexts, final MetaDataPersistService persistService) {
+ private void persistMetaData(final MetaDataContexts metaDataContexts) {
metaDataContexts.getMetaData().getAllDatabases().forEach(each ->
each.getAllSchemas().forEach(schema -> {
if (schema.isEmpty()) {
persistService.getDatabaseMetaDataFacade().getSchema().add(each.getName(),
schema.getName());
@@ -139,33 +136,30 @@ public final class MetaDataContextsFactory {
}
}
- private static Collection<String> getDatabaseNames(final
MetaDataPersistService persistService, final Map<String, DatabaseConfiguration>
databaseConfigs,
- final
ComputeNodeInstanceContext instanceContext) {
+ private Collection<String> getDatabaseNames(final Map<String,
DatabaseConfiguration> databaseConfigs, final ComputeNodeInstanceContext
instanceContext) {
return instanceContext.getInstance().getMetaData() instanceof
JDBCInstanceMetaData
? databaseConfigs.keySet()
:
persistService.getDatabaseMetaDataFacade().getDatabase().loadAllDatabaseNames();
}
- private static Map<String, DatabaseConfiguration>
createEffectiveDatabaseConfigurations(final Collection<String> databaseNames,
-
final Map<String, DatabaseConfiguration> databaseConfigs, final
MetaDataPersistService persistService) {
- return databaseNames.stream().collect(Collectors.toMap(each -> each,
each -> createEffectiveDatabaseConfiguration(each, databaseConfigs,
persistService)));
+ private Map<String, DatabaseConfiguration>
createEffectiveDatabaseConfigurations(final Collection<String> databaseNames,
final Map<String, DatabaseConfiguration> databaseConfigs) {
+ return databaseNames.stream().collect(Collectors.toMap(each -> each,
each -> createEffectiveDatabaseConfiguration(each, databaseConfigs)));
}
- private static DatabaseConfiguration
createEffectiveDatabaseConfiguration(final String databaseName,
-
final Map<String, DatabaseConfiguration> databaseConfigs, final
MetaDataPersistService persistService) {
+ private DatabaseConfiguration createEffectiveDatabaseConfiguration(final
String databaseName, final Map<String, DatabaseConfiguration> databaseConfigs) {
closeGeneratedDataSources(databaseName, databaseConfigs);
Map<String, DataSourceConfiguration> dataSources =
persistService.loadDataSourceConfigurations(databaseName);
Collection<RuleConfiguration> databaseRuleConfigs =
persistService.getDatabaseRulePersistService().load(databaseName);
return new DataSourceGeneratedDatabaseConfiguration(dataSources,
databaseRuleConfigs);
}
- private static void closeGeneratedDataSources(final String databaseName,
final Map<String, ? extends DatabaseConfiguration> databaseConfigs) {
+ private void closeGeneratedDataSources(final String databaseName, final
Map<String, ? extends DatabaseConfiguration> databaseConfigs) {
if (databaseConfigs.containsKey(databaseName) &&
!databaseConfigs.get(databaseName).getStorageUnits().isEmpty()) {
databaseConfigs.get(databaseName).getDataSources().values().forEach(each -> new
DataSourcePoolDestroyer(each).asyncDestroy());
}
}
- private static Map<String, Collection<ShardingSphereSchema>>
loadSchemas(final MetaDataPersistService persistService, final
Collection<String> databaseNames) {
+ private Map<String, Collection<ShardingSphereSchema>> loadSchemas(final
Collection<String> databaseNames) {
return databaseNames.stream().collect(Collectors.toMap(each -> each,
each -> persistService.getDatabaseMetaDataFacade().getSchema().load(each)));
}
@@ -176,16 +170,14 @@ public final class MetaDataContextsFactory {
* @param internalLoadMetaData internal load meta data
* @param switchingResource switching resource
* @param originalMetaDataContexts original meta data contexts
- * @param persistService meta data persist service
* @param instanceContext 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 originalMetaDataContexts, final MetaDataPersistService
persistService,
- final
ComputeNodeInstanceContext instanceContext) throws SQLException {
+ public MetaDataContexts createBySwitchResource(final String databaseName,
final boolean internalLoadMetaData, final SwitchingResource switchingResource,
+ final MetaDataContexts
originalMetaDataContexts, final ComputeNodeInstanceContext instanceContext)
throws SQLException {
ShardingSphereDatabase changedDatabase = createChangedDatabase(
- databaseName, internalLoadMetaData, switchingResource, null,
originalMetaDataContexts, persistService, instanceContext);
+ databaseName, internalLoadMetaData, switchingResource, null,
originalMetaDataContexts, instanceContext);
ConfigurationProperties props =
originalMetaDataContexts.getMetaData().getProps();
ShardingSphereMetaData clonedMetaData =
cloneMetaData(originalMetaDataContexts.getMetaData(), changedDatabase);
RuleMetaData changedGlobalMetaData = new RuleMetaData(
@@ -202,16 +194,14 @@ public final class MetaDataContextsFactory {
* @param internalLoadMetaData internal load meta data
* @param ruleConfigs rule configs
* @param originalMetaDataContexts original meta data contexts
- * @param persistService meta data persist service
* @param instanceContext compute node instance context
* @return meta data contexts
* @throws SQLException SQL exception
*/
- public static MetaDataContexts createByAlterRule(final String
databaseName, final boolean internalLoadMetaData, final
Collection<RuleConfiguration> ruleConfigs,
- final MetaDataContexts
originalMetaDataContexts, final MetaDataPersistService persistService,
- final
ComputeNodeInstanceContext instanceContext) throws SQLException {
+ public MetaDataContexts createByAlterRule(final String databaseName, final
boolean internalLoadMetaData, final Collection<RuleConfiguration> ruleConfigs,
+ final MetaDataContexts
originalMetaDataContexts, final ComputeNodeInstanceContext instanceContext)
throws SQLException {
ShardingSphereDatabase changedDatabase = createChangedDatabase(
- databaseName, internalLoadMetaData, null, ruleConfigs,
originalMetaDataContexts, persistService, instanceContext);
+ databaseName, internalLoadMetaData, null, ruleConfigs,
originalMetaDataContexts, instanceContext);
ShardingSphereMetaData clonedMetaData =
cloneMetaData(originalMetaDataContexts.getMetaData(), changedDatabase);
ConfigurationProperties props =
originalMetaDataContexts.getMetaData().getProps();
RuleMetaData changedGlobalMetaData = new RuleMetaData(
@@ -221,7 +211,7 @@ public final class MetaDataContextsFactory {
return new MetaDataContexts(metaData,
ShardingSphereStatisticsFactory.create(metaData,
persistService.getShardingSphereDataPersistService().load(metaData)));
}
- private static ShardingSphereMetaData cloneMetaData(final
ShardingSphereMetaData originalMetaData, final ShardingSphereDatabase
changedDatabase) {
+ private ShardingSphereMetaData cloneMetaData(final ShardingSphereMetaData
originalMetaData, final ShardingSphereDatabase changedDatabase) {
ShardingSphereMetaData result = new ShardingSphereMetaData(
originalMetaData.getAllDatabases(),
originalMetaData.getGlobalResourceMetaData(),
originalMetaData.getGlobalRuleMetaData(), originalMetaData.getProps());
result.putDatabase(changedDatabase);
@@ -236,40 +226,37 @@ public final class MetaDataContextsFactory {
* @param switchingResource switching resource
* @param ruleConfigs rule configurations
* @param originalMetaDataContext original meta data contexts
- * @param persistService meta data persist service
* @param instanceContext compute node instance context
* @return changed database
* @throws SQLException SQL exception
*/
- public static ShardingSphereDatabase createChangedDatabase(final String
databaseName, final boolean internalLoadMetaData,
- final
SwitchingResource switchingResource, final Collection<RuleConfiguration>
ruleConfigs,
- final
MetaDataContexts originalMetaDataContext, final MetaDataPersistService
persistService,
- final
ComputeNodeInstanceContext instanceContext) throws SQLException {
+ public ShardingSphereDatabase createChangedDatabase(final String
databaseName, final boolean internalLoadMetaData,
+ final
SwitchingResource switchingResource, final Collection<RuleConfiguration>
ruleConfigs,
+ final MetaDataContexts
originalMetaDataContext, final ComputeNodeInstanceContext instanceContext)
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);
return
createChangedDatabase(originalMetaDataContext.getMetaData().getDatabase(databaseName).getName(),
internalLoadMetaData,
- persistService, toBeCreatedDatabaseConfig,
originalMetaDataContext.getMetaData().getProps(), instanceContext);
+ toBeCreatedDatabaseConfig,
originalMetaDataContext.getMetaData().getProps(), instanceContext);
}
- private static ShardingSphereDatabase createChangedDatabase(final String
databaseName, final boolean internalLoadMetaData, final MetaDataPersistService
persistService,
- final
DatabaseConfiguration databaseConfig, final ConfigurationProperties props,
- final
ComputeNodeInstanceContext instanceContext) throws SQLException {
+ private ShardingSphereDatabase createChangedDatabase(final String
databaseName, final boolean internalLoadMetaData, final DatabaseConfiguration
databaseConfig,
+ final
ConfigurationProperties props, final ComputeNodeInstanceContext
instanceContext) throws SQLException {
DatabaseType protocolType =
DatabaseTypeEngine.getProtocolType(databaseConfig, props);
return internalLoadMetaData
? ShardingSphereDatabase.create(databaseName, protocolType,
databaseConfig, instanceContext,
persistService.getDatabaseMetaDataFacade().getSchema().load(databaseName))
: ShardingSphereDatabase.create(databaseName, protocolType,
databaseConfig, props, instanceContext);
}
- private static ResourceMetaData getEffectiveResourceMetaData(final
ShardingSphereDatabase database, final SwitchingResource resource) {
+ private 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) {
+ 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())) {
@@ -279,7 +266,7 @@ public final class MetaDataContextsFactory {
return result;
}
- private static Map<String, StorageUnit> getStorageUnits(final Map<String,
StorageUnit> currentStorageUnits, final SwitchingResource resource) {
+ 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())) {
@@ -289,15 +276,15 @@ public final class MetaDataContextsFactory {
return result;
}
- private static DatabaseConfiguration getDatabaseConfiguration(final
ResourceMetaData resourceMetaData, final SwitchingResource switchingResource,
- final
Collection<RuleConfiguration> toBeCreatedRuleConfigs) {
+ 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 static Map<StorageNode, DataSource>
getMergedStorageNodeDataSources(final ResourceMetaData currentResourceMetaData,
final SwitchingResource switchingResource) {
+ 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());
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/DatabaseRuleConfigurationManager.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/DatabaseRuleConfigurationManager.java
index d8baeb451c6..08387674c4e 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/DatabaseRuleConfigurationManager.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/DatabaseRuleConfigurationManager.java
@@ -102,7 +102,7 @@ public final class DatabaseRuleConfigurationManager {
}
private void refreshMetadata(final String databaseName, final
Collection<RuleConfiguration> ruleConfigurations) throws SQLException {
-
metaDataContexts.update(MetaDataContextsFactory.createByAlterRule(databaseName,
false, ruleConfigurations, metaDataContexts, metaDataPersistService,
computeNodeInstanceContext));
+ metaDataContexts.update(new
MetaDataContextsFactory(metaDataPersistService).createByAlterRule(databaseName,
false, ruleConfigurations, metaDataContexts, computeNodeInstanceContext));
}
private Collection<RuleConfiguration> getRuleConfigurations(final
Collection<ShardingSphereRule> rules) {
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 9d2240a9e64..3079015c6f6 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
@@ -107,8 +107,8 @@ public final class StorageUnitManager {
}
private void buildNewMetaDataContext(final String databaseName, final
SwitchingResource switchingResource) throws SQLException {
- MetaDataContexts reloadMetaDataContexts =
MetaDataContextsFactory.createBySwitchResource(
- databaseName, true, switchingResource, metaDataContexts,
metaDataPersistService, computeNodeInstanceContext);
+ MetaDataContexts reloadMetaDataContexts = new
MetaDataContextsFactory(metaDataPersistService).createBySwitchResource(
+ databaseName, true, switchingResource, metaDataContexts,
computeNodeInstanceContext);
metaDataContexts.update(reloadMetaDataContexts);
metaDataContexts.getMetaData().putDatabase(buildDatabase(reloadMetaDataContexts.getMetaData().getDatabase(databaseName)));
switchingResource.closeStaleDataSources();
diff --git
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/MetaDataContextsFactoryTest.java
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/MetaDataContextsFactoryTest.java
index 0df9edbaf47..f88f1a4fabe 100644
---
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/MetaDataContextsFactoryTest.java
+++
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/MetaDataContextsFactoryTest.java
@@ -109,7 +109,7 @@ class MetaDataContextsFactoryTest {
void assertCreateWithJDBCInstanceMetaData() throws SQLException {
ComputeNodeInstanceContext computeNodeInstanceContext =
mock(ComputeNodeInstanceContext.class, RETURNS_DEEP_STUBS);
when(computeNodeInstanceContext.getInstance().getMetaData()).thenReturn(mock(JDBCInstanceMetaData.class));
- MetaDataContexts actual =
MetaDataContextsFactory.create(metaDataPersistService,
createContextManagerBuilderParameter(), computeNodeInstanceContext);
+ MetaDataContexts actual = new
MetaDataContextsFactory(metaDataPersistService).create(createContextManagerBuilderParameter(),
computeNodeInstanceContext);
assertThat(actual.getMetaData().getGlobalRuleMetaData().getRules().size(),
is(1));
assertThat(actual.getMetaData().getGlobalRuleMetaData().getRules().iterator().next(),
instanceOf(MockedRule.class));
assertTrue(actual.getMetaData().containsDatabase("foo_db"));
@@ -120,7 +120,7 @@ class MetaDataContextsFactoryTest {
void assertCreateWithProxyInstanceMetaData() throws SQLException {
when(databaseMetaDataPersistFacade.getDatabase().loadAllDatabaseNames()).thenReturn(Collections.singletonList("foo_db"));
when(metaDataPersistService.getDatabaseMetaDataFacade()).thenReturn(databaseMetaDataPersistFacade);
- MetaDataContexts actual =
MetaDataContextsFactory.create(metaDataPersistService,
createContextManagerBuilderParameter(), mock(ComputeNodeInstanceContext.class,
RETURNS_DEEP_STUBS));
+ MetaDataContexts actual = new
MetaDataContextsFactory(metaDataPersistService).create(createContextManagerBuilderParameter(),
mock(ComputeNodeInstanceContext.class, RETURNS_DEEP_STUBS));
assertThat(actual.getMetaData().getGlobalRuleMetaData().getRules().size(),
is(1));
assertThat(actual.getMetaData().getGlobalRuleMetaData().getRules().iterator().next(),
instanceOf(MockedRule.class));
assertTrue(actual.getMetaData().containsDatabase("foo_db"));
diff --git
a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/ClusterContextManagerBuilder.java
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/ClusterContextManagerBuilder.java
index 2e997abe9d2..de6545ebea9 100644
---
a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/ClusterContextManagerBuilder.java
+++
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/ClusterContextManagerBuilder.java
@@ -60,8 +60,7 @@ public final class ClusterContextManagerBuilder implements
ContextManagerBuilder
ClusterPersistRepository repository =
getClusterPersistRepository(config, computeNodeInstanceContext);
LockContext lockContext = new ClusterLockContext(new
GlobalLockPersistService(repository));
computeNodeInstanceContext.init(new
ClusterWorkerIdGenerator(repository, param.getInstanceMetaData().getId()),
lockContext);
- MetaDataPersistService metaDataPersistService = new
MetaDataPersistService(repository);
- MetaDataContexts metaDataContexts =
MetaDataContextsFactory.create(metaDataPersistService, param,
computeNodeInstanceContext);
+ MetaDataContexts metaDataContexts = new MetaDataContextsFactory(new
MetaDataPersistService(repository)).create(param, computeNodeInstanceContext);
ContextManager result = new ContextManager(metaDataContexts,
computeNodeInstanceContext, repository);
registerOnline(computeNodeInstanceContext, param, result, repository);
return result;
diff --git
a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java
index 5d73de6ee14..b8bc61de563 100644
---
a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java
+++
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/persist/service/ClusterMetaDataManagerPersistService.java
@@ -125,8 +125,8 @@ public final class ClusterMetaDataManagerPersistService
implements MetaDataManag
SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager()
.switchByRegisterStorageUnit(originalMetaDataContexts.getMetaData().getDatabase(databaseName).getResourceMetaData(),
toBeRegisteredProps);
newDataSources.putAll(switchingResource.getNewDataSources());
- MetaDataContexts reloadMetaDataContexts =
MetaDataContextsFactory.createBySwitchResource(databaseName, false,
- switchingResource, originalMetaDataContexts,
metaDataPersistService, metaDataContextManager.getComputeNodeInstanceContext());
+ MetaDataContexts reloadMetaDataContexts = new
MetaDataContextsFactory(metaDataPersistService).createBySwitchResource(
+ databaseName, false, switchingResource,
originalMetaDataContexts,
metaDataContextManager.getComputeNodeInstanceContext());
metaDataPersistService.getDataSourceUnitService().persist(databaseName,
toBeRegisteredProps);
afterStorageUnitsAltered(databaseName, originalMetaDataContexts,
reloadMetaDataContexts);
reloadMetaDataContexts.getMetaData().close();
@@ -143,8 +143,8 @@ public final class ClusterMetaDataManagerPersistService
implements MetaDataManag
SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager()
.switchByAlterStorageUnit(originalMetaDataContexts.getMetaData().getDatabase(databaseName).getResourceMetaData(),
toBeUpdatedProps);
newDataSources.putAll(switchingResource.getNewDataSources());
- MetaDataContexts reloadMetaDataContexts =
MetaDataContextsFactory.createBySwitchResource(databaseName, false,
- switchingResource, originalMetaDataContexts,
metaDataPersistService, metaDataContextManager.getComputeNodeInstanceContext());
+ MetaDataContexts reloadMetaDataContexts = new
MetaDataContextsFactory(metaDataPersistService).createBySwitchResource(
+ databaseName, false, switchingResource,
originalMetaDataContexts,
metaDataContextManager.getComputeNodeInstanceContext());
DataSourceUnitPersistService dataSourceService =
metaDataPersistService.getDataSourceUnitService();
metaDataPersistService.getMetaDataVersionPersistService()
.switchActiveVersion(dataSourceService.persist(databaseName, toBeUpdatedProps));
@@ -161,8 +161,8 @@ public final class ClusterMetaDataManagerPersistService
implements MetaDataManag
MetaDataContexts originalMetaDataContexts =
buildOriginalMetaDataContexts();
SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager()
.createByUnregisterStorageUnit(originalMetaDataContexts.getMetaData().getDatabase(databaseName).getResourceMetaData(),
Collections.singletonList(each));
- MetaDataContexts reloadMetaDataContexts =
MetaDataContextsFactory.createBySwitchResource(databaseName, false,
- switchingResource, originalMetaDataContexts,
metaDataPersistService, metaDataContextManager.getComputeNodeInstanceContext());
+ MetaDataContexts reloadMetaDataContexts = new
MetaDataContextsFactory(metaDataPersistService).createBySwitchResource(
+ databaseName, false, switchingResource,
originalMetaDataContexts,
metaDataContextManager.getComputeNodeInstanceContext());
metaDataPersistService.getDataSourceUnitService().delete(databaseName, each);
afterStorageUnitsDropped(databaseName, originalMetaDataContexts,
reloadMetaDataContexts);
reloadMetaDataContexts.getMetaData().close();
diff --git
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneContextManagerBuilder.java
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneContextManagerBuilder.java
index 824887b9feb..03d10bf61a1 100644
---
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneContextManagerBuilder.java
+++
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/StandaloneContextManagerBuilder.java
@@ -22,7 +22,6 @@ import
org.apache.shardingsphere.infra.instance.ComputeNodeInstance;
import org.apache.shardingsphere.infra.instance.ComputeNodeInstanceContext;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import org.apache.shardingsphere.infra.util.eventbus.EventBusContext;
-import org.apache.shardingsphere.mode.metadata.persist.MetaDataPersistService;
import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.mode.manager.ContextManagerBuilder;
import org.apache.shardingsphere.mode.manager.ContextManagerBuilderParameter;
@@ -30,6 +29,7 @@ import
org.apache.shardingsphere.mode.manager.standalone.lock.StandaloneLockCont
import
org.apache.shardingsphere.mode.manager.standalone.workerid.StandaloneWorkerIdGenerator;
import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
import org.apache.shardingsphere.mode.metadata.MetaDataContextsFactory;
+import org.apache.shardingsphere.mode.metadata.persist.MetaDataPersistService;
import
org.apache.shardingsphere.mode.repository.standalone.StandalonePersistRepository;
import java.sql.SQLException;
@@ -45,10 +45,9 @@ public final class StandaloneContextManagerBuilder
implements ContextManagerBuil
PersistRepositoryConfiguration repositoryConfig =
param.getModeConfiguration().getRepository();
StandalonePersistRepository repository = TypedSPILoader.getService(
StandalonePersistRepository.class, null == repositoryConfig ?
null : repositoryConfig.getType(), null == repositoryConfig ? new Properties()
: repositoryConfig.getProps());
- MetaDataPersistService persistService = new
MetaDataPersistService(repository);
ComputeNodeInstanceContext computeNodeInstanceContext = new
ComputeNodeInstanceContext(new
ComputeNodeInstance(param.getInstanceMetaData()), param.getModeConfiguration(),
eventBusContext);
computeNodeInstanceContext.init(new StandaloneWorkerIdGenerator(), new
StandaloneLockContext());
- MetaDataContexts metaDataContexts =
MetaDataContextsFactory.create(persistService, param,
computeNodeInstanceContext);
+ MetaDataContexts metaDataContexts = new MetaDataContextsFactory(new
MetaDataPersistService(repository)).create(param, computeNodeInstanceContext);
return new ContextManager(metaDataContexts,
computeNodeInstanceContext, repository);
}
diff --git
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java
index a5fbf412c1e..71354d17bd1 100644
---
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java
+++
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/persist/service/StandaloneMetaDataManagerPersistService.java
@@ -224,8 +224,8 @@ public final class StandaloneMetaDataManagerPersistService
implements MetaDataMa
public void registerStorageUnits(final String databaseName, final
Map<String, DataSourcePoolProperties> toBeRegisteredProps) throws SQLException {
SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager().switchByRegisterStorageUnit(metaDataContextManager.getMetaDataContexts()
.getMetaData().getDatabase(databaseName).getResourceMetaData(),
toBeRegisteredProps);
- ShardingSphereDatabase changedDatabase =
MetaDataContextsFactory.createChangedDatabase(databaseName, false,
switchingResource, null,
- metaDataContextManager.getMetaDataContexts(),
metaDataPersistService, metaDataContextManager.getComputeNodeInstanceContext());
+ ShardingSphereDatabase changedDatabase = new
MetaDataContextsFactory(metaDataPersistService).createChangedDatabase(databaseName,
false, switchingResource, null,
+ metaDataContextManager.getMetaDataContexts(),
metaDataContextManager.getComputeNodeInstanceContext());
metaDataContextManager.getMetaDataContexts().getMetaData().putDatabase(changedDatabase);
metaDataContextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData().getRules()
.forEach(each -> ((GlobalRule)
each).refresh(metaDataContextManager.getMetaDataContexts().getMetaData().getAllDatabases(),
GlobalRuleChangedType.DATABASE_CHANGED));
@@ -246,8 +246,8 @@ public final class StandaloneMetaDataManagerPersistService
implements MetaDataMa
public void alterStorageUnits(final String databaseName, final Map<String,
DataSourcePoolProperties> toBeUpdatedProps) throws SQLException {
SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager().switchByAlterStorageUnit(metaDataContextManager.getMetaDataContexts().getMetaData()
.getDatabase(databaseName).getResourceMetaData(),
toBeUpdatedProps);
- ShardingSphereDatabase changedDatabase =
MetaDataContextsFactory.createChangedDatabase(databaseName, true,
switchingResource, null,
- metaDataContextManager.getMetaDataContexts(),
metaDataPersistService, metaDataContextManager.getComputeNodeInstanceContext());
+ ShardingSphereDatabase changedDatabase = new
MetaDataContextsFactory(metaDataPersistService).createChangedDatabase(databaseName,
true, switchingResource, null,
+ metaDataContextManager.getMetaDataContexts(),
metaDataContextManager.getComputeNodeInstanceContext());
metaDataContextManager.getMetaDataContexts().getMetaData().putDatabase(changedDatabase);
metaDataContextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData().getRules()
.forEach(each -> ((GlobalRule)
each).refresh(metaDataContextManager.getMetaDataContexts().getMetaData().getAllDatabases(),
GlobalRuleChangedType.DATABASE_CHANGED));
@@ -262,8 +262,8 @@ public final class StandaloneMetaDataManagerPersistService
implements MetaDataMa
public void unregisterStorageUnits(final String databaseName, final
Collection<String> toBeDroppedStorageUnitNames) throws SQLException {
SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager().switchByUnregisterStorageUnit(metaDataContextManager.getMetaDataContexts().getMetaData()
.getDatabase(databaseName).getResourceMetaData(),
toBeDroppedStorageUnitNames);
- MetaDataContexts reloadMetaDataContexts =
MetaDataContextsFactory.createBySwitchResource(databaseName, false,
switchingResource,
- metaDataContextManager.getMetaDataContexts(),
metaDataPersistService, metaDataContextManager.getComputeNodeInstanceContext());
+ MetaDataContexts reloadMetaDataContexts = new
MetaDataContextsFactory(metaDataPersistService).createBySwitchResource(databaseName,
false, switchingResource,
+ metaDataContextManager.getMetaDataContexts(),
metaDataContextManager.getComputeNodeInstanceContext());
metaDataPersistService.persistReloadDatabaseByDrop(databaseName,
reloadMetaDataContexts.getMetaData().getDatabase(databaseName),
metaDataContextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName));
metaDataContextManager.dropSchemas(databaseName,
reloadMetaDataContexts.getMetaData().getDatabase(databaseName),
