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 f37cff49963 Add spi MetaDataManagerPersistService to instead of
ModeContextManager (#31361)
f37cff49963 is described below
commit f37cff49963fe4cb7d4bfaee327530083e66169b
Author: Haoran Meng <[email protected]>
AuthorDate: Thu May 23 13:30:02 2024 +0800
Add spi MetaDataManagerPersistService to instead of ModeContextManager
(#31361)
---
.../mode/manager/ContextManager.java | 2 +-
.../service/MetaDataManagerPersistService.java | 152 ++++++++++
...a => MetaDataManagerPersistServiceBuilder.java} | 25 +-
.../mode/service/PersistServiceFacade.java | 8 +-
...taDataManagerPersistServiceBuilderFixture.java} | 30 +-
.../mode/manager/ContextManagerTest.java | 4 +-
...de.service.MetaDataManagerPersistServiceBuilder | 18 ++
.../ClusterMetaDataManagerPersistService.java | 158 ++++++++++
...usterMetaDataManagerPersistServiceBuilder.java} | 26 +-
...de.service.MetaDataManagerPersistServiceBuilder | 18 ++
.../StandaloneMetaDataManagerPersistService.java | 322 +++++++++++++++++++++
...aloneMetaDataManagerPersistServiceBuilder.java} | 29 +-
...de.service.MetaDataManagerPersistServiceBuilder | 18 ++
.../ProxyDatabaseConnectionManagerTest.java | 5 +-
.../backend/connector/ProxySQLExecutorTest.java | 5 +-
.../DatabaseAdminQueryBackendHandlerTest.java | 5 +-
.../ral/QueryableRALBackendHandlerTest.java | 5 +-
.../FrontDatabaseProtocolTypeFactoryTest.java | 5 +-
.../frontend/state/impl/OKProxyStateTest.java | 5 +-
.../PostgreSQLCommandExecuteEngineTest.java | 5 +-
20 files changed, 781 insertions(+), 64 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 698651fa6c4..78905598a88 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
@@ -84,7 +84,7 @@ public final class ContextManager implements AutoCloseable {
resourceMetaDataContextManager = new
ResourceMetaDataContextManager(this.metaDataContexts);
executorEngine =
ExecutorEngine.createExecutorEngineWithSize(metaDataContexts.getMetaData().getProps().<Integer>getValue(ConfigurationPropertyKey.KERNEL_EXECUTOR_SIZE));
stateContext = new StateContext();
- persistServiceFacade = new
PersistServiceFacade(metaDataContexts.getPersistService().getRepository());
+ persistServiceFacade = new
PersistServiceFacade(metaDataContexts.getPersistService().getRepository(),
computeNodeInstanceContext.getModeConfiguration(), this);
}
/**
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/service/MetaDataManagerPersistService.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/service/MetaDataManagerPersistService.java
new file mode 100644
index 00000000000..8b1d9a91ae3
--- /dev/null
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/service/MetaDataManagerPersistService.java
@@ -0,0 +1,152 @@
+/*
+ * 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.service;
+
+import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
+import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
+import
org.apache.shardingsphere.infra.metadata.database.schema.pojo.AlterSchemaMetaDataPOJO;
+import
org.apache.shardingsphere.infra.metadata.database.schema.pojo.AlterSchemaPOJO;
+import org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
+
+import java.sql.SQLException;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Properties;
+
+/**
+ * Meta data manager persist service.
+ */
+public interface MetaDataManagerPersistService {
+
+ /**
+ * Create database.
+ *
+ * @param databaseName database name
+ */
+ void createDatabase(String databaseName);
+
+ /**
+ * Drop database.
+ *
+ * @param databaseName database name
+ */
+ void dropDatabase(String databaseName);
+
+ /**
+ * Create schema.
+ *
+ * @param databaseName database name
+ * @param schemaName schema name
+ */
+ void createSchema(String databaseName, String schemaName);
+
+ /**
+ * Alter schema.
+ *
+ * @param alterSchemaPOJO alter schema pojo
+ */
+ void alterSchema(AlterSchemaPOJO alterSchemaPOJO);
+
+ /**
+ * Drop schema.
+ *
+ * @param databaseName database name
+ * @param schemaNames schema names
+ */
+ void dropSchema(String databaseName, Collection<String> schemaNames);
+
+ /**
+ * Alter schema metadata.
+ *
+ * @param alterSchemaMetaDataPOJO alter schema metadata pojo
+ */
+ void alterSchemaMetaData(AlterSchemaMetaDataPOJO alterSchemaMetaDataPOJO);
+
+ /**
+ * Register storage units.
+ *
+ * @param databaseName database name
+ * @param toBeRegisteredProps to be registered storage unit properties
+ * @throws SQLException SQL exception
+ */
+ void registerStorageUnits(String databaseName, Map<String,
DataSourcePoolProperties> toBeRegisteredProps) throws SQLException;
+
+ /**
+ * Alter storage units.
+ *
+ * @param databaseName database name
+ * @param toBeUpdatedProps to be updated storage unit properties
+ * @throws SQLException SQL exception
+ */
+ void alterStorageUnits(String databaseName, Map<String,
DataSourcePoolProperties> toBeUpdatedProps) throws SQLException;
+
+ /**
+ * Unregister storage units.
+ * @param databaseName database name
+ * @param toBeDroppedStorageUnitNames to be dropped storage unit names
+ * @throws SQLException SQL exception
+ */
+ void unregisterStorageUnits(String databaseName, Collection<String>
toBeDroppedStorageUnitNames) throws SQLException;
+
+ /**
+ * Alter single rule configuration.
+ *
+ * @param databaseName database name
+ * @param ruleConfigs rule configs
+ */
+ void alterSingleRuleConfiguration(String databaseName,
Collection<RuleConfiguration> ruleConfigs);
+
+ /**
+ * Alter rule configuration.
+ *
+ * @param databaseName database name
+ * @param toBeAlteredRuleConfig to be altered rule config
+ * @return meta data versions
+ */
+ Collection<MetaDataVersion> alterRuleConfiguration(String databaseName,
RuleConfiguration toBeAlteredRuleConfig);
+
+ /**
+ * Remove rule configuration item.
+ *
+ * @param databaseName database name
+ * @param toBeRemovedRuleConfig to be removed rule config
+ */
+ void removeRuleConfigurationItem(String databaseName, RuleConfiguration
toBeRemovedRuleConfig);
+
+ /**
+ * Remove rule configuration.
+ *
+ * @param databaseName database name
+ * @param ruleName rule name
+ */
+ void removeRuleConfiguration(String databaseName, String ruleName);
+
+ /**
+ * Alter global rule configuration.
+ *
+ * @param globalRuleConfig global rule config
+ */
+ void alterGlobalRuleConfiguration(RuleConfiguration globalRuleConfig);
+
+ /**
+ * Alter properties.
+ *
+ * @param props pros
+ */
+ void alterProperties(Properties props);
+}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/service/PersistServiceFacade.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/service/MetaDataManagerPersistServiceBuilder.java
similarity index 59%
copy from
mode/core/src/main/java/org/apache/shardingsphere/mode/service/PersistServiceFacade.java
copy to
mode/core/src/main/java/org/apache/shardingsphere/mode/service/MetaDataManagerPersistServiceBuilder.java
index e6642d5c1c5..9fe6bc5b63b 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/service/PersistServiceFacade.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/service/MetaDataManagerPersistServiceBuilder.java
@@ -17,22 +17,19 @@
package org.apache.shardingsphere.mode.service;
-import lombok.Getter;
-import org.apache.shardingsphere.mode.spi.PersistRepository;
-import org.apache.shardingsphere.mode.state.StatePersistService;
+import org.apache.shardingsphere.infra.spi.type.typed.TypedSPI;
+import org.apache.shardingsphere.mode.manager.ContextManager;
/**
- * Persist service facade.
+ * Meta data manager persist service builder.
*/
-@Getter
-public final class PersistServiceFacade {
+public interface MetaDataManagerPersistServiceBuilder extends TypedSPI {
- private final ComputeNodePersistService computeNodePersistService;
-
- private final StatePersistService statePersistService;
-
- public PersistServiceFacade(final PersistRepository repository) {
- computeNodePersistService = new ComputeNodePersistService(repository);
- statePersistService = new StatePersistService(repository);
- }
+ /**
+ * Build meta data manager persist service.
+ *
+ * @param contextManager context manager
+ * @return meta data manager persist service
+ */
+ MetaDataManagerPersistService build(ContextManager contextManager);
}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/service/PersistServiceFacade.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/service/PersistServiceFacade.java
index e6642d5c1c5..de646661a22 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/service/PersistServiceFacade.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/service/PersistServiceFacade.java
@@ -18,6 +18,9 @@
package org.apache.shardingsphere.mode.service;
import lombok.Getter;
+import org.apache.shardingsphere.infra.config.mode.ModeConfiguration;
+import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
+import org.apache.shardingsphere.mode.manager.ContextManager;
import org.apache.shardingsphere.mode.spi.PersistRepository;
import org.apache.shardingsphere.mode.state.StatePersistService;
@@ -31,8 +34,11 @@ public final class PersistServiceFacade {
private final StatePersistService statePersistService;
- public PersistServiceFacade(final PersistRepository repository) {
+ private final MetaDataManagerPersistService metaDataManagerPersistService;
+
+ public PersistServiceFacade(final PersistRepository repository, final
ModeConfiguration modeConfiguration, final ContextManager contextManager) {
computeNodePersistService = new ComputeNodePersistService(repository);
statePersistService = new StatePersistService(repository);
+ metaDataManagerPersistService =
TypedSPILoader.getService(MetaDataManagerPersistServiceBuilder.class,
modeConfiguration.getType()).build(contextManager);
}
}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/service/PersistServiceFacade.java
b/mode/core/src/test/java/org/apache/shardingsphere/mode/fixture/MetaDataManagerPersistServiceBuilderFixture.java
similarity index 55%
copy from
mode/core/src/main/java/org/apache/shardingsphere/mode/service/PersistServiceFacade.java
copy to
mode/core/src/test/java/org/apache/shardingsphere/mode/fixture/MetaDataManagerPersistServiceBuilderFixture.java
index e6642d5c1c5..691a9e620d2 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/service/PersistServiceFacade.java
+++
b/mode/core/src/test/java/org/apache/shardingsphere/mode/fixture/MetaDataManagerPersistServiceBuilderFixture.java
@@ -15,24 +15,26 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.mode.service;
+package org.apache.shardingsphere.mode.fixture;
-import lombok.Getter;
-import org.apache.shardingsphere.mode.spi.PersistRepository;
-import org.apache.shardingsphere.mode.state.StatePersistService;
+import org.apache.shardingsphere.mode.manager.ContextManager;
+import org.apache.shardingsphere.mode.service.MetaDataManagerPersistService;
+import
org.apache.shardingsphere.mode.service.MetaDataManagerPersistServiceBuilder;
-/**
- * Persist service facade.
- */
-@Getter
-public final class PersistServiceFacade {
+public final class MetaDataManagerPersistServiceBuilderFixture implements
MetaDataManagerPersistServiceBuilder {
- private final ComputeNodePersistService computeNodePersistService;
+ @Override
+ public MetaDataManagerPersistService build(final ContextManager
contextManager) {
+ return null;
+ }
- private final StatePersistService statePersistService;
+ @Override
+ public Object getType() {
+ return "foo_type";
+ }
- public PersistServiceFacade(final PersistRepository repository) {
- computeNodePersistService = new ComputeNodePersistService(repository);
- statePersistService = new StatePersistService(repository);
+ @Override
+ public boolean isDefault() {
+ return true;
}
}
diff --git
a/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
b/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
index e2bcdd6f86d..b0e80fe3341 100644
---
a/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
+++
b/mode/core/src/test/java/org/apache/shardingsphere/mode/manager/ContextManagerTest.java
@@ -17,6 +17,7 @@
package org.apache.shardingsphere.mode.manager;
+import org.apache.shardingsphere.infra.config.mode.ModeConfiguration;
import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
import org.apache.shardingsphere.infra.config.props.ConfigurationPropertyKey;
import org.apache.shardingsphere.infra.database.core.DefaultDatabase;
@@ -26,7 +27,6 @@ import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePo
import
org.apache.shardingsphere.infra.exception.dialect.exception.syntax.database.NoDatabaseSelectedException;
import
org.apache.shardingsphere.infra.exception.dialect.exception.syntax.database.UnknownDatabaseException;
import org.apache.shardingsphere.infra.instance.ComputeNodeInstanceContext;
-import org.apache.shardingsphere.infra.instance.mode.ModeContextManager;
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;
@@ -88,7 +88,7 @@ class ContextManagerTest {
when(metaDataContexts.getMetaData().getDatabase("foo_db").containsSchema("foo_schema")).thenReturn(true);
when(metaDataContexts.getMetaData().getDatabases().values()).thenReturn(Collections.singleton(database));
ComputeNodeInstanceContext computeNodeInstanceContext =
mock(ComputeNodeInstanceContext.class);
-
when(computeNodeInstanceContext.getModeContextManager()).thenReturn(mock(ModeContextManager.class));
+
when(computeNodeInstanceContext.getModeConfiguration()).thenReturn(mock(ModeConfiguration.class));
contextManager = new ContextManager(metaDataContexts,
computeNodeInstanceContext);
}
diff --git
a/mode/core/src/test/resources/META-INF/services/org.apache.shardingsphere.mode.service.MetaDataManagerPersistServiceBuilder
b/mode/core/src/test/resources/META-INF/services/org.apache.shardingsphere.mode.service.MetaDataManagerPersistServiceBuilder
new file mode 100644
index 00000000000..02002f9acbe
--- /dev/null
+++
b/mode/core/src/test/resources/META-INF/services/org.apache.shardingsphere.mode.service.MetaDataManagerPersistServiceBuilder
@@ -0,0 +1,18 @@
+#
+# 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.
+#
+
+org.apache.shardingsphere.mode.fixture.MetaDataManagerPersistServiceBuilderFixture
diff --git
a/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/service/ClusterMetaDataManagerPersistService.java
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/service/ClusterMetaDataManagerPersistService.java
new file mode 100644
index 00000000000..eaddbaa3870
--- /dev/null
+++
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/service/ClusterMetaDataManagerPersistService.java
@@ -0,0 +1,158 @@
+/*
+ * 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.manager.cluster.service;
+
+import lombok.RequiredArgsConstructor;
+import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
+import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
+import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
+import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereTable;
+import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereView;
+import
org.apache.shardingsphere.infra.metadata.database.schema.pojo.AlterSchemaMetaDataPOJO;
+import
org.apache.shardingsphere.infra.metadata.database.schema.pojo.AlterSchemaPOJO;
+import org.apache.shardingsphere.infra.metadata.version.MetaDataVersion;
+import
org.apache.shardingsphere.metadata.persist.service.config.database.DatabaseBasedPersistService;
+import
org.apache.shardingsphere.metadata.persist.service.database.DatabaseMetaDataPersistService;
+import org.apache.shardingsphere.mode.manager.ContextManager;
+import org.apache.shardingsphere.mode.service.MetaDataManagerPersistService;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Properties;
+import java.util.stream.Collectors;
+
+/**
+ * Cluster meta data manager persist service.
+ */
+@RequiredArgsConstructor
+public final class ClusterMetaDataManagerPersistService implements
MetaDataManagerPersistService {
+
+ private final ContextManager contextManager;
+
+ @Override
+ public void createDatabase(final String databaseName) {
+
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService().addDatabase(databaseName);
+ }
+
+ @Override
+ public void dropDatabase(final String databaseName) {
+
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService().dropDatabase(databaseName);
+ }
+
+ @Override
+ public void createSchema(final String databaseName, final String
schemaName) {
+
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService().addSchema(databaseName,
schemaName);
+ }
+
+ @Override
+ public void alterSchema(final AlterSchemaPOJO alterSchemaPOJO) {
+ String databaseName = alterSchemaPOJO.getDatabaseName();
+ String schemaName = alterSchemaPOJO.getSchemaName();
+ ShardingSphereSchema schema =
contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getSchema(schemaName);
+ DatabaseMetaDataPersistService databaseMetaDataService =
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService();
+ databaseMetaDataService.persistByAlterConfiguration(databaseName,
alterSchemaPOJO.getRenameSchemaName(), schema);
+
databaseMetaDataService.getViewMetaDataPersistService().persist(databaseName,
alterSchemaPOJO.getRenameSchemaName(), schema.getViews());
+ databaseMetaDataService.dropSchema(databaseName, schemaName);
+ }
+
+ @Override
+ public void dropSchema(final String databaseName, final Collection<String>
schemaNames) {
+ DatabaseMetaDataPersistService databaseMetaDataService =
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService();
+ schemaNames.forEach(each ->
databaseMetaDataService.dropSchema(databaseName, each));
+ }
+
+ @Override
+ public void alterSchemaMetaData(final AlterSchemaMetaDataPOJO
alterSchemaMetaDataPOJO) {
+ String databaseName = alterSchemaMetaDataPOJO.getDatabaseName();
+ String schemaName = alterSchemaMetaDataPOJO.getSchemaName();
+ Map<String, ShardingSphereTable> tables =
alterSchemaMetaDataPOJO.getAlteredTables().stream().collect(Collectors.toMap(ShardingSphereTable::getName,
table -> table));
+ Map<String, ShardingSphereView> views =
alterSchemaMetaDataPOJO.getAlteredViews().stream().collect(Collectors.toMap(ShardingSphereView::getName,
view -> view));
+ DatabaseMetaDataPersistService databaseMetaDataService =
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService();
+
databaseMetaDataService.getTableMetaDataPersistService().persist(databaseName,
schemaName, tables);
+
databaseMetaDataService.getViewMetaDataPersistService().persist(databaseName,
schemaName, views);
+ alterSchemaMetaDataPOJO.getDroppedTables().forEach(each ->
databaseMetaDataService.getTableMetaDataPersistService().delete(databaseName,
schemaName, each));
+ alterSchemaMetaDataPOJO.getDroppedViews().forEach(each ->
databaseMetaDataService.getViewMetaDataPersistService().delete(databaseName,
schemaName, each));
+ }
+
+ @Override
+ public void registerStorageUnits(final String databaseName, final
Map<String, DataSourcePoolProperties> toBeRegisteredProps) {
+
contextManager.getMetaDataContexts().getPersistService().getDataSourceUnitService().persistConfigurations(databaseName,
toBeRegisteredProps);
+ }
+
+ @Override
+ public void alterStorageUnits(final String databaseName, final Map<String,
DataSourcePoolProperties> toBeUpdatedProps) {
+ DatabaseBasedPersistService<Map<String, DataSourcePoolProperties>>
dataSourceService =
contextManager.getMetaDataContexts().getPersistService().getDataSourceUnitService();
+
contextManager.getMetaDataContexts().getPersistService().getMetaDataVersionPersistService().switchActiveVersion(dataSourceService.persistConfigurations(databaseName,
toBeUpdatedProps));
+ }
+
+ @Override
+ public void unregisterStorageUnits(final String databaseName, final
Collection<String> toBeDroppedStorageUnitNames) {
+
contextManager.getMetaDataContexts().getPersistService().getDataSourceUnitService().deleteConfigurations(databaseName,
+
getToBeDroppedDataSourcePoolProperties(contextManager.getMetaDataContexts().getPersistService().getDataSourceUnitService().load(databaseName),
toBeDroppedStorageUnitNames));
+ }
+
+ private Map<String, DataSourcePoolProperties>
getToBeDroppedDataSourcePoolProperties(final Map<String,
DataSourcePoolProperties> propsMap, final Collection<String>
toBeDroppedResourceNames) {
+ Map<String, DataSourcePoolProperties> result = new
LinkedHashMap<>(toBeDroppedResourceNames.size(), 1F);
+ for (String each : toBeDroppedResourceNames) {
+ if (propsMap.containsKey(each)) {
+ result.put(each, propsMap.get(each));
+ }
+ }
+ return result;
+ }
+
+ @Override
+ public void alterSingleRuleConfiguration(final String databaseName, final
Collection<RuleConfiguration> ruleConfigs) {
+ ruleConfigs.removeIf(each ->
!each.getClass().isAssignableFrom(SingleRuleConfiguration.class));
+
contextManager.getMetaDataContexts().getPersistService().getMetaDataVersionPersistService()
+
.switchActiveVersion(contextManager.getMetaDataContexts().getPersistService().getDatabaseRulePersistService().persistConfigurations(databaseName,
ruleConfigs));
+ }
+
+ @Override
+ public Collection<MetaDataVersion> alterRuleConfiguration(final String
databaseName, final RuleConfiguration toBeAlteredRuleConfig) {
+ if (null != toBeAlteredRuleConfig) {
+ return
contextManager.getMetaDataContexts().getPersistService().getDatabaseRulePersistService().persistConfigurations(databaseName,
Collections.singleton(toBeAlteredRuleConfig));
+ }
+ return Collections.emptyList();
+ }
+
+ @Override
+ public void removeRuleConfigurationItem(final String databaseName, final
RuleConfiguration toBeRemovedRuleConfig) {
+ if (null != toBeRemovedRuleConfig) {
+
contextManager.getMetaDataContexts().getPersistService().getDatabaseRulePersistService().deleteConfigurations(databaseName,
Collections.singleton(toBeRemovedRuleConfig));
+ }
+ }
+
+ @Override
+ public void removeRuleConfiguration(final String databaseName, final
String ruleName) {
+
contextManager.getMetaDataContexts().getPersistService().getDatabaseRulePersistService().delete(databaseName,
ruleName);
+ }
+
+ @Override
+ public void alterGlobalRuleConfiguration(final RuleConfiguration
toBeAlteredRuleConfig) {
+
contextManager.getMetaDataContexts().getPersistService().getGlobalRuleService().persist(Collections.singleton(toBeAlteredRuleConfig));
+ }
+
+ @Override
+ public void alterProperties(final Properties props) {
+
contextManager.getMetaDataContexts().getPersistService().getPropsService().persist(props);
+ }
+}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/service/PersistServiceFacade.java
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/service/ClusterMetaDataManagerPersistServiceBuilder.java
similarity index 54%
copy from
mode/core/src/main/java/org/apache/shardingsphere/mode/service/PersistServiceFacade.java
copy to
mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/service/ClusterMetaDataManagerPersistServiceBuilder.java
index e6642d5c1c5..1f5eb8a41d2 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/service/PersistServiceFacade.java
+++
b/mode/type/cluster/core/src/main/java/org/apache/shardingsphere/mode/manager/cluster/service/ClusterMetaDataManagerPersistServiceBuilder.java
@@ -15,24 +15,24 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.mode.service;
+package org.apache.shardingsphere.mode.manager.cluster.service;
-import lombok.Getter;
-import org.apache.shardingsphere.mode.spi.PersistRepository;
-import org.apache.shardingsphere.mode.state.StatePersistService;
+import org.apache.shardingsphere.mode.manager.ContextManager;
+import org.apache.shardingsphere.mode.service.MetaDataManagerPersistService;
+import
org.apache.shardingsphere.mode.service.MetaDataManagerPersistServiceBuilder;
/**
- * Persist service facade.
+ * Cluster meta data manager persist service builder.
*/
-@Getter
-public final class PersistServiceFacade {
+public final class ClusterMetaDataManagerPersistServiceBuilder implements
MetaDataManagerPersistServiceBuilder {
- private final ComputeNodePersistService computeNodePersistService;
-
- private final StatePersistService statePersistService;
+ @Override
+ public MetaDataManagerPersistService build(final ContextManager
contextManager) {
+ return new ClusterMetaDataManagerPersistService(contextManager);
+ }
- public PersistServiceFacade(final PersistRepository repository) {
- computeNodePersistService = new ComputeNodePersistService(repository);
- statePersistService = new StatePersistService(repository);
+ @Override
+ public Object getType() {
+ return "Cluster";
}
}
diff --git
a/mode/type/cluster/core/src/main/resources/META-INF/services/org.apache.shardingsphere.mode.service.MetaDataManagerPersistServiceBuilder
b/mode/type/cluster/core/src/main/resources/META-INF/services/org.apache.shardingsphere.mode.service.MetaDataManagerPersistServiceBuilder
new file mode 100644
index 00000000000..9e31a2d93c2
--- /dev/null
+++
b/mode/type/cluster/core/src/main/resources/META-INF/services/org.apache.shardingsphere.mode.service.MetaDataManagerPersistServiceBuilder
@@ -0,0 +1,18 @@
+#
+# 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.
+#
+
+org.apache.shardingsphere.mode.manager.cluster.service.ClusterMetaDataManagerPersistServiceBuilder
diff --git
a/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/service/StandaloneMetaDataManagerPersistService.java
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/service/StandaloneMetaDataManagerPersistService.java
new file mode 100644
index 00000000000..dbe5b0d5d18
--- /dev/null
+++
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/service/StandaloneMetaDataManagerPersistService.java
@@ -0,0 +1,322 @@
+/*
+ * 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.manager.standalone.service;
+
+import com.google.common.base.Strings;
+import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
+import
org.apache.shardingsphere.infra.connection.refresher.util.TableRefreshUtils;
+import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
+import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
+import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
+import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
+import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereTable;
+import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereView;
+import
org.apache.shardingsphere.infra.metadata.database.schema.pojo.AlterSchemaMetaDataPOJO;
+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.infra.rule.scope.GlobalRule;
+import
org.apache.shardingsphere.infra.rule.scope.GlobalRule.GlobalRuleChangedType;
+import
org.apache.shardingsphere.infra.spi.type.ordered.cache.OrderedServicesCache;
+import
org.apache.shardingsphere.metadata.persist.service.config.database.DatabaseBasedPersistService;
+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.manager.ContextManager;
+import org.apache.shardingsphere.mode.manager.switcher.ResourceSwitchManager;
+import org.apache.shardingsphere.mode.manager.switcher.SwitchingResource;
+import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
+import
org.apache.shardingsphere.mode.metadata.builder.RuleConfigurationEventBuilder;
+import org.apache.shardingsphere.mode.service.MetaDataManagerPersistService;
+import org.apache.shardingsphere.single.api.config.SingleRuleConfiguration;
+
+import java.sql.SQLException;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+import java.util.Properties;
+import java.util.stream.Collectors;
+
+/**
+ * Standalone meta data manager persist service.
+ */
+public final class StandaloneMetaDataManagerPersistService implements
MetaDataManagerPersistService {
+
+ private final RuleConfigurationEventBuilder ruleConfigurationEventBuilder
= new RuleConfigurationEventBuilder();
+
+ private final ContextManager contextManager;
+
+ public StandaloneMetaDataManagerPersistService(final ContextManager
contextManager) {
+ this.contextManager = contextManager;
+ }
+
+ @Override
+ public void createDatabase(final String databaseName) {
+
contextManager.getResourceMetaDataContextManager().addDatabase(databaseName);
+
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService().addDatabase(databaseName);
+ clearServiceCache();
+ }
+
+ @Override
+ public void dropDatabase(final String databaseName) {
+
contextManager.getResourceMetaDataContextManager().dropDatabase(databaseName);
+
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService().dropDatabase(databaseName);
+ clearServiceCache();
+ }
+
+ @Override
+ public void createSchema(final String databaseName, final String
schemaName) {
+ ShardingSphereSchema schema = new ShardingSphereSchema();
+ ShardingSphereMetaData metaData =
contextManager.getMetaDataContexts().getMetaData();
+ ShardingSphereDatabase database = metaData.getDatabase(databaseName);
+ database.addSchema(schemaName, schema);
+ metaData.getGlobalRuleMetaData().getRules().forEach(each ->
((GlobalRule) each).refresh(metaData.getDatabases(),
GlobalRuleChangedType.SCHEMA_CHANGED));
+
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService().persistByAlterConfiguration(databaseName,
schemaName, schema);
+ }
+
+ @Override
+ public void alterSchema(final AlterSchemaPOJO alterSchemaPOJO) {
+ ShardingSphereMetaData metaData =
contextManager.getMetaDataContexts().getMetaData();
+ ShardingSphereDatabase database =
metaData.getDatabase(alterSchemaPOJO.getDatabaseName());
+ putSchemaMetaData(database, alterSchemaPOJO.getSchemaName(),
alterSchemaPOJO.getRenameSchemaName(),
alterSchemaPOJO.getLogicDataSourceName());
+ removeSchemaMetaData(database, alterSchemaPOJO.getSchemaName());
+ metaData.getGlobalRuleMetaData().getRules().forEach(each ->
((GlobalRule) each).refresh(metaData.getDatabases(),
GlobalRuleChangedType.SCHEMA_CHANGED));
+ DatabaseMetaDataPersistService databaseMetaDataService =
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService();
+
databaseMetaDataService.persistByAlterConfiguration(alterSchemaPOJO.getDatabaseName(),
alterSchemaPOJO.getRenameSchemaName(),
database.getSchema(alterSchemaPOJO.getRenameSchemaName()));
+
databaseMetaDataService.getViewMetaDataPersistService().persist(alterSchemaPOJO.getDatabaseName(),
alterSchemaPOJO.getRenameSchemaName(),
+
database.getSchema(alterSchemaPOJO.getRenameSchemaName()).getViews());
+ databaseMetaDataService.dropSchema(alterSchemaPOJO.getDatabaseName(),
alterSchemaPOJO.getSchemaName());
+ }
+
+ private void putSchemaMetaData(final ShardingSphereDatabase database,
final String schemaName, final String renameSchemaName, final String
logicDataSourceName) {
+ ShardingSphereSchema schema = database.getSchema(schemaName);
+ database.addSchema(renameSchemaName, schema);
+ addDataNode(database, logicDataSourceName, schemaName,
schema.getAllTableNames());
+ }
+
+ private void addDataNode(final ShardingSphereDatabase database, final
String logicDataSourceName, final String schemaName, final Collection<String>
tobeAddedTableNames) {
+ tobeAddedTableNames.forEach(each -> {
+ if (!Strings.isNullOrEmpty(logicDataSourceName) &&
TableRefreshUtils.isSingleTable(each, database)) {
+
database.getRuleMetaData().getAttributes(MutableDataNodeRuleAttribute.class).forEach(rule
-> rule.put(logicDataSourceName, schemaName, each));
+ }
+ });
+ }
+
+ private void addDataNode(final ShardingSphereDatabase database, final
String logicDataSourceName, final String schemaName, final Map<String,
ShardingSphereTable> toBeAddedTables,
+ final Map<String, ShardingSphereView>
toBeAddedViews) {
+ addTablesToDataNode(database, schemaName, logicDataSourceName,
toBeAddedTables);
+ addViewsToDataNode(database, schemaName, logicDataSourceName,
toBeAddedTables, toBeAddedViews);
+ }
+
+ private void addTablesToDataNode(final ShardingSphereDatabase database,
final String schemaName, final String logicDataSourceName, final Map<String,
ShardingSphereTable> toBeAddedTables) {
+ for (Entry<String, ShardingSphereTable> entry :
toBeAddedTables.entrySet()) {
+ if (!Strings.isNullOrEmpty(logicDataSourceName) &&
TableRefreshUtils.isSingleTable(entry.getKey(), database)) {
+
database.getRuleMetaData().getAttributes(MutableDataNodeRuleAttribute.class).forEach(rule
-> rule.put(logicDataSourceName, schemaName, entry.getKey()));
+ }
+ database.getSchema(schemaName).putTable(entry.getKey(),
entry.getValue());
+ }
+ }
+
+ private void addViewsToDataNode(final ShardingSphereDatabase database,
final String schemaName, final String logicDataSourceName,
+ final Map<String, ShardingSphereTable>
toBeAddedTables, final Map<String, ShardingSphereView> toBeAddedViews) {
+ for (Entry<String, ShardingSphereView> entry :
toBeAddedViews.entrySet()) {
+ if (!Strings.isNullOrEmpty(logicDataSourceName) &&
TableRefreshUtils.isSingleTable(entry.getKey(), database)) {
+
database.getRuleMetaData().getAttributes(MutableDataNodeRuleAttribute.class).forEach(each
-> each.put(logicDataSourceName, schemaName, entry.getKey()));
+ }
+ database.getSchema(schemaName).putTable(entry.getKey(),
toBeAddedTables.get(entry.getKey().toLowerCase()));
+ database.getSchema(schemaName).putView(entry.getKey(),
entry.getValue());
+ }
+ }
+
+ private void removeSchemaMetaData(final ShardingSphereDatabase database,
final String schemaName) {
+ ShardingSphereSchema schema = new
ShardingSphereSchema(database.getSchema(schemaName).getTables(),
database.getSchema(schemaName).getViews());
+ database.dropSchema(schemaName);
+
removeDataNode(database.getRuleMetaData().getAttributes(MutableDataNodeRuleAttribute.class),
Collections.singletonList(schemaName), schema.getAllTableNames());
+ }
+
+ private void removeDataNode(final Collection<MutableDataNodeRuleAttribute>
ruleAttributes, final Collection<String> schemaNames, final Collection<String>
tobeRemovedTables) {
+ tobeRemovedTables.forEach(each -> ruleAttributes.forEach(rule ->
rule.remove(schemaNames, each)));
+ }
+
+ private void removeDataNode(final ShardingSphereDatabase database, final
String schemaName, final Collection<String> tobeRemovedTables, final
Collection<String> tobeRemovedViews) {
+ removeTablesToDataNode(database, schemaName, tobeRemovedTables);
+ removeViewsToDataNode(database, schemaName, tobeRemovedTables,
tobeRemovedViews);
+ }
+
+ private void removeDataNode(final Collection<MutableDataNodeRuleAttribute>
ruleAttributes, final String schemaName, final Collection<String>
tobeRemovedTables) {
+ tobeRemovedTables.forEach(each -> ruleAttributes.forEach(rule ->
rule.remove(schemaName, each)));
+ }
+
+ private void removeTablesToDataNode(final ShardingSphereDatabase database,
final String schemaName, final Collection<String> toBeDroppedTables) {
+
removeDataNode(database.getRuleMetaData().getAttributes(MutableDataNodeRuleAttribute.class),
schemaName, toBeDroppedTables);
+ toBeDroppedTables.forEach(each ->
database.getSchema(schemaName).removeTable(each));
+ }
+
+ private void removeViewsToDataNode(final ShardingSphereDatabase database,
final String schemaName, final Collection<String> toBeDroppedTables, final
Collection<String> toBeDroppedViews) {
+
removeDataNode(database.getRuleMetaData().getAttributes(MutableDataNodeRuleAttribute.class),
schemaName, toBeDroppedViews);
+ ShardingSphereSchema schema = database.getSchema(schemaName);
+ toBeDroppedTables.forEach(schema::removeTable);
+ toBeDroppedViews.forEach(schema::removeView);
+ }
+
+ @Override
+ public void dropSchema(final String databaseName, final Collection<String>
schemaNames) {
+ Collection<String> tobeRemovedTables = new LinkedHashSet<>();
+ Collection<String> tobeRemovedSchemas = new
LinkedHashSet<>(schemaNames.size(), 1F);
+ ShardingSphereMetaData metaData =
contextManager.getMetaDataContexts().getMetaData();
+ ShardingSphereDatabase database = metaData.getDatabase(databaseName);
+ for (String each : schemaNames) {
+ ShardingSphereSchema schema = new
ShardingSphereSchema(database.getSchema(each).getTables(),
database.getSchema(each).getViews());
+ database.dropSchema(each);
+ Optional.of(schema).ifPresent(optional ->
tobeRemovedTables.addAll(optional.getAllTableNames()));
+ tobeRemovedSchemas.add(each.toLowerCase());
+ }
+
removeDataNode(database.getRuleMetaData().getAttributes(MutableDataNodeRuleAttribute.class),
tobeRemovedSchemas, tobeRemovedTables);
+ metaData.getGlobalRuleMetaData().getRules().forEach(each ->
((GlobalRule) each).refresh(metaData.getDatabases(),
GlobalRuleChangedType.SCHEMA_CHANGED));
+ }
+
+ @Override
+ public void alterSchemaMetaData(final AlterSchemaMetaDataPOJO
alterSchemaMetaDataPOJO) {
+ String databaseName = alterSchemaMetaDataPOJO.getDatabaseName();
+ String schemaName = alterSchemaMetaDataPOJO.getSchemaName();
+ ShardingSphereMetaData metaData =
contextManager.getMetaDataContexts().getMetaData();
+ ShardingSphereDatabase database = metaData.getDatabase(databaseName);
+ Map<String, ShardingSphereTable> tables =
alterSchemaMetaDataPOJO.getAlteredTables().stream().collect(Collectors.toMap(ShardingSphereTable::getName,
table -> table));
+ Map<String, ShardingSphereView> views =
alterSchemaMetaDataPOJO.getAlteredViews().stream().collect(Collectors.toMap(ShardingSphereView::getName,
view -> view));
+ addDataNode(database,
alterSchemaMetaDataPOJO.getLogicDataSourceName(), schemaName, tables, views);
+ removeDataNode(database, schemaName,
alterSchemaMetaDataPOJO.getDroppedTables(),
alterSchemaMetaDataPOJO.getDroppedViews());
+ metaData.getGlobalRuleMetaData().getRules().forEach(each ->
((GlobalRule) each).refresh(metaData.getDatabases(),
GlobalRuleChangedType.SCHEMA_CHANGED));
+ DatabaseMetaDataPersistService databaseMetaDataService =
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService();
+
databaseMetaDataService.getTableMetaDataPersistService().persist(databaseName,
schemaName, tables);
+
databaseMetaDataService.getViewMetaDataPersistService().persist(databaseName,
schemaName, views);
+ alterSchemaMetaDataPOJO.getDroppedTables().forEach(each ->
databaseMetaDataService.getTableMetaDataPersistService().delete(databaseName,
schemaName, each));
+ alterSchemaMetaDataPOJO.getDroppedViews().forEach(each ->
databaseMetaDataService.getViewMetaDataPersistService().delete(databaseName,
schemaName, each));
+ }
+
+ @Override
+ public void registerStorageUnits(final String databaseName, final
Map<String, DataSourcePoolProperties> toBeRegisteredProps) throws SQLException {
+ SwitchingResource switchingResource =
+ new
ResourceSwitchManager().registerStorageUnit(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getResourceMetaData(),
toBeRegisteredProps);
+
contextManager.getMetaDataContexts().getMetaData().getDatabases().putAll(contextManager.getConfigurationContextManager().createChangedDatabases(databaseName,
false, switchingResource, null));
+
contextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData().getRules()
+ .forEach(each -> ((GlobalRule)
each).refresh(contextManager.getMetaDataContexts().getMetaData().getDatabases(),
GlobalRuleChangedType.DATABASE_CHANGED));
+
contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getSchemas()
+ .forEach((schemaName, schema) ->
contextManager.getMetaDataContexts().getPersistService().getDatabaseMetaDataService()
+
.persistByAlterConfiguration(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getName(),
schemaName, schema));
+ DatabaseBasedPersistService<Map<String, DataSourcePoolProperties>>
dataSourceService =
contextManager.getMetaDataContexts().getPersistService().getDataSourceUnitService();
+
contextManager.getMetaDataContexts().getPersistService().getMetaDataVersionPersistService().switchActiveVersion(dataSourceService.persistConfigurations(databaseName,
toBeRegisteredProps));
+ clearServiceCache();
+ }
+
+ @Override
+ public void alterStorageUnits(final String databaseName, final Map<String,
DataSourcePoolProperties> toBeUpdatedProps) throws SQLException {
+ SwitchingResource switchingResource =
+ new
ResourceSwitchManager().alterStorageUnit(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getResourceMetaData(),
toBeUpdatedProps);
+
contextManager.getMetaDataContexts().getMetaData().getDatabases().putAll(contextManager.getConfigurationContextManager().createChangedDatabases(databaseName,
true, switchingResource, null));
+
contextManager.getMetaDataContexts().getMetaData().getGlobalRuleMetaData().getRules()
+ .forEach(each -> ((GlobalRule)
each).refresh(contextManager.getMetaDataContexts().getMetaData().getDatabases(),
GlobalRuleChangedType.DATABASE_CHANGED));
+ DatabaseBasedPersistService<Map<String, DataSourcePoolProperties>>
dataSourceService =
contextManager.getMetaDataContexts().getPersistService().getDataSourceUnitService();
+
contextManager.getMetaDataContexts().getPersistService().getMetaDataVersionPersistService().switchActiveVersion(dataSourceService.persistConfigurations(databaseName,
toBeUpdatedProps));
+ switchingResource.closeStaleDataSources();
+ clearServiceCache();
+ }
+
+ @Override
+ public void unregisterStorageUnits(final String databaseName, final
Collection<String> toBeDroppedStorageUnitNames) throws SQLException {
+ SwitchingResource switchingResource =
+ new
ResourceSwitchManager().unregisterStorageUnit(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getResourceMetaData(),
toBeDroppedStorageUnitNames);
+ contextManager.getMetaDataContexts().getMetaData().getDatabases()
+
.putAll(contextManager.getConfigurationContextManager().renewDatabase(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName),
switchingResource));
+ MetaDataContexts reloadMetaDataContexts =
contextManager.getConfigurationContextManager().createMetaDataContexts(databaseName,
false, switchingResource, null);
+
contextManager.getConfigurationContextManager().alterSchemaMetaData(databaseName,
reloadMetaDataContexts.getMetaData().getDatabase(databaseName),
+
contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName),
true);
+ contextManager.deletedSchemaNames(databaseName,
reloadMetaDataContexts.getMetaData().getDatabase(databaseName),
contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName));
+ contextManager.renewMetaDataContexts(reloadMetaDataContexts);
+ switchingResource.closeStaleDataSources();
+ clearServiceCache();
+ }
+
+ @Override
+ public void alterSingleRuleConfiguration(final String databaseName, final
Collection<RuleConfiguration> ruleConfigs) {
+ ruleConfigs.removeIf(each ->
!each.getClass().isAssignableFrom(SingleRuleConfiguration.class));
+ Collection<MetaDataVersion> metaDataVersions =
contextManager.getMetaDataContexts().getPersistService().getDatabaseRulePersistService()
+
.persistConfigurations(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getName(),
ruleConfigs);
+
contextManager.getMetaDataContexts().getPersistService().getMetaDataVersionPersistService().switchActiveVersion(metaDataVersions);
+
contextManager.getConfigurationContextManager().alterRuleConfiguration(databaseName,
ruleConfigs.iterator().next());
+ clearServiceCache();
+ }
+
+ @Override
+ public Collection<MetaDataVersion> alterRuleConfiguration(final String
databaseName, final RuleConfiguration toBeAlteredRuleConfig) {
+ if (null != toBeAlteredRuleConfig) {
+ Collection<MetaDataVersion> metaDataVersions =
contextManager.getMetaDataContexts().getPersistService().getDatabaseRulePersistService()
+
.persistConfigurations(contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getName(),
Collections.singletonList(toBeAlteredRuleConfig));
+
contextManager.getMetaDataContexts().getPersistService().getMetaDataVersionPersistService().switchActiveVersion(metaDataVersions);
+ sendDatabaseRuleChangedEvent(databaseName, metaDataVersions);
+ clearServiceCache();
+ }
+ return Collections.emptyList();
+ }
+
+ private void sendDatabaseRuleChangedEvent(final String databaseName, final
Collection<MetaDataVersion> metaDataVersions) {
+ for (MetaDataVersion each : metaDataVersions) {
+ sendDatabaseRuleChangedEvent(databaseName, each);
+ }
+ }
+
+ private void sendDatabaseRuleChangedEvent(final String databaseName, final
MetaDataVersion metaDataVersion) {
+ ruleConfigurationEventBuilder.build(databaseName, new
DataChangedEvent(metaDataVersion.getActiveVersionNodePath(),
metaDataVersion.getNextActiveVersion(), Type.UPDATED))
+ .ifPresent(optional ->
contextManager.getComputeNodeInstanceContext().getEventBusContext().post(optional));
+ }
+
+ @Override
+ public void removeRuleConfigurationItem(final String databaseName, final
RuleConfiguration toBeRemovedRuleConfig) {
+ if (null != toBeRemovedRuleConfig) {
+ sendDatabaseRuleChangedEvent(databaseName,
+
contextManager.getMetaDataContexts().getPersistService().getDatabaseRulePersistService().deleteConfigurations(databaseName,
Collections.singleton(toBeRemovedRuleConfig)));
+ clearServiceCache();
+ }
+ }
+
+ @Override
+ public void removeRuleConfiguration(final String databaseName, final
String ruleName) {
+
contextManager.getMetaDataContexts().getPersistService().getDatabaseRulePersistService().delete(databaseName,
ruleName);
+ clearServiceCache();
+ }
+
+ @Override
+ public void alterGlobalRuleConfiguration(final RuleConfiguration
toBeAlteredRuleConfig) {
+
contextManager.getConfigurationContextManager().alterGlobalRuleConfiguration(toBeAlteredRuleConfig);
+
contextManager.getMetaDataContexts().getPersistService().getGlobalRuleService().persist(Collections.singleton(toBeAlteredRuleConfig));
+ clearServiceCache();
+ }
+
+ @Override
+ public void alterProperties(final Properties props) {
+ contextManager.getConfigurationContextManager().alterProperties(props);
+
contextManager.getMetaDataContexts().getPersistService().getPropsService().persist(props);
+ clearServiceCache();
+ }
+
+ private void clearServiceCache() {
+ OrderedServicesCache.clearCache();
+ }
+}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/service/PersistServiceFacade.java
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/service/StandaloneMetaDataManagerPersistServiceBuilder.java
similarity index 51%
copy from
mode/core/src/main/java/org/apache/shardingsphere/mode/service/PersistServiceFacade.java
copy to
mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/service/StandaloneMetaDataManagerPersistServiceBuilder.java
index e6642d5c1c5..c60f8658c39 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/service/PersistServiceFacade.java
+++
b/mode/type/standalone/core/src/main/java/org/apache/shardingsphere/mode/manager/standalone/service/StandaloneMetaDataManagerPersistServiceBuilder.java
@@ -15,24 +15,29 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.mode.service;
+package org.apache.shardingsphere.mode.manager.standalone.service;
-import lombok.Getter;
-import org.apache.shardingsphere.mode.spi.PersistRepository;
-import org.apache.shardingsphere.mode.state.StatePersistService;
+import org.apache.shardingsphere.mode.manager.ContextManager;
+import org.apache.shardingsphere.mode.service.MetaDataManagerPersistService;
+import
org.apache.shardingsphere.mode.service.MetaDataManagerPersistServiceBuilder;
/**
- * Persist service facade.
+ * Standalone meta data manager persist service builder.
*/
-@Getter
-public final class PersistServiceFacade {
+public final class StandaloneMetaDataManagerPersistServiceBuilder implements
MetaDataManagerPersistServiceBuilder {
- private final ComputeNodePersistService computeNodePersistService;
+ @Override
+ public MetaDataManagerPersistService build(final ContextManager
contextManager) {
+ return new StandaloneMetaDataManagerPersistService(contextManager);
+ }
- private final StatePersistService statePersistService;
+ @Override
+ public Object getType() {
+ return "Standalone";
+ }
- public PersistServiceFacade(final PersistRepository repository) {
- computeNodePersistService = new ComputeNodePersistService(repository);
- statePersistService = new StatePersistService(repository);
+ @Override
+ public boolean isDefault() {
+ return true;
}
}
diff --git
a/mode/type/standalone/core/src/main/resources/META-INF/services/org.apache.shardingsphere.mode.service.MetaDataManagerPersistServiceBuilder
b/mode/type/standalone/core/src/main/resources/META-INF/services/org.apache.shardingsphere.mode.service.MetaDataManagerPersistServiceBuilder
new file mode 100644
index 00000000000..3dbb1a3829c
--- /dev/null
+++
b/mode/type/standalone/core/src/main/resources/META-INF/services/org.apache.shardingsphere.mode.service.MetaDataManagerPersistServiceBuilder
@@ -0,0 +1,18 @@
+#
+# 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.
+#
+
+org.apache.shardingsphere.mode.manager.standalone.service.StandaloneMetaDataManagerPersistServiceBuilder
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/ProxyDatabaseConnectionManagerTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/ProxyDatabaseConnectionManagerTest.java
index 61e7fb1bda9..d646d28e20d 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/ProxyDatabaseConnectionManagerTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/ProxyDatabaseConnectionManagerTest.java
@@ -19,6 +19,7 @@ package org.apache.shardingsphere.proxy.backend.connector;
import com.google.common.collect.Multimap;
import lombok.SneakyThrows;
+import org.apache.shardingsphere.infra.config.mode.ModeConfiguration;
import org.apache.shardingsphere.infra.config.props.ConfigurationPropertyKey;
import org.apache.shardingsphere.infra.database.core.DefaultDatabase;
import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
@@ -123,7 +124,9 @@ class ProxyDatabaseConnectionManagerTest {
TransactionRule transactionRule = mock(TransactionRule.class);
when(transactionRule.getDefaultType()).thenReturn(TransactionType.LOCAL);
when(metaData.getGlobalRuleMetaData()).thenReturn(new
RuleMetaData(Collections.singletonList(transactionRule)));
- return new ContextManager(new
MetaDataContexts(mock(MetaDataPersistService.class), metaData),
mock(ComputeNodeInstanceContext.class));
+ ComputeNodeInstanceContext computeNodeInstanceContext =
mock(ComputeNodeInstanceContext.class);
+
when(computeNodeInstanceContext.getModeConfiguration()).thenReturn(mock(ModeConfiguration.class));
+ return new ContextManager(new
MetaDataContexts(mock(MetaDataPersistService.class), metaData),
computeNodeInstanceContext);
}
@AfterEach
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/ProxySQLExecutorTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/ProxySQLExecutorTest.java
index 423f570e372..ff1aca87b97 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/ProxySQLExecutorTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/connector/ProxySQLExecutorTest.java
@@ -23,6 +23,7 @@ import
org.apache.shardingsphere.infra.binder.context.statement.ddl.CursorStatem
import
org.apache.shardingsphere.infra.binder.context.statement.ddl.TruncateStatementContext;
import
org.apache.shardingsphere.infra.binder.context.statement.dml.InsertStatementContext;
import
org.apache.shardingsphere.infra.binder.context.statement.dml.SelectStatementContext;
+import org.apache.shardingsphere.infra.config.mode.ModeConfiguration;
import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
import org.apache.shardingsphere.infra.config.props.ConfigurationPropertyKey;
import org.apache.shardingsphere.infra.database.core.DefaultDatabase;
@@ -108,7 +109,9 @@ class ProxySQLExecutorTest {
when(metaData.getProps().<Integer>getValue(ConfigurationPropertyKey.KERNEL_EXECUTOR_SIZE)).thenReturn(0);
when(transactionRule.getDefaultType()).thenReturn(TransactionType.XA);
when(metaData.getGlobalRuleMetaData()).thenReturn(new
RuleMetaData(Arrays.asList(mock(SQLFederationRule.class), transactionRule)));
- ContextManager contextManager = new ContextManager(new
MetaDataContexts(mock(MetaDataPersistService.class), metaData),
mock(ComputeNodeInstanceContext.class));
+ ComputeNodeInstanceContext computeNodeInstanceContext =
mock(ComputeNodeInstanceContext.class);
+
when(computeNodeInstanceContext.getModeConfiguration()).thenReturn(mock(ModeConfiguration.class));
+ ContextManager contextManager = new ContextManager(new
MetaDataContexts(mock(MetaDataPersistService.class), metaData),
computeNodeInstanceContext);
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
}
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/admin/DatabaseAdminQueryBackendHandlerTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/admin/DatabaseAdminQueryBackendHandlerTest.java
index 4ed563005ff..8be713fff81 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/admin/DatabaseAdminQueryBackendHandlerTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/admin/DatabaseAdminQueryBackendHandlerTest.java
@@ -17,6 +17,7 @@
package org.apache.shardingsphere.proxy.backend.handler.admin;
+import org.apache.shardingsphere.infra.config.mode.ModeConfiguration;
import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import org.apache.shardingsphere.infra.instance.ComputeNodeInstanceContext;
@@ -114,6 +115,8 @@ class DatabaseAdminQueryBackendHandlerTest {
when(ProxyContext.getInstance().getContextManager().getDatabase("foo_db")).thenReturn(database);
ShardingSphereMetaData metaData = new
ShardingSphereMetaData(Collections.singletonMap("foo_db", database),
mock(ResourceMetaData.class),
mock(RuleMetaData.class), new ConfigurationProperties(new
Properties()));
- return new ContextManager(new
MetaDataContexts(mock(MetaDataPersistService.class), metaData),
mock(ComputeNodeInstanceContext.class));
+ ComputeNodeInstanceContext computeNodeInstanceContext =
mock(ComputeNodeInstanceContext.class);
+
when(computeNodeInstanceContext.getModeConfiguration()).thenReturn(mock(ModeConfiguration.class));
+ return new ContextManager(new
MetaDataContexts(mock(MetaDataPersistService.class), metaData),
computeNodeInstanceContext);
}
}
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/QueryableRALBackendHandlerTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/QueryableRALBackendHandlerTest.java
index 97794e2bd02..be67ceb1868 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/QueryableRALBackendHandlerTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/QueryableRALBackendHandlerTest.java
@@ -20,6 +20,7 @@ package
org.apache.shardingsphere.proxy.backend.handler.distsql.ral;
import
org.apache.shardingsphere.distsql.statement.ral.queryable.QueryableRALStatement;
import
org.apache.shardingsphere.distsql.statement.ral.queryable.export.ExportDatabaseConfigurationStatement;
import
org.apache.shardingsphere.distsql.statement.ral.queryable.show.ShowTableMetaDataStatement;
+import org.apache.shardingsphere.infra.config.mode.ModeConfiguration;
import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
import
org.apache.shardingsphere.infra.exception.dialect.exception.syntax.database.NoDatabaseSelectedException;
import
org.apache.shardingsphere.infra.exception.dialect.exception.syntax.database.UnknownDatabaseException;
@@ -71,7 +72,9 @@ class QueryableRALBackendHandlerTest {
MetaDataContexts metaDataContexts = new
MetaDataContexts(mock(MetaDataPersistService.class), metaData);
ConnectionSession connectionSession = mock(ConnectionSession.class,
RETURNS_DEEP_STUBS);
when(connectionSession.getDatabaseName()).thenReturn("unknown");
- ContextManager contextManager = new ContextManager(metaDataContexts,
mock(ComputeNodeInstanceContext.class));
+ ComputeNodeInstanceContext computeNodeInstanceContext =
mock(ComputeNodeInstanceContext.class);
+
when(computeNodeInstanceContext.getModeConfiguration()).thenReturn(mock(ModeConfiguration.class));
+ ContextManager contextManager = new ContextManager(metaDataContexts,
computeNodeInstanceContext);
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
assertThrows(UnknownDatabaseException.class, () -> new
DistSQLQueryBackendHandler(mock(ExportDatabaseConfigurationStatement.class),
connectionSession).execute());
}
diff --git
a/proxy/frontend/core/src/test/java/org/apache/shardingsphere/proxy/frontend/protocol/FrontDatabaseProtocolTypeFactoryTest.java
b/proxy/frontend/core/src/test/java/org/apache/shardingsphere/proxy/frontend/protocol/FrontDatabaseProtocolTypeFactoryTest.java
index beedf6cce0d..f022bfb3bb8 100644
---
a/proxy/frontend/core/src/test/java/org/apache/shardingsphere/proxy/frontend/protocol/FrontDatabaseProtocolTypeFactoryTest.java
+++
b/proxy/frontend/core/src/test/java/org/apache/shardingsphere/proxy/frontend/protocol/FrontDatabaseProtocolTypeFactoryTest.java
@@ -17,6 +17,7 @@
package org.apache.shardingsphere.proxy.frontend.protocol;
+import org.apache.shardingsphere.infra.config.mode.ModeConfiguration;
import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
import org.apache.shardingsphere.infra.config.props.ConfigurationPropertyKey;
import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
@@ -96,6 +97,8 @@ class FrontDatabaseProtocolTypeFactoryTest {
when(metaDataPersistService.getShardingSphereDataPersistService()).thenReturn(shardingSphereDataPersistService);
MetaDataContexts metaDataContexts = new
MetaDataContexts(metaDataPersistService,
new ShardingSphereMetaData(databases,
mock(ResourceMetaData.class), mock(RuleMetaData.class), new
ConfigurationProperties(props)));
- return new ContextManager(metaDataContexts,
mock(ComputeNodeInstanceContext.class));
+ ComputeNodeInstanceContext computeNodeInstanceContext =
mock(ComputeNodeInstanceContext.class);
+
when(computeNodeInstanceContext.getModeConfiguration()).thenReturn(mock(ModeConfiguration.class));
+ return new ContextManager(metaDataContexts,
computeNodeInstanceContext);
}
}
diff --git
a/proxy/frontend/core/src/test/java/org/apache/shardingsphere/proxy/frontend/state/impl/OKProxyStateTest.java
b/proxy/frontend/core/src/test/java/org/apache/shardingsphere/proxy/frontend/state/impl/OKProxyStateTest.java
index da08b4ad95b..0b8b9d494a8 100644
---
a/proxy/frontend/core/src/test/java/org/apache/shardingsphere/proxy/frontend/state/impl/OKProxyStateTest.java
+++
b/proxy/frontend/core/src/test/java/org/apache/shardingsphere/proxy/frontend/state/impl/OKProxyStateTest.java
@@ -20,6 +20,7 @@ package org.apache.shardingsphere.proxy.frontend.state.impl;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.embedded.EmbeddedChannel;
import lombok.SneakyThrows;
+import org.apache.shardingsphere.infra.config.mode.ModeConfiguration;
import org.apache.shardingsphere.infra.config.props.ConfigurationPropertyKey;
import org.apache.shardingsphere.infra.database.core.DefaultDatabase;
import org.apache.shardingsphere.infra.database.core.type.DatabaseType;
@@ -93,7 +94,9 @@ class OKProxyStateTest {
TransactionRule transactionRule = mock(TransactionRule.class);
when(transactionRule.getDefaultType()).thenReturn(TransactionType.XA);
when(metaData.getGlobalRuleMetaData()).thenReturn(new
RuleMetaData(Collections.singletonList(transactionRule)));
- return new ContextManager(new
MetaDataContexts(mock(MetaDataPersistService.class), metaData),
mock(ComputeNodeInstanceContext.class));
+ ComputeNodeInstanceContext computeNodeInstanceContext =
mock(ComputeNodeInstanceContext.class);
+
when(computeNodeInstanceContext.getModeConfiguration()).thenReturn(mock(ModeConfiguration.class));
+ return new ContextManager(new
MetaDataContexts(mock(MetaDataPersistService.class), metaData),
computeNodeInstanceContext);
}
@SuppressWarnings({"unchecked", "SameParameterValue"})
diff --git
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/PostgreSQLCommandExecuteEngineTest.java
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/PostgreSQLCommandExecuteEngineTest.java
index 0774a7a9101..9fe5c6bf8d7 100644
---
a/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/PostgreSQLCommandExecuteEngineTest.java
+++
b/proxy/frontend/type/postgresql/src/test/java/org/apache/shardingsphere/proxy/frontend/postgresql/command/PostgreSQLCommandExecuteEngineTest.java
@@ -22,6 +22,7 @@ import io.netty.channel.ChannelHandlerContext;
import
org.apache.shardingsphere.db.protocol.postgresql.packet.PostgreSQLPacket;
import
org.apache.shardingsphere.db.protocol.postgresql.packet.generic.PostgreSQLCommandCompletePacket;
import
org.apache.shardingsphere.db.protocol.postgresql.packet.generic.PostgreSQLReadyForQueryPacket;
+import org.apache.shardingsphere.infra.config.mode.ModeConfiguration;
import org.apache.shardingsphere.infra.instance.ComputeNodeInstanceContext;
import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
import org.apache.shardingsphere.metadata.persist.MetaDataPersistService;
@@ -119,7 +120,9 @@ class PostgreSQLCommandExecuteEngineTest {
PostgreSQLPacket packet = mock(PostgreSQLPacket.class);
when(queryCommandExecutor.getQueryRowPacket()).thenReturn(packet);
PostgreSQLCommandExecuteEngine commandExecuteEngine = new
PostgreSQLCommandExecuteEngine();
- ContextManager contextManager = new ContextManager(new
MetaDataContexts(mock(MetaDataPersistService.class), new
ShardingSphereMetaData()), mock(ComputeNodeInstanceContext.class));
+ ComputeNodeInstanceContext computeNodeInstanceContext =
mock(ComputeNodeInstanceContext.class);
+
when(computeNodeInstanceContext.getModeConfiguration()).thenReturn(mock(ModeConfiguration.class));
+ ContextManager contextManager = new ContextManager(new
MetaDataContexts(mock(MetaDataPersistService.class), new
ShardingSphereMetaData()), computeNodeInstanceContext);
when(ProxyContext.getInstance().getContextManager()).thenReturn(contextManager);
commandExecuteEngine.writeQueryData(channelHandlerContext,
databaseConnectionManager, queryCommandExecutor, 0);
verify(resourceLock).doAwait(channelHandlerContext);
