This is an automated email from the ASF dual-hosted git repository.
jiangmaolin 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 5006a9f6cb4 Add temporary config key instance-connection-enabled
(#37694)
5006a9f6cb4 is described below
commit 5006a9f6cb4e5e80e81a7310612dbe09796551a5
Author: Raigor <[email protected]>
AuthorDate: Fri Jan 9 17:38:11 2026 +0800
Add temporary config key instance-connection-enabled (#37694)
* Add temporary config key instance-connection-enabled
* Update RELEASE-NOTES.md
* Fix transaction e2e for mysql
---
RELEASE-NOTES.md | 1 +
.../DataSourceGeneratedDatabaseConfiguration.java | 5 +-
.../DataSourceProvidedDatabaseConfiguration.java | 6 +-
.../TemporaryConfigurationPropertyKey.java | 7 ++-
.../database/resource/node/StorageNode.java | 10 +++-
.../resource/node/StorageNodeAggregator.java | 13 ++--
.../database/resource/unit/StorageUnit.java | 6 +-
.../resource/unit/StorageUnitNodeMapCreator.java | 12 ++--
...taSourceGeneratedDatabaseConfigurationTest.java | 2 +-
...ataSourceProvidedDatabaseConfigurationTest.java | 2 +-
.../resource/node/StorageNodeAggregatorTest.java | 6 +-
.../unit/StorageUnitNodeMapCreatorTest.java | 6 +-
.../database/resource/unit/StorageUnitTest.java | 3 -
.../pool/CatalogSwitchableDataSource.java | 2 +-
.../pool/CatalogSwitchableDataSourceTest.java | 69 ++++++++++++++++++++++
.../mode/manager/ContextManager.java | 5 +-
.../metadata/factory/MetaDataContextsFactory.java | 10 ++--
.../RegisterCenterMetaDataContextsInitFactory.java | 25 +++++---
.../manager/resource/ResourceSwitchManager.java | 16 +++--
.../manager/resource/StorageUnitManager.java | 7 ++-
.../mode/manager/ContextManagerTest.java | 7 ++-
.../resource/ResourceSwitchManagerTest.java | 16 ++---
.../manager/resource/StorageUnitManagerTest.java | 19 ++++--
.../swapper/YamlProxyConfigurationSwapper.java | 9 ++-
.../YamlDatabaseConfigurationImportExecutor.java | 4 +-
.../variable/ShowDistVariablesExecutorTest.java | 6 +-
.../ImportDatabaseConfigurationExecutorTest.java | 3 +
.../imports/ImportMetaDataExecutorTest.java | 4 ++
...amlDatabaseConfigurationImportExecutorTest.java | 20 ++++---
.../src/test/resources/env/mysql/global.yaml | 1 +
30 files changed, 218 insertions(+), 84 deletions(-)
diff --git a/RELEASE-NOTES.md b/RELEASE-NOTES.md
index ae56f2cab60..0ef3b428f47 100644
--- a/RELEASE-NOTES.md
+++ b/RELEASE-NOTES.md
@@ -16,6 +16,7 @@
1. Remove logging rule feature -
[#35458](https://github.com/apache/shardingsphere/pull/35458)
1. Remove configuration property key `system-log-level` -
[#35493](https://github.com/apache/shardingsphere/pull/35493)
1. Change ShardingSphere SQL log topic from `ShardingSphere-SQL` to
`org.apache.shardingsphere.sql` -
[#37022](https://github.com/apache/shardingsphere/pull/37022)
+1. Add temporary config key `instance-connection-enabled` -
[#37694](https://github.com/apache/shardingsphere/pull/37694)
### New Features
diff --git
a/infra/common/src/main/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceGeneratedDatabaseConfiguration.java
b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceGeneratedDatabaseConfiguration.java
index f77c07ba9f0..7af9bbfe5b2 100644
---
a/infra/common/src/main/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceGeneratedDatabaseConfiguration.java
+++
b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceGeneratedDatabaseConfiguration.java
@@ -48,11 +48,12 @@ public final class DataSourceGeneratedDatabaseConfiguration
implements DatabaseC
private final Map<StorageNode, DataSource> dataSources;
- public DataSourceGeneratedDatabaseConfiguration(final Map<String,
DataSourceConfiguration> dataSourceConfigs, final Collection<RuleConfiguration>
ruleConfigs) {
+ public DataSourceGeneratedDatabaseConfiguration(final Map<String,
DataSourceConfiguration> dataSourceConfigs, final Collection<RuleConfiguration>
ruleConfigs,
+ final boolean
isInstanceConnectionEnabled) {
ruleConfigurations = ruleConfigs;
Map<String, DataSourcePoolProperties> dataSourcePoolPropertiesMap =
dataSourceConfigs.entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, entry ->
DataSourcePoolPropertiesCreator.create(entry.getValue()), (oldValue,
currentValue) -> oldValue, LinkedHashMap::new));
- Map<String, StorageNode> storageUnitNodeMap =
StorageUnitNodeMapCreator.create(dataSourcePoolPropertiesMap);
+ Map<String, StorageNode> storageUnitNodeMap =
StorageUnitNodeMapCreator.create(dataSourcePoolPropertiesMap,
isInstanceConnectionEnabled);
Map<StorageNode, DataSource> storageNodeDataSources =
getStorageNodeDataSourceMap(dataSourcePoolPropertiesMap, storageUnitNodeMap);
storageUnits = new LinkedHashMap<>(dataSourceConfigs.size(), 1F);
for (Entry<String, DataSourceConfiguration> entry :
dataSourceConfigs.entrySet()) {
diff --git
a/infra/common/src/main/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceProvidedDatabaseConfiguration.java
b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceProvidedDatabaseConfiguration.java
index d1ba5647410..9191d9f3a02 100644
---
a/infra/common/src/main/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceProvidedDatabaseConfiguration.java
+++
b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceProvidedDatabaseConfiguration.java
@@ -55,10 +55,10 @@ public final class DataSourceProvidedDatabaseConfiguration
implements DatabaseCo
this.dataSources = storageNodeDataSources;
}
- public DataSourceProvidedDatabaseConfiguration(final Map<StorageNode,
DataSource> storageNodeDataSources,
- final
Collection<RuleConfiguration> ruleConfigs, final Map<String,
DataSourcePoolProperties> dataSourcePoolPropsMap) {
+ public DataSourceProvidedDatabaseConfiguration(final Map<StorageNode,
DataSource> storageNodeDataSources, final Collection<RuleConfiguration>
ruleConfigs,
+ final Map<String,
DataSourcePoolProperties> dataSourcePoolPropsMap, final boolean
isInstanceConnectionEnabled) {
ruleConfigurations = ruleConfigs;
- Map<String, StorageNode> storageUnitNodeMap =
StorageUnitNodeMapCreator.create(dataSourcePoolPropsMap);
+ Map<String, StorageNode> storageUnitNodeMap =
StorageUnitNodeMapCreator.create(dataSourcePoolPropsMap,
isInstanceConnectionEnabled);
storageUnits = getStorageUnits(storageUnitNodeMap,
storageNodeDataSources, dataSourcePoolPropsMap);
dataSources = storageNodeDataSources;
}
diff --git
a/infra/common/src/main/java/org/apache/shardingsphere/infra/config/props/temporary/TemporaryConfigurationPropertyKey.java
b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/props/temporary/TemporaryConfigurationPropertyKey.java
index 378a55fd575..dec76dd769d 100644
---
a/infra/common/src/main/java/org/apache/shardingsphere/infra/config/props/temporary/TemporaryConfigurationPropertyKey.java
+++
b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/props/temporary/TemporaryConfigurationPropertyKey.java
@@ -45,7 +45,12 @@ public enum TemporaryConfigurationPropertyKey implements
TypedPropertyKey {
/**
* Proxy meta data collector cron.
*/
- PROXY_META_DATA_COLLECTOR_CRON("proxy-meta-data-collector-cron", "0 0/1 *
* * ?", String.class, false);
+ PROXY_META_DATA_COLLECTOR_CRON("proxy-meta-data-collector-cron", "0 0/1 *
* * ?", String.class, false),
+
+ /**
+ * Instance connection enabled.
+ */
+ INSTANCE_CONNECTION_ENABLED("instance-connection-enabled",
String.valueOf(Boolean.FALSE), boolean.class, false);
private final String key;
diff --git
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/node/StorageNode.java
b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/node/StorageNode.java
index b1b23778720..57bcce48c77 100644
---
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/node/StorageNode.java
+++
b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/node/StorageNode.java
@@ -19,19 +19,25 @@ package
org.apache.shardingsphere.infra.metadata.database.resource.node;
import com.google.common.base.Objects;
import lombok.Getter;
-import lombok.RequiredArgsConstructor;
/**
* Storage node.
*/
-@RequiredArgsConstructor
@Getter
public final class StorageNode {
private final String name;
+ private final boolean instanceStorageNode;
+
+ public StorageNode(final String name) {
+ this.name = name;
+ instanceStorageNode = false;
+ }
+
public StorageNode(final String hostname, final int port, final String
username) {
name = String.format("%s_%s_%s", hostname, port, username);
+ instanceStorageNode = true;
}
@Override
diff --git
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/node/StorageNodeAggregator.java
b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/node/StorageNodeAggregator.java
index bc76a08cd3a..6b13f5f77af 100644
---
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/node/StorageNodeAggregator.java
+++
b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/node/StorageNodeAggregator.java
@@ -55,26 +55,31 @@ public final class StorageNodeAggregator {
* Aggregate data source pool properties map to storage node grouped.
*
* @param storageUnitDataSourcePoolPropsMap storage unit name and data
source pool properties map
+ * @param isInstanceConnectionEnabled is instance connection enabled
* @return storage node and data source pool properties map
*/
- public static Map<StorageNode, DataSourcePoolProperties>
aggregateDataSourcePoolProperties(final Map<String, DataSourcePoolProperties>
storageUnitDataSourcePoolPropsMap) {
+ public static Map<StorageNode, DataSourcePoolProperties>
aggregateDataSourcePoolProperties(final Map<String, DataSourcePoolProperties>
storageUnitDataSourcePoolPropsMap,
+
final boolean isInstanceConnectionEnabled) {
Map<StorageNode, DataSourcePoolProperties> result = new
LinkedHashMap<>(storageUnitDataSourcePoolPropsMap.size(), 1F);
for (Entry<String, DataSourcePoolProperties> entry :
storageUnitDataSourcePoolPropsMap.entrySet()) {
Map<String, Object> standardProps =
entry.getValue().getConnectionPropertySynonyms().getStandardProperties();
String url = standardProps.get("url").toString();
String username = standardProps.get("username").toString();
DatabaseType databaseType = DatabaseTypeFactory.get(url);
- StorageNode storageNode = getStorageNode(entry.getKey(), url,
username, databaseType);
+ StorageNode storageNode = getStorageNode(entry.getKey(), url,
username, databaseType, isInstanceConnectionEnabled);
result.putIfAbsent(storageNode, entry.getValue());
}
return result;
}
- private static StorageNode getStorageNode(final String dataSourceName,
final String url, final String username, final DatabaseType databaseType) {
+ private static StorageNode getStorageNode(final String dataSourceName,
final String url, final String username,
+ final DatabaseType databaseType,
final boolean isInstanceConnectionEnabled) {
try {
ConnectionProperties connectionProps =
DatabaseTypedSPILoader.getService(ConnectionPropertiesParser.class,
databaseType).parse(url, username, null);
boolean isInstanceConnectionAvailable = new
DatabaseTypeRegistry(databaseType).getDialectDatabaseMetaData().getConnectionOption().isInstanceConnectionAvailable();
- return isInstanceConnectionAvailable ? new
StorageNode(connectionProps.getHostname(), connectionProps.getPort(), username)
: new StorageNode(dataSourceName);
+ return isInstanceConnectionEnabled && isInstanceConnectionAvailable
+ ? new StorageNode(connectionProps.getHostname(),
connectionProps.getPort(), username)
+ : new StorageNode(dataSourceName);
} catch (final UnrecognizedDatabaseURLException ex) {
return new StorageNode(dataSourceName);
}
diff --git
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/unit/StorageUnit.java
b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/unit/StorageUnit.java
index d832c37a7f9..3375ae65c79 100644
---
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/unit/StorageUnit.java
+++
b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/unit/StorageUnit.java
@@ -23,7 +23,6 @@ import
org.apache.shardingsphere.database.connector.core.jdbcurl.parser.Connecti
import
org.apache.shardingsphere.database.connector.core.spi.DatabaseTypedSPILoader;
import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
import
org.apache.shardingsphere.database.connector.core.type.DatabaseTypeFactory;
-import
org.apache.shardingsphere.database.connector.core.type.DatabaseTypeRegistry;
import
org.apache.shardingsphere.infra.datasource.pool.CatalogSwitchableDataSource;
import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
import
org.apache.shardingsphere.infra.metadata.database.resource.node.StorageNode;
@@ -54,10 +53,9 @@ public final class StorageUnit {
Object originUsername = standardProps.get("username");
String username = null == originUsername ? "" :
originUsername.toString();
storageType = DatabaseTypeFactory.get(url);
- boolean isInstanceConnectionAvailable = new
DatabaseTypeRegistry(storageType).getDialectDatabaseMetaData().getConnectionOption().isInstanceConnectionAvailable();
ConnectionPropertiesParser parser =
DatabaseTypedSPILoader.getService(ConnectionPropertiesParser.class,
storageType);
- String catalog = isInstanceConnectionAvailable ? parser.parse(url,
username, null).getCatalog() : null;
- this.dataSource = isInstanceConnectionAvailable ? new
CatalogSwitchableDataSource(dataSource, catalog, url) : dataSource;
+ String catalog = storageNode.isInstanceStorageNode() ?
parser.parse(url, username, null).getCatalog() : null;
+ this.dataSource = storageNode.isInstanceStorageNode() ? new
CatalogSwitchableDataSource(dataSource, catalog, url) : dataSource;
dataSourcePoolProperties = dataSourcePoolProps;
connectionProperties = createConnectionProperties(parser, catalog,
standardProps);
}
diff --git
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/unit/StorageUnitNodeMapCreator.java
b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/unit/StorageUnitNodeMapCreator.java
index 114435e24be..41ae0c3afa5 100644
---
a/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/unit/StorageUnitNodeMapCreator.java
+++
b/infra/common/src/main/java/org/apache/shardingsphere/infra/metadata/database/resource/unit/StorageUnitNodeMapCreator.java
@@ -43,20 +43,24 @@ public final class StorageUnitNodeMapCreator {
* Create storage unit node map.
*
* @param propsMap data source pool properties map
+ * @param isInstanceConnectionEnabled is instance connection enabled
* @return storage unit node map
*/
- public static Map<String, StorageNode> create(final Map<String,
DataSourcePoolProperties> propsMap) {
- return
propsMap.entrySet().stream().collect(Collectors.toMap(Entry::getKey, entry ->
create(entry.getKey(), entry.getValue()), (oldValue, currentValue) -> oldValue,
LinkedHashMap::new));
+ public static Map<String, StorageNode> create(final Map<String,
DataSourcePoolProperties> propsMap, final boolean isInstanceConnectionEnabled) {
+ return
propsMap.entrySet().stream().collect(Collectors.toMap(Entry::getKey, entry ->
create(entry.getKey(), entry.getValue(), isInstanceConnectionEnabled),
+ (oldValue, currentValue) -> oldValue, LinkedHashMap::new));
}
- private static StorageNode create(final String storageUnitName, final
DataSourcePoolProperties props) {
+ private static StorageNode create(final String storageUnitName, final
DataSourcePoolProperties props, final boolean isInstanceConnectionEnabled) {
Map<String, Object> standardProps =
props.getConnectionPropertySynonyms().getStandardProperties();
String url = standardProps.get("url").toString();
String username = standardProps.get("username").toString();
boolean isInstanceConnectionAvailable = new
DatabaseTypeRegistry(DatabaseTypeFactory.get(url)).getDialectDatabaseMetaData().getConnectionOption().isInstanceConnectionAvailable();
try {
ConnectionProperties connectionProps =
DatabaseTypedSPILoader.getService(ConnectionPropertiesParser.class,
DatabaseTypeFactory.get(url)).parse(url, username, null);
- return isInstanceConnectionAvailable ? new
StorageNode(connectionProps.getHostname(), connectionProps.getPort(), username)
: new StorageNode(storageUnitName);
+ return isInstanceConnectionEnabled && isInstanceConnectionAvailable
+ ? new StorageNode(connectionProps.getHostname(),
connectionProps.getPort(), username)
+ : new StorageNode(storageUnitName);
} catch (final UnrecognizedDatabaseURLException ex) {
return new StorageNode(storageUnitName);
}
diff --git
a/infra/common/src/test/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceGeneratedDatabaseConfigurationTest.java
b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceGeneratedDatabaseConfigurationTest.java
index 8a8a2688d39..2b8cbe95dd4 100644
---
a/infra/common/src/test/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceGeneratedDatabaseConfigurationTest.java
+++
b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceGeneratedDatabaseConfigurationTest.java
@@ -93,6 +93,6 @@ class DataSourceGeneratedDatabaseConfigurationTest {
private DataSourceGeneratedDatabaseConfiguration
createDatabaseConfiguration(final String dataSourceClassName) {
DataSourceConfiguration dataSourceConfig = new
DataSourceConfiguration(new ConnectionConfiguration(dataSourceClassName,
"jdbc:mock://127.0.0.1/foo_db", "root", ""),
new PoolConfiguration(2000L, 1000L, 1000L, 2, 1, false, new
Properties()));
- return new
DataSourceGeneratedDatabaseConfiguration(Collections.singletonMap("foo_db",
dataSourceConfig), Collections.singleton(new
FixtureRuleConfiguration("foo_rule")));
+ return new
DataSourceGeneratedDatabaseConfiguration(Collections.singletonMap("foo_db",
dataSourceConfig), Collections.singleton(new
FixtureRuleConfiguration("foo_rule")), true);
}
}
diff --git
a/infra/common/src/test/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceProvidedDatabaseConfigurationTest.java
b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceProvidedDatabaseConfigurationTest.java
index 991ac47dbf3..bc8281648a2 100644
---
a/infra/common/src/test/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceProvidedDatabaseConfigurationTest.java
+++
b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/database/impl/DataSourceProvidedDatabaseConfigurationTest.java
@@ -54,7 +54,7 @@ class DataSourceProvidedDatabaseConfigurationTest {
void assertNewWithStorageNodeDataSources() {
Map<String, DataSourcePoolProperties> dataSourcePoolPropsMap =
Collections.singletonMap("foo_ds", new DataSourcePoolProperties("foo_ds",
createConnectionProps()));
DataSourceProvidedDatabaseConfiguration actual = new
DataSourceProvidedDatabaseConfiguration(
- Collections.singletonMap(new StorageNode("foo_ds"), new
MockedDataSource()), Collections.singleton(new
FixtureRuleConfiguration("foo_rule")), dataSourcePoolPropsMap);
+ Collections.singletonMap(new StorageNode("foo_ds"), new
MockedDataSource()), Collections.singleton(new
FixtureRuleConfiguration("foo_rule")), dataSourcePoolPropsMap, false);
assertRuleConfigurations(actual);
assertStorageUnits(actual.getStorageUnits().get("foo_ds"));
assertDataSources((MockedDataSource) actual.getDataSources().get(new
StorageNode("foo_ds")));
diff --git
a/infra/common/src/test/java/org/apache/shardingsphere/infra/metadata/database/resource/node/StorageNodeAggregatorTest.java
b/infra/common/src/test/java/org/apache/shardingsphere/infra/metadata/database/resource/node/StorageNodeAggregatorTest.java
index e3e09cf4392..31e1956b2e2 100644
---
a/infra/common/src/test/java/org/apache/shardingsphere/infra/metadata/database/resource/node/StorageNodeAggregatorTest.java
+++
b/infra/common/src/test/java/org/apache/shardingsphere/infra/metadata/database/resource/node/StorageNodeAggregatorTest.java
@@ -53,7 +53,7 @@ class StorageNodeAggregatorTest {
standardProps.put("username", "root");
DataSourcePoolProperties dataSourcePoolProps =
mock(DataSourcePoolProperties.class, Answers.RETURNS_DEEP_STUBS);
when(dataSourcePoolProps.getConnectionPropertySynonyms().getStandardProperties()).thenReturn(standardProps);
- Map<StorageNode, DataSourcePoolProperties> actual =
StorageNodeAggregator.aggregateDataSourcePoolProperties(Collections.singletonMap("foo_ds",
dataSourcePoolProps));
+ Map<StorageNode, DataSourcePoolProperties> actual =
StorageNodeAggregator.aggregateDataSourcePoolProperties(Collections.singletonMap("foo_ds",
dataSourcePoolProps), true);
assertThat(actual.size(), is(1));
assertThat(actual.get(actual.keySet().iterator().next()),
is(dataSourcePoolProps));
}
@@ -70,7 +70,7 @@ class StorageNodeAggregatorTest {
when(dialectDatabaseMetaData.getConnectionOption().isInstanceConnectionAvailable()).thenReturn(true);
when(mock.getDialectDatabaseMetaData()).thenReturn(dialectDatabaseMetaData);
})) {
- Map<StorageNode, DataSourcePoolProperties> actual =
StorageNodeAggregator.aggregateDataSourcePoolProperties(Collections.singletonMap("foo_ds",
dataSourcePoolProps));
+ Map<StorageNode, DataSourcePoolProperties> actual =
StorageNodeAggregator.aggregateDataSourcePoolProperties(Collections.singletonMap("foo_ds",
dataSourcePoolProps), true);
assertThat(actual.size(), is(1));
assertThat(actual.get(new StorageNode("127.0.0.1_-1_root")),
is(dataSourcePoolProps));
}
@@ -83,7 +83,7 @@ class StorageNodeAggregatorTest {
standardProps.put("username", "root");
DataSourcePoolProperties dataSourcePoolProps =
mock(DataSourcePoolProperties.class, Answers.RETURNS_DEEP_STUBS);
when(dataSourcePoolProps.getConnectionPropertySynonyms().getStandardProperties()).thenReturn(standardProps);
- Map<StorageNode, DataSourcePoolProperties> actual =
StorageNodeAggregator.aggregateDataSourcePoolProperties(Collections.singletonMap("foo_ds",
dataSourcePoolProps));
+ Map<StorageNode, DataSourcePoolProperties> actual =
StorageNodeAggregator.aggregateDataSourcePoolProperties(Collections.singletonMap("foo_ds",
dataSourcePoolProps), true);
assertThat(actual.size(), is(1));
assertThat(actual.get(new StorageNode("foo_ds")),
is(dataSourcePoolProps));
}
diff --git
a/infra/common/src/test/java/org/apache/shardingsphere/infra/metadata/database/resource/unit/StorageUnitNodeMapCreatorTest.java
b/infra/common/src/test/java/org/apache/shardingsphere/infra/metadata/database/resource/unit/StorageUnitNodeMapCreatorTest.java
index 69da95613f2..1e87400b547 100644
---
a/infra/common/src/test/java/org/apache/shardingsphere/infra/metadata/database/resource/unit/StorageUnitNodeMapCreatorTest.java
+++
b/infra/common/src/test/java/org/apache/shardingsphere/infra/metadata/database/resource/unit/StorageUnitNodeMapCreatorTest.java
@@ -73,7 +73,7 @@ class StorageUnitNodeMapCreatorTest {
ConnectionPropertiesParser parser =
mock(ConnectionPropertiesParser.class);
when(parser.parse("jdbc:mock://127.0.0.1/foo_ds", "sa",
null)).thenReturn(new ConnectionProperties("127.0.0.1", 3307, null,
"foo_schema", new Properties()));
mockedLoader.when(() ->
DatabaseTypedSPILoader.getService(ConnectionPropertiesParser.class,
databaseType)).thenReturn(parser);
- Map<String, StorageNode> actual =
StorageUnitNodeMapCreator.create(Collections.singletonMap("foo_ds",
dataSourcePoolProps));
+ Map<String, StorageNode> actual =
StorageUnitNodeMapCreator.create(Collections.singletonMap("foo_ds",
dataSourcePoolProps), true);
assertThat(actual.size(), is(1));
assertTrue(actual.containsKey("foo_ds"));
}
@@ -86,7 +86,7 @@ class StorageUnitNodeMapCreatorTest {
ConnectionPropertiesParser parser =
mock(ConnectionPropertiesParser.class);
when(parser.parse("jdbc:mock://127.0.0.1/foo_ds", "sa",
null)).thenReturn(new ConnectionProperties("127.0.0.1", 3307, null,
"foo_schema", new Properties()));
mockedLoader.when(() ->
DatabaseTypedSPILoader.getService(ConnectionPropertiesParser.class,
databaseType)).thenReturn(parser);
- Map<String, StorageNode> actual =
StorageUnitNodeMapCreator.create(Collections.singletonMap("foo_ds",
dataSourcePoolProps));
+ Map<String, StorageNode> actual =
StorageUnitNodeMapCreator.create(Collections.singletonMap("foo_ds",
dataSourcePoolProps), true);
assertThat(actual.size(), is(1));
assertTrue(actual.containsKey("foo_ds"));
}
@@ -99,7 +99,7 @@ class StorageUnitNodeMapCreatorTest {
ConnectionPropertiesParser parser =
mock(ConnectionPropertiesParser.class);
when(parser.parse("jdbc:mock://127.0.0.1/foo_ds", "sa",
null)).thenThrow(UnrecognizedDatabaseURLException.class);
mockedLoader.when(() ->
DatabaseTypedSPILoader.getService(ConnectionPropertiesParser.class,
databaseType)).thenReturn(parser);
- Map<String, StorageNode> actual =
StorageUnitNodeMapCreator.create(Collections.singletonMap("foo_ds",
dataSourcePoolProps));
+ Map<String, StorageNode> actual =
StorageUnitNodeMapCreator.create(Collections.singletonMap("foo_ds",
dataSourcePoolProps), true);
assertThat(actual.size(), is(1));
assertTrue(actual.containsKey("foo_ds"));
}
diff --git
a/infra/common/src/test/java/org/apache/shardingsphere/infra/metadata/database/resource/unit/StorageUnitTest.java
b/infra/common/src/test/java/org/apache/shardingsphere/infra/metadata/database/resource/unit/StorageUnitTest.java
index d347a4e4736..3ea7a7c2331 100644
---
a/infra/common/src/test/java/org/apache/shardingsphere/infra/metadata/database/resource/unit/StorageUnitTest.java
+++
b/infra/common/src/test/java/org/apache/shardingsphere/infra/metadata/database/resource/unit/StorageUnitTest.java
@@ -84,13 +84,10 @@ class StorageUnitTest {
try (MockedStatic<DatabaseTypedSPILoader> mockedLoader =
mockStatic(DatabaseTypedSPILoader.class)) {
when(dataSourcePoolProperties.getConnectionPropertySynonyms().getStandardProperties()).thenReturn(standardProperties);
DialectDatabaseMetaData dialectDatabaseMetaData =
mock(DialectDatabaseMetaData.class, RETURNS_DEEP_STUBS);
-
when(dialectDatabaseMetaData.getConnectionOption().isInstanceConnectionAvailable()).thenReturn(true);
mockedLoader.when(() ->
DatabaseTypedSPILoader.getService(DialectDatabaseMetaData.class,
databaseType)).thenReturn(dialectDatabaseMetaData);
ConnectionPropertiesParser parser =
mock(ConnectionPropertiesParser.class);
when(parser.parse("jdbc:mock://127.0.0.1/foo_ds", "sa", null))
.thenReturn(new ConnectionProperties("127.0.0.1", 3307,
"foo_catalog", "foo_schema", new Properties()));
- when(parser.parse("jdbc:mock://127.0.0.1/foo_ds", "sa",
"foo_catalog"))
- .thenReturn(new ConnectionProperties("127.0.0.1", 3307,
"foo_catalog", "foo_schema", new Properties()));
mockedLoader.when(() ->
DatabaseTypedSPILoader.getService(ConnectionPropertiesParser.class,
databaseType)).thenReturn(parser);
StorageUnit actual = new StorageUnit(mock(),
dataSourcePoolProperties, mock());
assertThat(actual.getConnectionProperties().getHostname(),
is("127.0.0.1"));
diff --git
a/infra/data-source-pool/core/src/main/java/org/apache/shardingsphere/infra/datasource/pool/CatalogSwitchableDataSource.java
b/infra/data-source-pool/core/src/main/java/org/apache/shardingsphere/infra/datasource/pool/CatalogSwitchableDataSource.java
index c9ea4ed8590..55c24a1b441 100644
---
a/infra/data-source-pool/core/src/main/java/org/apache/shardingsphere/infra/datasource/pool/CatalogSwitchableDataSource.java
+++
b/infra/data-source-pool/core/src/main/java/org/apache/shardingsphere/infra/datasource/pool/CatalogSwitchableDataSource.java
@@ -44,7 +44,7 @@ public final class CatalogSwitchableDataSource implements
DataSource, AutoClosea
@Override
public Connection getConnection() throws SQLException {
Connection result = dataSource.getConnection();
- if (null != catalog) {
+ if (null != catalog && !catalog.equals(result.getCatalog())) {
result.setCatalog(catalog);
}
return result;
diff --git
a/infra/data-source-pool/core/src/test/java/org/apache/shardingsphere/infra/datasource/pool/CatalogSwitchableDataSourceTest.java
b/infra/data-source-pool/core/src/test/java/org/apache/shardingsphere/infra/datasource/pool/CatalogSwitchableDataSourceTest.java
new file mode 100644
index 00000000000..9af0113db68
--- /dev/null
+++
b/infra/data-source-pool/core/src/test/java/org/apache/shardingsphere/infra/datasource/pool/CatalogSwitchableDataSourceTest.java
@@ -0,0 +1,69 @@
+/*
+ * 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.infra.datasource.pool;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
+
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class CatalogSwitchableDataSourceTest {
+
+ @Mock
+ private DataSource dataSource;
+
+ @Mock
+ private Connection connection;
+
+ @Test
+ void assertGetConnectionWhenCatalogIsNull() throws SQLException {
+ when(dataSource.getConnection()).thenReturn(connection);
+ CatalogSwitchableDataSource catalogSwitchableDataSource = new
CatalogSwitchableDataSource(dataSource, null, "jdbc:mysql://localhost:3306/db");
+ catalogSwitchableDataSource.getConnection();
+ verify(connection, never()).setCatalog(null);
+ }
+
+ @Test
+ void assertGetConnectionWhenCatalogIsSame() throws SQLException {
+ String catalog = "db";
+ when(dataSource.getConnection()).thenReturn(connection);
+ when(connection.getCatalog()).thenReturn(catalog);
+ CatalogSwitchableDataSource catalogSwitchableDataSource = new
CatalogSwitchableDataSource(dataSource, catalog,
"jdbc:mysql://localhost:3306/db");
+ catalogSwitchableDataSource.getConnection();
+ verify(connection, never()).setCatalog(catalog);
+ }
+
+ @Test
+ void assertGetConnectionWhenCatalogIsDifferent() throws SQLException {
+ String catalog = "db";
+ when(dataSource.getConnection()).thenReturn(connection);
+ when(connection.getCatalog()).thenReturn("other_db");
+ CatalogSwitchableDataSource catalogSwitchableDataSource = new
CatalogSwitchableDataSource(dataSource, catalog,
"jdbc:mysql://localhost:3306/db");
+ catalogSwitchableDataSource.getConnection();
+ verify(connection).setCatalog(catalog);
+ }
+}
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 b8ffd235864..6002fcd373b 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
@@ -24,6 +24,7 @@ import
org.apache.shardingsphere.database.exception.core.exception.syntax.databa
import
org.apache.shardingsphere.database.exception.core.exception.syntax.database.UnknownDatabaseException;
import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
import org.apache.shardingsphere.infra.config.props.ConfigurationPropertyKey;
+import
org.apache.shardingsphere.infra.config.props.temporary.TemporaryConfigurationPropertyKey;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import org.apache.shardingsphere.infra.database.DatabaseTypeEngine;
import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
@@ -152,7 +153,9 @@ public final class ContextManager implements AutoCloseable {
private MetaDataContexts createMetaDataContexts(final
ShardingSphereDatabase database) throws SQLException {
Map<String, DataSourcePoolProperties> dataSourcePoolProps =
persistServiceFacade.getMetaDataFacade().getDataSourceUnitService().load(database.getName());
- SwitchingResource switchingResource =
metaDataContextManager.getResourceSwitchManager().switchByAlterStorageUnit(database.getResourceMetaData(),
dataSourcePoolProps);
+ boolean isInstanceConnectionEnabled =
metaDataContexts.getMetaData().getTemporaryProps().<Boolean>getValue(TemporaryConfigurationPropertyKey.INSTANCE_CONNECTION_ENABLED);
+ SwitchingResource switchingResource =
+
metaDataContextManager.getResourceSwitchManager().switchByAlterStorageUnit(database.getResourceMetaData(),
dataSourcePoolProps, isInstanceConnectionEnabled);
Collection<RuleConfiguration> ruleConfigs =
persistServiceFacade.getMetaDataFacade().getDatabaseRuleService().load(database.getName());
ShardingSphereDatabase changedDatabase = new
MetaDataContextsFactory(persistServiceFacade.getMetaDataFacade(),
computeNodeInstanceContext)
.createChangedDatabase(database.getName(), false,
switchingResource, ruleConfigs, metaDataContexts);
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/factory/MetaDataContextsFactory.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/factory/MetaDataContextsFactory.java
index f9afcfd0c4f..4ab8269b02b 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/factory/MetaDataContextsFactory.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/factory/MetaDataContextsFactory.java
@@ -23,6 +23,7 @@ import
org.apache.shardingsphere.infra.config.database.DatabaseConfiguration;
import
org.apache.shardingsphere.infra.config.database.impl.DataSourceProvidedDatabaseConfiguration;
import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
import org.apache.shardingsphere.infra.config.props.ConfigurationPropertyKey;
+import
org.apache.shardingsphere.infra.config.props.temporary.TemporaryConfigurationPropertyKey;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import org.apache.shardingsphere.infra.database.DatabaseTypeEngine;
import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
@@ -151,7 +152,7 @@ public final class MetaDataContextsFactory {
ShardingSphereDatabase database =
originalMetaDataContext.getMetaData().getDatabase(databaseName);
ResourceMetaData effectiveResourceMetaData =
getEffectiveResourceMetaData(database, switchingResource);
Collection<RuleConfiguration> toBeCreatedRuleConfigs = null ==
ruleConfigs ? database.getRuleMetaData().getConfigurations() : ruleConfigs;
- DatabaseConfiguration toBeCreatedDatabaseConfig =
getDatabaseConfiguration(effectiveResourceMetaData, switchingResource,
toBeCreatedRuleConfigs);
+ DatabaseConfiguration toBeCreatedDatabaseConfig =
getDatabaseConfiguration(effectiveResourceMetaData, switchingResource,
toBeCreatedRuleConfigs, originalMetaDataContext);
return createChangedDatabase(database.getName(),
isLoadSchemasFromRegisterCenter, toBeCreatedDatabaseConfig,
originalMetaDataContext);
}
@@ -197,12 +198,13 @@ public final class MetaDataContextsFactory {
.collect(Collectors.toMap(Entry::getKey, Entry::getValue,
(oldValue, currentValue) -> currentValue, () -> new
LinkedHashMap<>(currentStorageUnits.size(), 1F)));
}
- private DatabaseConfiguration getDatabaseConfiguration(final
ResourceMetaData currentResourceMetaData,
- final
SwitchingResource switchingResource, final Collection<RuleConfiguration>
toBeCreatedRuleConfigs) {
+ private DatabaseConfiguration getDatabaseConfiguration(final
ResourceMetaData currentResourceMetaData, final SwitchingResource
switchingResource,
+ final
Collection<RuleConfiguration> toBeCreatedRuleConfigs, final MetaDataContexts
metaDataContexts) {
Map<String, DataSourcePoolProperties> propsMap = null ==
switchingResource ?
currentResourceMetaData.getStorageUnits().entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, entry ->
entry.getValue().getDataSourcePoolProperties(), (oldValue, currentValue) ->
oldValue, LinkedHashMap::new))
: switchingResource.getMergedDataSourcePoolPropertiesMap();
- return new
DataSourceProvidedDatabaseConfiguration(getMergedStorageNodeDataSources(currentResourceMetaData,
switchingResource), toBeCreatedRuleConfigs, propsMap);
+ boolean isInstanceConnectionEnabled =
metaDataContexts.getMetaData().getTemporaryProps().<Boolean>getValue(TemporaryConfigurationPropertyKey.INSTANCE_CONNECTION_ENABLED);
+ return new
DataSourceProvidedDatabaseConfiguration(getMergedStorageNodeDataSources(currentResourceMetaData,
switchingResource), toBeCreatedRuleConfigs, propsMap,
isInstanceConnectionEnabled);
}
private Map<StorageNode, DataSource> getMergedStorageNodeDataSources(final
ResourceMetaData currentResourceMetaData, final SwitchingResource
switchingResource) {
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/factory/init/type/RegisterCenterMetaDataContextsInitFactory.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/factory/init/type/RegisterCenterMetaDataContextsInitFactory.java
index 8ec8df4a60b..27c2d980ffb 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/factory/init/type/RegisterCenterMetaDataContextsInitFactory.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/factory/init/type/RegisterCenterMetaDataContextsInitFactory.java
@@ -24,6 +24,8 @@ import
org.apache.shardingsphere.infra.config.database.DatabaseConfiguration;
import
org.apache.shardingsphere.infra.config.database.impl.DataSourceGeneratedDatabaseConfiguration;
import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
import org.apache.shardingsphere.infra.config.props.ConfigurationPropertyKey;
+import
org.apache.shardingsphere.infra.config.props.temporary.TemporaryConfigurationProperties;
+import
org.apache.shardingsphere.infra.config.props.temporary.TemporaryConfigurationPropertyKey;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import org.apache.shardingsphere.infra.database.DatabaseTypeEngine;
import org.apache.shardingsphere.infra.datanode.DataNode;
@@ -75,12 +77,15 @@ public final class
RegisterCenterMetaDataContextsInitFactory extends MetaDataCon
@Override
public MetaDataContexts create(final ContextManagerBuilderParameter param)
throws SQLException {
- Map<String, DatabaseConfiguration> effectiveDatabaseConfigs =
createEffectiveDatabaseConfigurations(getDatabaseNames(param.getDatabaseConfigs()),
param.getDatabaseConfigs());
+ TemporaryConfigurationProperties tempProps = new
TemporaryConfigurationProperties(persistFacade.getPropsService().load());
+ boolean isInstanceConnectionEnabled =
tempProps.getValue(TemporaryConfigurationPropertyKey.INSTANCE_CONNECTION_ENABLED);
+ Map<String, DatabaseConfiguration> effectiveDatabaseConfigs =
+
createEffectiveDatabaseConfigurations(getDatabaseNames(param.getDatabaseConfigs()),
param.getDatabaseConfigs(), isInstanceConnectionEnabled);
// TODO load global data sources from persist service
Map<String, DataSource> globalDataSources =
param.getGlobalDataSources();
ConfigurationProperties props = new
ConfigurationProperties(persistFacade.getPropsService().load());
DatabaseType protocolType =
DatabaseTypeEngine.getProtocolType(effectiveDatabaseConfigs, props);
- Map<String, Collection<ShardingSphereSchema>> schemas =
loadSchemas(effectiveDatabaseConfigs, protocolType, props);
+ Map<String, Collection<ShardingSphereSchema>> schemas =
loadSchemas(effectiveDatabaseConfigs, protocolType, props,
isInstanceConnectionEnabled);
Collection<ShardingSphereDatabase> databases;
if (persistSchemasEnabled) {
// TODO merge schemas with local
@@ -104,15 +109,17 @@ public final class
RegisterCenterMetaDataContextsInitFactory extends MetaDataCon
:
persistFacade.getDatabaseMetaDataFacade().getDatabase().loadAllDatabaseNames();
}
- 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 Map<String, DatabaseConfiguration>
createEffectiveDatabaseConfigurations(final Collection<String> databaseNames,
final Map<String, DatabaseConfiguration> databaseConfigs,
+
final boolean isInstanceConnectionEnabled) {
+ return databaseNames.stream().collect(Collectors.toMap(each -> each,
each -> createEffectiveDatabaseConfiguration(each, databaseConfigs,
isInstanceConnectionEnabled)));
}
- private DatabaseConfiguration createEffectiveDatabaseConfiguration(final
String databaseName, final Map<String, DatabaseConfiguration> databaseConfigs) {
+ private DatabaseConfiguration createEffectiveDatabaseConfiguration(final
String databaseName, final Map<String, DatabaseConfiguration> databaseConfigs,
+ final
boolean isInstanceConnectionEnabled) {
closeGeneratedDataSources(databaseName, databaseConfigs);
Map<String, DataSourceConfiguration> dataSources =
persistFacade.loadDataSourceConfigurations(databaseName);
Collection<RuleConfiguration> databaseRuleConfigs =
persistFacade.getDatabaseRuleService().load(databaseName);
- return new DataSourceGeneratedDatabaseConfiguration(dataSources,
databaseRuleConfigs);
+ return new DataSourceGeneratedDatabaseConfiguration(dataSources,
databaseRuleConfigs, isInstanceConnectionEnabled);
}
private void closeGeneratedDataSources(final String databaseName, final
Map<String, ? extends DatabaseConfiguration> databaseConfigs) {
@@ -121,8 +128,8 @@ public final class
RegisterCenterMetaDataContextsInitFactory extends MetaDataCon
}
}
- private Map<String, Collection<ShardingSphereSchema>> loadSchemas(final
Map<String, DatabaseConfiguration> effectiveDatabaseConfigs,
- final
DatabaseType protocolType, final ConfigurationProperties props) {
+ private Map<String, Collection<ShardingSphereSchema>> loadSchemas(final
Map<String, DatabaseConfiguration> effectiveDatabaseConfigs, final DatabaseType
protocolType,
+ final
ConfigurationProperties props, final boolean isInstanceConnectionEnabled) {
Collection<String> sysDatabaseNames = new
SystemDatabase(protocolType).getSystemDatabases();
Collection<String> databaseNames = effectiveDatabaseConfigs.keySet();
Map<String, Collection<ShardingSphereSchema>> result = new
HashMap<>(databaseNames.size());
@@ -140,7 +147,7 @@ public final class
RegisterCenterMetaDataContextsInitFactory extends MetaDataCon
} else {
log.info("Repository missed single tables: {} of database:
{}, start to reload", missedSingleTables, dbName);
DataSourceGeneratedDatabaseConfiguration databaseConfig =
new
DataSourceGeneratedDatabaseConfiguration(persistFacade.loadDataSourceConfigurations(dbName),
- Collections.singleton(new
SingleRuleConfiguration(missedSingleTables, null)));
+ Collections.singleton(new
SingleRuleConfiguration(missedSingleTables, null)),
isInstanceConnectionEnabled);
try {
ShardingSphereDatabase database =
ShardingSphereDatabaseFactory.createWithoutSystemSchema(dbName, protocolType,
databaseConfig, props, instanceContext);
database.getAllSchemas().forEach(schema ->
persistFacade.getDatabaseMetaDataFacade().getTable().persist(dbName,
schema.getName(), schema.getAllTables()));
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/resource/ResourceSwitchManager.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/resource/ResourceSwitchManager.java
index 9427ae3ba25..7d1b82146dd 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/resource/ResourceSwitchManager.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/resource/ResourceSwitchManager.java
@@ -45,14 +45,16 @@ public final class ResourceSwitchManager {
*
* @param resourceMetaData resource meta data
* @param toBeRegisteredProps to be registered storage unit grouped data
source pool properties map
+ * @param isInstanceConnectionEnabled is instance connection enabled
* @return created switching resource
*/
- public SwitchingResource switchByRegisterStorageUnit(final
ResourceMetaData resourceMetaData, final Map<String, DataSourcePoolProperties>
toBeRegisteredProps) {
+ public SwitchingResource switchByRegisterStorageUnit(final
ResourceMetaData resourceMetaData, final Map<String, DataSourcePoolProperties>
toBeRegisteredProps,
+ final boolean
isInstanceConnectionEnabled) {
Map<String, DataSourcePoolProperties> mergedPropsMap = new
LinkedHashMap<>(resourceMetaData.getStorageUnits().entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, entry ->
entry.getValue().getDataSourcePoolProperties(), (oldValue, currentValue) ->
oldValue, LinkedHashMap::new)));
mergedPropsMap.putAll(toBeRegisteredProps);
- Map<String, StorageNode> toBeCreatedStorageUintNodeMap =
StorageUnitNodeMapCreator.create(toBeRegisteredProps);
- Map<StorageNode, DataSourcePoolProperties> dataSourcePoolPropsMap =
StorageNodeAggregator.aggregateDataSourcePoolProperties(toBeRegisteredProps);
+ Map<String, StorageNode> toBeCreatedStorageUintNodeMap =
StorageUnitNodeMapCreator.create(toBeRegisteredProps,
isInstanceConnectionEnabled);
+ Map<StorageNode, DataSourcePoolProperties> dataSourcePoolPropsMap =
StorageNodeAggregator.aggregateDataSourcePoolProperties(toBeRegisteredProps,
isInstanceConnectionEnabled);
return new SwitchingResource(getNewDataSources(resourceMetaData,
toBeCreatedStorageUintNodeMap, dataSourcePoolPropsMap), Collections.emptyMap(),
Collections.emptyList(), mergedPropsMap);
}
@@ -72,14 +74,16 @@ public final class ResourceSwitchManager {
*
* @param resourceMetaData resource meta data
* @param toBeAlteredProps to be altered data source pool properties map
+ * @param isInstanceConnectionEnabled is instance connection enabled
* @return created switching resource
*/
- public SwitchingResource switchByAlterStorageUnit(final ResourceMetaData
resourceMetaData, final Map<String, DataSourcePoolProperties> toBeAlteredProps)
{
+ public SwitchingResource switchByAlterStorageUnit(final ResourceMetaData
resourceMetaData, final Map<String, DataSourcePoolProperties> toBeAlteredProps,
+ final boolean
isInstanceConnectionEnabled) {
Map<String, DataSourcePoolProperties> mergedDataSourcePoolPropsMap =
new LinkedHashMap<>(resourceMetaData.getStorageUnits().entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, entry ->
entry.getValue().getDataSourcePoolProperties(), (oldValue, currentValue) ->
oldValue, LinkedHashMap::new)));
mergedDataSourcePoolPropsMap.putAll(toBeAlteredProps);
- Map<String, StorageNode> toBeAlteredStorageUintNodeMap =
StorageUnitNodeMapCreator.create(mergedDataSourcePoolPropsMap);
- Map<StorageNode, DataSourcePoolProperties> dataSourcePoolPropsMap =
StorageNodeAggregator.aggregateDataSourcePoolProperties(mergedDataSourcePoolPropsMap);
+ Map<String, StorageNode> toBeAlteredStorageUintNodeMap =
StorageUnitNodeMapCreator.create(mergedDataSourcePoolPropsMap,
isInstanceConnectionEnabled);
+ Map<StorageNode, DataSourcePoolProperties> dataSourcePoolPropsMap =
StorageNodeAggregator.aggregateDataSourcePoolProperties(mergedDataSourcePoolPropsMap,
isInstanceConnectionEnabled);
return new
SwitchingResource(getAlterNewDataSources(toBeAlteredStorageUintNodeMap,
dataSourcePoolPropsMap),
getStaleDataSources(resourceMetaData,
toBeAlteredStorageUintNodeMap.values()), new
LinkedHashSet<>(toBeAlteredStorageUintNodeMap.keySet()),
mergedDataSourcePoolPropsMap);
}
diff --git
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/resource/StorageUnitManager.java
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/resource/StorageUnitManager.java
index 0bdef7fa50a..ec4e3587079 100644
---
a/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/resource/StorageUnitManager.java
+++
b/mode/core/src/main/java/org/apache/shardingsphere/mode/metadata/manager/resource/StorageUnitManager.java
@@ -20,6 +20,7 @@ package
org.apache.shardingsphere.mode.metadata.manager.resource;
import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
+import
org.apache.shardingsphere.infra.config.props.temporary.TemporaryConfigurationPropertyKey;
import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
import org.apache.shardingsphere.infra.instance.ComputeNodeInstanceContext;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
@@ -60,7 +61,8 @@ public final class StorageUnitManager {
ShardingSphereDatabase database =
metaDataContexts.getMetaData().getDatabase(databaseName);
try {
closeStaleRules(database);
- SwitchingResource switchingResource =
resourceSwitchManager.switchByRegisterStorageUnit(database.getResourceMetaData(),
propsMap);
+ boolean isInstanceConnectionEnabled =
metaDataContexts.getMetaData().getTemporaryProps().<Boolean>getValue(TemporaryConfigurationPropertyKey.INSTANCE_CONNECTION_ENABLED);
+ SwitchingResource switchingResource =
resourceSwitchManager.switchByRegisterStorageUnit(database.getResourceMetaData(),
propsMap, isInstanceConnectionEnabled);
buildNewMetaDataContext(databaseName, switchingResource, true);
} catch (final SQLException ex) {
log.error("Alter database: {} register storage unit failed.",
databaseName, ex);
@@ -77,7 +79,8 @@ public final class StorageUnitManager {
ShardingSphereDatabase database =
metaDataContexts.getMetaData().getDatabase(databaseName);
try {
closeStaleRules(database);
- SwitchingResource switchingResource =
resourceSwitchManager.switchByAlterStorageUnit(database.getResourceMetaData(),
propsMap);
+ boolean isInstanceConnectionEnabled =
metaDataContexts.getMetaData().getTemporaryProps().<Boolean>getValue(TemporaryConfigurationPropertyKey.INSTANCE_CONNECTION_ENABLED);
+ SwitchingResource switchingResource =
resourceSwitchManager.switchByAlterStorageUnit(database.getResourceMetaData(),
propsMap, isInstanceConnectionEnabled);
buildNewMetaDataContext(databaseName, switchingResource, true);
} catch (final SQLException ex) {
log.error("Alter database: {} alter storage unit failed.",
databaseName, ex);
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 993b185f203..8f4bbcd41fd 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
@@ -23,6 +23,7 @@ import
org.apache.shardingsphere.database.exception.core.exception.syntax.databa
import
org.apache.shardingsphere.database.exception.core.exception.syntax.database.UnknownDatabaseException;
import org.apache.shardingsphere.infra.config.mode.ModeConfiguration;
import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
+import
org.apache.shardingsphere.infra.config.props.temporary.TemporaryConfigurationProperties;
import org.apache.shardingsphere.infra.database.DatabaseTypeEngine;
import org.apache.shardingsphere.infra.datanode.DataNode;
import org.apache.shardingsphere.infra.instance.ComputeNodeInstance;
@@ -77,6 +78,7 @@ import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyCollection;
import static org.mockito.ArgumentMatchers.anyMap;
import static org.mockito.ArgumentMatchers.anySet;
@@ -109,6 +111,7 @@ class ContextManagerTest {
@BeforeEach
void setUp() throws SQLException {
when(metaDataContexts.getMetaData().getProps()).thenReturn(new
ConfigurationProperties(new Properties()));
+
when(metaDataContexts.getMetaData().getTemporaryProps()).thenReturn(new
TemporaryConfigurationProperties(new Properties()));
database = mockDatabase();
when(metaDataContexts.getMetaData().containsDatabase("foo_db")).thenReturn(true);
when(metaDataContexts.getMetaData().getDatabase("foo_db")).thenReturn(database);
@@ -186,7 +189,7 @@ class ContextManagerTest {
setPersistServiceFacade(persistServiceFacade);
MetaDataContextManager metaDataContextManager =
mock(MetaDataContextManager.class, RETURNS_DEEP_STUBS);
SwitchingResource switchingResource = new
SwitchingResource(Collections.emptyMap(), Collections.emptyMap(),
Collections.emptyList(), Collections.emptyMap());
-
when(metaDataContextManager.getResourceSwitchManager().switchByAlterStorageUnit(any(ResourceMetaData.class),
anyMap())).thenReturn(switchingResource);
+
when(metaDataContextManager.getResourceSwitchManager().switchByAlterStorageUnit(any(ResourceMetaData.class),
anyMap(), anyBoolean())).thenReturn(switchingResource);
setMetaDataContextManager(metaDataContextManager);
when(metaDataContexts.getMetaData().getGlobalResourceMetaData()).thenReturn(mock(ResourceMetaData.class));
try (
@@ -210,7 +213,7 @@ class ContextManagerTest {
setPersistServiceFacade(mockPersistServiceFacade());
MetaDataContextManager metaDataContextManager =
mock(MetaDataContextManager.class, RETURNS_DEEP_STUBS);
SwitchingResource switchingResource = new
SwitchingResource(Collections.emptyMap(), Collections.emptyMap(),
Collections.emptyList(), Collections.emptyMap());
-
when(metaDataContextManager.getResourceSwitchManager().switchByAlterStorageUnit(any(ResourceMetaData.class),
anyMap())).thenReturn(switchingResource);
+
when(metaDataContextManager.getResourceSwitchManager().switchByAlterStorageUnit(any(ResourceMetaData.class),
anyMap(), anyBoolean())).thenReturn(switchingResource);
setMetaDataContextManager(metaDataContextManager);
try (
MockedConstruction<MetaDataContextsFactory> ignored =
mockConstruction(MetaDataContextsFactory.class,
diff --git
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/resource/ResourceSwitchManagerTest.java
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/resource/ResourceSwitchManagerTest.java
index 66f4b881c09..3c0e49a4e07 100644
---
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/resource/ResourceSwitchManagerTest.java
+++
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/resource/ResourceSwitchManagerTest.java
@@ -66,7 +66,7 @@ class ResourceSwitchManagerTest {
DataSource newDataSource = mock(DataSource.class);
try (MockedStatic<DataSourcePoolCreator> mocked =
mockStatic(DataSourcePoolCreator.class)) {
mocked.when(() ->
DataSourcePoolCreator.create(any(DataSourcePoolProperties.class))).thenReturn(newDataSource);
- SwitchingResource actual =
resourceSwitchManager.switchByRegisterStorageUnit(resourceMetaData,
toBeRegistered);
+ SwitchingResource actual =
resourceSwitchManager.switchByRegisterStorageUnit(resourceMetaData,
toBeRegistered, false);
assertThat(actual.getNewDataSources().size(), is(1));
assertThat(actual.getNewDataSources(), hasKey(new
StorageNode("ds_new")));
verifyNoInteractions(resourceMetaData.getDataSources().get(new
StorageNode("ds_existing")));
@@ -81,7 +81,7 @@ class ResourceSwitchManagerTest {
DataSource newDataSource = mock(DataSource.class);
try (MockedStatic<DataSourcePoolCreator> mocked =
mockStatic(DataSourcePoolCreator.class)) {
mocked.when(() ->
DataSourcePoolCreator.create(any(DataSourcePoolProperties.class))).thenReturn(newDataSource);
- SwitchingResource actual =
resourceSwitchManager.switchByAlterStorageUnit(resourceMetaData, toBeAltered);
+ SwitchingResource actual =
resourceSwitchManager.switchByAlterStorageUnit(resourceMetaData, toBeAltered,
false);
assertThat(actual.getNewDataSources().get(existingNode),
is(newDataSource));
assertThat(actual.getStaleDataSources().get(existingNode),
is(resourceMetaData.getDataSources().get(existingNode)));
assertThat(actual.getStaleDataSources(), not(hasKey(new
StorageNode("extra_only"))));
@@ -137,7 +137,7 @@ class ResourceSwitchManagerTest {
DataSource newDataSource = mock(DataSource.class);
try (MockedStatic<DataSourcePoolCreator> mocked =
mockStatic(DataSourcePoolCreator.class)) {
mocked.when(() ->
DataSourcePoolCreator.create(any(DataSourcePoolProperties.class))).thenReturn(newDataSource);
- SwitchingResource actual =
resourceSwitchManager.switchByRegisterStorageUnit(resourceMetaData,
toBeRegistered);
+ SwitchingResource actual =
resourceSwitchManager.switchByRegisterStorageUnit(resourceMetaData,
toBeRegistered, false);
assertThat(actual.getNewDataSources().size(), is(newUnitsCount));
assertThat(actual.getNewDataSources().size(), is(newUnitsCount));
for (int i = 0; i < newUnitsCount; i++) {
@@ -154,7 +154,7 @@ class ResourceSwitchManagerTest {
DataSource newDataSource = mock(DataSource.class);
try (MockedStatic<DataSourcePoolCreator> mocked =
mockStatic(DataSourcePoolCreator.class)) {
mocked.when(() ->
DataSourcePoolCreator.create(any(DataSourcePoolProperties.class))).thenReturn(newDataSource);
- SwitchingResource actual =
resourceSwitchManager.switchByAlterStorageUnit(resourceMetaData, toBeAltered);
+ SwitchingResource actual =
resourceSwitchManager.switchByAlterStorageUnit(resourceMetaData, toBeAltered,
false);
assertThat(actual.getNewDataSources().size(), is(totalUnits));
assertThat(actual.getStaleDataSources().size(), is(totalUnits));
assertTrue(actual.getStaleStorageUnitNames().containsAll(toBeAltered.keySet()));
@@ -179,7 +179,7 @@ class ResourceSwitchManagerTest {
void assertSwitchByRegisterStorageUnitWithEmptyInput() {
ResourceMetaData resourceMetaData =
createResourceMetaDataWithSingleUnit("ds_existing");
Map<String, DataSourcePoolProperties> toBeRegistered =
Collections.emptyMap();
- SwitchingResource actual =
resourceSwitchManager.switchByRegisterStorageUnit(resourceMetaData,
toBeRegistered);
+ SwitchingResource actual =
resourceSwitchManager.switchByRegisterStorageUnit(resourceMetaData,
toBeRegistered, false);
assertThat(actual.getNewDataSources(), aMapWithSize(0));
assertThat(actual.getStaleDataSources(), aMapWithSize(0));
assertThat(actual.getStaleStorageUnitNames().isEmpty(), is(true));
@@ -193,7 +193,7 @@ class ResourceSwitchManagerTest {
DataSource newDataSource = mock(DataSource.class);
try (MockedStatic<DataSourcePoolCreator> mocked =
mockStatic(DataSourcePoolCreator.class)) {
mocked.when(() ->
DataSourcePoolCreator.create(any(DataSourcePoolProperties.class))).thenReturn(newDataSource);
- SwitchingResource actual =
resourceSwitchManager.switchByAlterStorageUnit(resourceMetaData, toBeAltered);
+ SwitchingResource actual =
resourceSwitchManager.switchByAlterStorageUnit(resourceMetaData, toBeAltered,
false);
assertThat(actual.getNewDataSources().size(), is(1));
assertThat(actual.getStaleDataSources().size(), is(1));
assertThat(actual.getStaleStorageUnitNames().isEmpty(), is(false));
@@ -228,7 +228,7 @@ class ResourceSwitchManagerTest {
DataSource newDataSource = mock(DataSource.class);
try (MockedStatic<DataSourcePoolCreator> mocked =
mockStatic(DataSourcePoolCreator.class)) {
mocked.when(() ->
DataSourcePoolCreator.create(any(DataSourcePoolProperties.class))).thenReturn(newDataSource);
- SwitchingResource actual =
resourceSwitchManager.switchByRegisterStorageUnit(resourceMetaData,
toBeRegistered);
+ SwitchingResource actual =
resourceSwitchManager.switchByRegisterStorageUnit(resourceMetaData,
toBeRegistered, false);
assertThat(actual.getNewDataSources().size(), is(1));
assertThat(actual.getNewDataSources(), hasKey(new
StorageNode("new_0")));
}
@@ -243,7 +243,7 @@ class ResourceSwitchManagerTest {
DataSource newDataSource = mock(DataSource.class);
try (MockedStatic<DataSourcePoolCreator> mocked =
mockStatic(DataSourcePoolCreator.class)) {
mocked.when(() ->
DataSourcePoolCreator.create(any(DataSourcePoolProperties.class))).thenReturn(newDataSource);
- SwitchingResource actual =
resourceSwitchManager.switchByAlterStorageUnit(resourceMetaData, toBeAltered);
+ SwitchingResource actual =
resourceSwitchManager.switchByAlterStorageUnit(resourceMetaData, toBeAltered,
false);
assertThat(actual.getNewDataSources().size(), is(5));
assertThat(actual.getStaleDataSources().size(), is(5));
assertThat(actual.getStaleStorageUnitNames(),
containsInAnyOrder("0", "1", "2", "3", "4"));
diff --git
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/resource/StorageUnitManagerTest.java
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/resource/StorageUnitManagerTest.java
index 9481c0d047c..b8a0a530649 100644
---
a/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/resource/StorageUnitManagerTest.java
+++
b/mode/core/src/test/java/org/apache/shardingsphere/mode/metadata/manager/resource/StorageUnitManagerTest.java
@@ -18,7 +18,9 @@
package org.apache.shardingsphere.mode.metadata.manager.resource;
import lombok.SneakyThrows;
+import
org.apache.shardingsphere.infra.config.props.temporary.TemporaryConfigurationProperties;
import org.apache.shardingsphere.infra.instance.ComputeNodeInstanceContext;
+import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import
org.apache.shardingsphere.infra.metadata.database.resource.ResourceMetaData;
import
org.apache.shardingsphere.infra.metadata.database.schema.model.ShardingSphereSchema;
@@ -36,9 +38,11 @@ import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
+import java.util.Properties;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
@@ -61,7 +65,7 @@ class StorageUnitManagerTest {
MetaDataContexts metaDataContexts = mockMetaDataContexts();
ResourceSwitchManager resourceSwitchManager =
mock(ResourceSwitchManager.class);
SwitchingResource switchingResource = new
SwitchingResource(Collections.emptyMap(), Collections.emptyMap(),
Collections.emptyList(), Collections.emptyMap());
-
when(resourceSwitchManager.switchByRegisterStorageUnit(any(ResourceMetaData.class),
any(Map.class))).thenReturn(switchingResource);
+
when(resourceSwitchManager.switchByRegisterStorageUnit(any(ResourceMetaData.class),
any(Map.class), anyBoolean())).thenReturn(switchingResource);
ShardingSphereDatabase reloadDatabase =
mock(ShardingSphereDatabase.class);
when(reloadDatabase.getAllSchemas()).thenReturn(Collections.singleton(new
ShardingSphereSchema("foo_schema")));
MetaDataContexts reloadMetaDataContexts = mock(MetaDataContexts.class,
RETURNS_DEEP_STUBS);
@@ -82,7 +86,7 @@ class StorageUnitManagerTest {
ResourceSwitchManager resourceSwitchManager =
mock(ResourceSwitchManager.class);
doAnswer(invocation -> {
throw new SQLException("register error");
-
}).when(resourceSwitchManager).switchByRegisterStorageUnit(any(ResourceMetaData.class),
any(Map.class));
+
}).when(resourceSwitchManager).switchByRegisterStorageUnit(any(ResourceMetaData.class),
any(Map.class), anyBoolean());
assertDoesNotThrow(() -> createManager(metaDataContexts,
resourceSwitchManager).register(DATABASE_NAME, Collections.emptyMap()));
verify(metaDataContexts, never()).update(any(MetaDataContexts.class));
verify(metaDataContexts.getMetaData(),
never()).putDatabase(any(ShardingSphereDatabase.class));
@@ -93,7 +97,7 @@ class StorageUnitManagerTest {
MetaDataContexts metaDataContexts = mockMetaDataContexts();
ResourceSwitchManager resourceSwitchManager =
mock(ResourceSwitchManager.class);
SwitchingResource switchingResource = new
SwitchingResource(Collections.emptyMap(), Collections.emptyMap(),
Collections.emptyList(), Collections.emptyMap());
-
when(resourceSwitchManager.switchByAlterStorageUnit(any(ResourceMetaData.class),
any(Map.class))).thenReturn(switchingResource);
+
when(resourceSwitchManager.switchByAlterStorageUnit(any(ResourceMetaData.class),
any(Map.class), anyBoolean())).thenReturn(switchingResource);
ShardingSphereDatabase reloadDatabase =
mock(ShardingSphereDatabase.class, RETURNS_DEEP_STUBS);
MetaDataContexts reloadMetaDataContexts = mock(MetaDataContexts.class,
RETURNS_DEEP_STUBS);
when(reloadMetaDataContexts.getMetaData().getDatabase(DATABASE_NAME)).thenReturn(reloadDatabase);
@@ -113,7 +117,7 @@ class StorageUnitManagerTest {
ResourceSwitchManager resourceSwitchManager =
mock(ResourceSwitchManager.class);
doAnswer(invocation -> {
throw new SQLException("alter error");
-
}).when(resourceSwitchManager).switchByAlterStorageUnit(any(ResourceMetaData.class),
any(Map.class));
+
}).when(resourceSwitchManager).switchByAlterStorageUnit(any(ResourceMetaData.class),
any(Map.class), anyBoolean());
assertDoesNotThrow(() -> createManager(metaDataContexts,
resourceSwitchManager).alter(DATABASE_NAME, Collections.emptyMap()));
verify(metaDataContexts, never()).update(any(MetaDataContexts.class));
verify(metaDataContexts.getMetaData(),
never()).putDatabase(any(ShardingSphereDatabase.class));
@@ -151,11 +155,14 @@ class StorageUnitManagerTest {
}
private MetaDataContexts mockMetaDataContexts() {
- MetaDataContexts result = mock(MetaDataContexts.class,
RETURNS_DEEP_STUBS);
+ MetaDataContexts result = mock(MetaDataContexts.class);
+ ShardingSphereMetaData metaData = mock(ShardingSphereMetaData.class);
+ when(result.getMetaData()).thenReturn(metaData);
ShardingSphereDatabase database = mock(ShardingSphereDatabase.class,
RETURNS_DEEP_STUBS);
when(database.getResourceMetaData()).thenReturn(new
ResourceMetaData(Collections.emptyMap(), Collections.emptyMap()));
when(database.getRuleMetaData().getRules()).thenReturn(Arrays.asList(mock(ShardingSphereRule.class,
withSettings().extraInterfaces(AutoCloseable.class)),
mock(ShardingSphereRule.class)));
-
when(result.getMetaData().getDatabase(DATABASE_NAME)).thenReturn(database);
+ when(metaData.getDatabase(DATABASE_NAME)).thenReturn(database);
+ when(metaData.getTemporaryProps()).thenReturn(new
TemporaryConfigurationProperties(new Properties()));
return result;
}
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/config/yaml/swapper/YamlProxyConfigurationSwapper.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/config/yaml/swapper/YamlProxyConfigurationSwapper.java
index 94ddfbce4b8..abde5352e30 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/config/yaml/swapper/YamlProxyConfigurationSwapper.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/config/yaml/swapper/YamlProxyConfigurationSwapper.java
@@ -19,6 +19,7 @@ package
org.apache.shardingsphere.proxy.backend.config.yaml.swapper;
import org.apache.shardingsphere.infra.config.database.DatabaseConfiguration;
import
org.apache.shardingsphere.infra.config.database.impl.DataSourceGeneratedDatabaseConfiguration;
+import
org.apache.shardingsphere.infra.config.props.temporary.TemporaryConfigurationPropertyKey;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import
org.apache.shardingsphere.infra.datasource.pool.config.DataSourceConfiguration;
import
org.apache.shardingsphere.infra.datasource.pool.creator.DataSourcePoolCreator;
@@ -57,7 +58,9 @@ public final class YamlProxyConfigurationSwapper {
* @return proxy configuration
*/
public ProxyConfiguration swap(final YamlProxyConfiguration yamlConfig) {
- Map<String, DatabaseConfiguration> databaseConfigs =
swapDatabaseConfigurations(yamlConfig.getDatabaseConfigurations());
+ boolean isInstanceConnectionEnabled =
+ (boolean)
yamlConfig.getServerConfiguration().getProps().getOrDefault(TemporaryConfigurationPropertyKey.INSTANCE_CONNECTION_ENABLED.getKey(),
Boolean.FALSE);
+ Map<String, DatabaseConfiguration> databaseConfigs =
swapDatabaseConfigurations(yamlConfig.getDatabaseConfigurations(),
isInstanceConnectionEnabled);
ProxyGlobalConfiguration globalConfig =
swapGlobalConfiguration(yamlConfig.getServerConfiguration());
return new ProxyConfiguration(databaseConfigs, globalConfig);
}
@@ -76,12 +79,12 @@ public final class YamlProxyConfigurationSwapper {
return DataSourcePoolCreator.create(propsMap, true);
}
- private Map<String, DatabaseConfiguration>
swapDatabaseConfigurations(final Map<String, YamlProxyDatabaseConfiguration>
databaseConfigs) {
+ private Map<String, DatabaseConfiguration>
swapDatabaseConfigurations(final Map<String, YamlProxyDatabaseConfiguration>
databaseConfigs, final boolean isInstanceConnectionEnabled) {
Map<String, DatabaseConfiguration> result = new
LinkedHashMap<>(databaseConfigs.size(), 1F);
for (Entry<String, YamlProxyDatabaseConfiguration> entry :
databaseConfigs.entrySet()) {
Map<String, DataSourceConfiguration> databaseDataSourceConfigs =
swapDataSourceConfigurations(entry.getValue().getDataSources());
Collection<RuleConfiguration> databaseRuleConfigs =
ruleConfigSwapperEngine.swapToRuleConfigurations(entry.getValue().getRules());
- result.put(entry.getKey(), new
DataSourceGeneratedDatabaseConfiguration(databaseDataSourceConfigs,
databaseRuleConfigs));
+ result.put(entry.getKey(), new
DataSourceGeneratedDatabaseConfiguration(databaseDataSourceConfigs,
databaseRuleConfigs, isInstanceConnectionEnabled));
}
return result;
}
diff --git
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutor.java
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutor.java
index 62804d1c4e5..68d351b6eb4 100644
---
a/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutor.java
+++
b/proxy/backend/core/src/main/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutor.java
@@ -21,6 +21,7 @@ import lombok.RequiredArgsConstructor;
import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
import
org.apache.shardingsphere.database.exception.core.exception.syntax.database.DatabaseCreateExistsException;
import
org.apache.shardingsphere.distsql.handler.validate.DistSQLDataSourcePoolPropertiesValidator;
+import
org.apache.shardingsphere.infra.config.props.temporary.TemporaryConfigurationPropertyKey;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import
org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationCheckEngine;
import org.apache.shardingsphere.infra.database.DatabaseTypeEngine;
@@ -112,7 +113,8 @@ public final class YamlDatabaseConfigurationImportExecutor {
validateHandler.validate(propsMap);
contextManager.getPersistServiceFacade().getModeFacade().getMetaDataManagerService().registerStorageUnits(databaseName,
propsMap);
Map<String, StorageUnit> storageUnits =
contextManager.getMetaDataContexts().getMetaData().getDatabase(databaseName).getResourceMetaData().getStorageUnits();
- Map<String, StorageNode> toBeAddedStorageNode =
StorageUnitNodeMapCreator.create(propsMap);
+ boolean isInstanceConnectionEnabled =
contextManager.getMetaDataContexts().getMetaData().getTemporaryProps().<Boolean>getValue(TemporaryConfigurationPropertyKey.INSTANCE_CONNECTION_ENABLED);
+ Map<String, StorageNode> toBeAddedStorageNode =
StorageUnitNodeMapCreator.create(propsMap, isInstanceConnectionEnabled);
for (Entry<String, DataSourcePoolProperties> entry :
propsMap.entrySet()) {
storageUnits.put(entry.getKey(), new
StorageUnit(toBeAddedStorageNode.get(entry.getKey()), entry.getValue(),
DataSourcePoolCreator.create(entry.getValue())));
}
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/queryable/variable/ShowDistVariablesExecutorTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/queryable/variable/ShowDistVariablesExecutorTest.java
index 9d5f1724510..6b6664687e5 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/queryable/variable/ShowDistVariablesExecutorTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/queryable/variable/ShowDistVariablesExecutorTest.java
@@ -76,10 +76,10 @@ class ShowDistVariablesExecutorTest {
ShowDistVariablesExecutor executor = new ShowDistVariablesExecutor();
ShowDistVariablesStatement sqlStatement = new
ShowDistVariablesStatement(true, null);
Collection<LocalDataQueryResultRow> actual =
executor.getRows(sqlStatement, contextManager);
- assertThat(actual.size(), is(3));
+ assertThat(actual.size(), is(4));
LocalDataQueryResultRow row = actual.iterator().next();
- assertThat(row.getCell(1), is("proxy_meta_data_collector_cron"));
- assertThat(row.getCell(2), is("0 0/1 * * * ?"));
+ assertThat(row.getCell(1), is("instance_connection_enabled"));
+ assertThat(row.getCell(2), is("false"));
}
@Test
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/imports/ImportDatabaseConfigurationExecutorTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/imports/ImportDatabaseConfigurationExecutorTest.java
index 31bddadc2d3..c30e4931ccf 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/imports/ImportDatabaseConfigurationExecutorTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/imports/ImportDatabaseConfigurationExecutorTest.java
@@ -22,6 +22,7 @@ import
org.apache.shardingsphere.database.exception.core.exception.syntax.databa
import
org.apache.shardingsphere.distsql.statement.type.ral.updatable.ImportDatabaseConfigurationStatement;
import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
import org.apache.shardingsphere.infra.config.props.ConfigurationPropertyKey;
+import
org.apache.shardingsphere.infra.config.props.temporary.TemporaryConfigurationProperties;
import
org.apache.shardingsphere.infra.exception.kernel.metadata.MissingRequiredDatabaseException;
import
org.apache.shardingsphere.infra.exception.kernel.metadata.rule.DuplicateRuleException;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
@@ -41,6 +42,7 @@ import java.net.URL;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
+import java.util.Properties;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
@@ -130,6 +132,7 @@ class ImportDatabaseConfigurationExecutorTest {
when(result.getMetaDataContexts().getMetaData().getDatabase(databaseName)).thenReturn(database);
when(result.getMetaDataContexts().getMetaData().getProps()).thenReturn(
new ConfigurationProperties(PropertiesBuilder.build(new
Property(ConfigurationPropertyKey.PROXY_FRONTEND_DATABASE_PROTOCOL_TYPE.getKey(),
"MySQL"))));
+
when(result.getMetaDataContexts().getMetaData().getTemporaryProps()).thenReturn(new
TemporaryConfigurationProperties(new Properties()));
return result;
}
}
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/imports/ImportMetaDataExecutorTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/imports/ImportMetaDataExecutorTest.java
index ff910fe0b84..43c10d4019c 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/imports/ImportMetaDataExecutorTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/handler/distsql/ral/updatable/imports/ImportMetaDataExecutorTest.java
@@ -28,6 +28,7 @@ import
org.apache.shardingsphere.globalclock.rule.builder.DefaultGlobalClockRule
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.config.props.temporary.TemporaryConfigurationProperties;
import
org.apache.shardingsphere.infra.datasource.pool.props.creator.DataSourcePoolPropertiesCreator;
import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
import
org.apache.shardingsphere.infra.exception.kernel.metadata.resource.storageunit.EmptyStorageUnitException;
@@ -60,6 +61,7 @@ import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
+import java.util.Properties;
import java.util.stream.Collectors;
import static org.junit.jupiter.api.Assertions.assertNotNull;
@@ -92,6 +94,7 @@ class ImportMetaDataExecutorTest {
void assertImportEmptyMetaData() {
ImportMetaDataExecutor executor = new ImportMetaDataExecutor();
ContextManager contextManager = mock(ContextManager.class,
RETURNS_DEEP_STUBS);
+
when(contextManager.getMetaDataContexts().getMetaData().getTemporaryProps()).thenReturn(new
TemporaryConfigurationProperties(new Properties()));
assertThrows(EmptyStorageUnitException.class, () ->
executor.executeUpdate(
new ImportMetaDataStatement(null,
Objects.requireNonNull(ImportMetaDataExecutorTest.class.getResource(featureMap.get(EMPTY_DATABASE_NAME))).getPath()),
contextManager));
}
@@ -99,6 +102,7 @@ class ImportMetaDataExecutorTest {
@Test
void assertImportMetaDataFromJsonValue() {
ContextManager contextManager = mock(ContextManager.class,
RETURNS_DEEP_STUBS);
+
when(contextManager.getMetaDataContexts().getMetaData().getTemporaryProps()).thenReturn(new
TemporaryConfigurationProperties(new Properties()));
ImportMetaDataExecutor executor = new ImportMetaDataExecutor();
executor.executeUpdate(new
ImportMetaDataStatement(Base64.encodeBase64String(METADATA_VALUE.getBytes()),
null), contextManager);
assertNotNull(contextManager.getDatabase("normal_db"));
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutorTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutorTest.java
index 3c41f7f7e07..a2047247e39 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutorTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/util/YamlDatabaseConfigurationImportExecutorTest.java
@@ -20,6 +20,7 @@ package org.apache.shardingsphere.proxy.backend.util;
import org.apache.shardingsphere.database.connector.core.type.DatabaseType;
import
org.apache.shardingsphere.distsql.handler.validate.DistSQLDataSourcePoolPropertiesValidator;
import org.apache.shardingsphere.infra.config.props.ConfigurationProperties;
+import
org.apache.shardingsphere.infra.config.props.temporary.TemporaryConfigurationProperties;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import
org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationCheckEngine;
import
org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
@@ -29,6 +30,7 @@ import
org.apache.shardingsphere.infra.datasource.pool.creator.DataSourcePoolCre
import
org.apache.shardingsphere.infra.datasource.pool.props.creator.DataSourcePoolPropertiesCreator;
import
org.apache.shardingsphere.infra.datasource.pool.props.domain.DataSourcePoolProperties;
import
org.apache.shardingsphere.infra.exception.external.sql.ShardingSphereSQLException;
+import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import
org.apache.shardingsphere.infra.metadata.database.resource.ResourceMetaData;
import
org.apache.shardingsphere.infra.metadata.database.resource.node.StorageNode;
@@ -71,6 +73,7 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyCollection;
import static org.mockito.ArgumentMatchers.anyMap;
import static org.mockito.ArgumentMatchers.anyString;
@@ -123,7 +126,7 @@ class YamlDatabaseConfigurationImportExecutorTest {
when(dataSourceConfigSwapper.swap(any(YamlProxyDataSourceConfiguration.class))).thenReturn(dataSourceConfig);
DataSourcePoolProperties poolProperties =
mock(DataSourcePoolProperties.class, RETURNS_DEEP_STUBS);
when(DataSourcePoolPropertiesCreator.create(dataSourceConfig)).thenReturn(poolProperties);
-
when(StorageUnitNodeMapCreator.create(anyMap())).thenReturn(Collections.singletonMap("foo_ds",
mock(StorageNode.class)));
+ when(StorageUnitNodeMapCreator.create(anyMap(),
anyBoolean())).thenReturn(Collections.singletonMap("foo_ds",
mock(StorageNode.class)));
when(DataSourcePoolCreator.create(poolProperties)).thenReturn(mock(DataSource.class));
when(DatabaseTypeEngine.getProtocolType(anyMap(),
any(ConfigurationProperties.class))).thenReturn(mock(DatabaseType.class));
try (MockedConstruction<StorageUnit> mockedConstruction =
mockConstruction(StorageUnit.class, (mock, context) -> {
@@ -148,7 +151,7 @@ class YamlDatabaseConfigurationImportExecutorTest {
when(dataSourceConfigSwapper.swap(any(YamlProxyDataSourceConfiguration.class))).thenReturn(dataSourceConfig);
DataSourcePoolProperties poolProperties =
mock(DataSourcePoolProperties.class, RETURNS_DEEP_STUBS);
when(DataSourcePoolPropertiesCreator.create(dataSourceConfig)).thenReturn(poolProperties);
-
when(StorageUnitNodeMapCreator.create(anyMap())).thenReturn(Collections.singletonMap("foo_ds",
mock(StorageNode.class)));
+ when(StorageUnitNodeMapCreator.create(anyMap(),
anyBoolean())).thenReturn(Collections.singletonMap("foo_ds",
mock(StorageNode.class)));
when(DataSourcePoolCreator.create(poolProperties)).thenReturn(mock(DataSource.class));
when(DatabaseTypeEngine.getProtocolType(anyMap(),
any(ConfigurationProperties.class))).thenReturn(mock(DatabaseType.class));
try (MockedConstruction<StorageUnit> ignored =
mockConstruction(StorageUnit.class)) {
@@ -172,7 +175,7 @@ class YamlDatabaseConfigurationImportExecutorTest {
when(dataSourceConfigSwapper.swap(any(YamlProxyDataSourceConfiguration.class))).thenReturn(dataSourceConfig);
DataSourcePoolProperties poolProperties =
mock(DataSourcePoolProperties.class, RETURNS_DEEP_STUBS);
when(DataSourcePoolPropertiesCreator.create(dataSourceConfig)).thenReturn(poolProperties);
-
when(StorageUnitNodeMapCreator.create(anyMap())).thenReturn(Collections.singletonMap("foo_ds",
mock(StorageNode.class)));
+ when(StorageUnitNodeMapCreator.create(anyMap(),
anyBoolean())).thenReturn(Collections.singletonMap("foo_ds",
mock(StorageNode.class)));
when(DataSourcePoolCreator.create(poolProperties)).thenReturn(mock(DataSource.class));
when(DatabaseTypeEngine.getProtocolType(anyMap(),
any(ConfigurationProperties.class))).thenReturn(mock(DatabaseType.class));
YamlRuleConfiguration yamlRuleConfig =
mock(YamlRuleConfiguration.class);
@@ -235,9 +238,12 @@ class YamlDatabaseConfigurationImportExecutorTest {
}
private void mockMetaDataContexts(final ShardingSphereDatabase database,
final ConfigurationProperties props) {
- MetaDataContexts metaDataContexts = mock(MetaDataContexts.class,
RETURNS_DEEP_STUBS);
-
when(metaDataContexts.getMetaData().getDatabase("foo_db")).thenReturn(database);
- when(metaDataContexts.getMetaData().getProps()).thenReturn(props);
-
when(contextManager.getMetaDataContexts()).thenReturn(metaDataContexts);
+ MetaDataContexts metaDataContexts = mock(MetaDataContexts.class);
+ ShardingSphereMetaData metaData = mock(ShardingSphereMetaData.class);
+ lenient().when(metaData.getDatabase("foo_db")).thenReturn(database);
+ lenient().when(metaData.getProps()).thenReturn(props);
+ lenient().when(metaData.getTemporaryProps()).thenReturn(new
TemporaryConfigurationProperties(new Properties()));
+ when(metaDataContexts.getMetaData()).thenReturn(metaData);
+
lenient().when(contextManager.getMetaDataContexts()).thenReturn(metaDataContexts);
}
}
diff --git
a/test/e2e/operation/transaction/src/test/resources/env/mysql/global.yaml
b/test/e2e/operation/transaction/src/test/resources/env/mysql/global.yaml
index 0485107a638..f6ce39388d2 100644
--- a/test/e2e/operation/transaction/src/test/resources/env/mysql/global.yaml
+++ b/test/e2e/operation/transaction/src/test/resources/env/mysql/global.yaml
@@ -43,3 +43,4 @@ props:
proxy-frontend-flush-threshold: 128
sql-show: true
proxy-frontend-ssl-enabled: true
+ instance-connection-enabled: true
