This is an automated email from the ASF dual-hosted git repository.
sunnianjun 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 bc095bd4052 Rename ReadwriteSplittingDataSourceGroupRuleConfiguration
(#31016)
bc095bd4052 is described below
commit bc095bd405210e89aac60b80d1448645c9a302c7
Author: Liang Zhang <[email protected]>
AuthorDate: Thu Apr 25 23:59:02 2024 +0800
Rename ReadwriteSplittingDataSourceGroupRuleConfiguration (#31016)
* Rename ReadwriteSplittingDataSourceGroupRuleConfiguration
* Rename ReadwriteSplittingDataSourceGroupRuleConfiguration
---
.../java-api/rules/readwrite-splitting.cn.md | 2 +-
.../java-api/rules/readwrite-splitting.en.md | 2 +-
.../template/java/config/Configuration.ftl | 2 +-
.../api/ReadwriteSplittingRuleConfiguration.java | 6 ++--
...SplittingDataSourceGroupRuleConfiguration.java} | 6 ++--
...plittingDataSourceRuleConfigurationChecker.java | 7 ++--
...ReadwriteSplittingRuleConfigurationChecker.java | 10 +++---
.../ReadwriteSplittingDataSourceGroupRule.java | 6 ++--
.../rule/ReadwriteSplittingRule.java | 24 +++++++-------
...adwriteSplittingDataSourceChangedProcessor.java | 18 +++++-----
...eSplittingDataNodeRuleConfigurationSwapper.java | 24 +++++++-------
...ReadwriteSplittingRuleConfigurationSwapper.java | 22 ++++++-------
...writeSplittingRuleConfigurationCheckerTest.java | 38 +++++++++++-----------
.../route/ReadwriteSplittingSQLRouterTest.java | 4 +--
...SplittingTransactionalDataSourceRouterTest.java | 12 +++----
...dardReadwriteSplittingDataSourceRouterTest.java | 4 +--
.../filter/DisabledReadDataSourcesFilterTest.java | 4 +--
.../ReadwriteSplittingDataSourceGroupRuleTest.java | 4 +--
.../rule/ReadwriteSplittingRuleTest.java | 8 ++---
...SplittingDataSourceMapperRuleAttributeTest.java | 4 +--
.../builder/ReadwriteSplittingRuleBuilderTest.java | 4 +--
...ittingDataNodeRuleConfigurationSwapperTest.java | 18 +++++-----
...writeSplittingRuleConfigurationSwapperTest.java | 12 +++----
.../ReadwriteSplittingRuleStatementChecker.java | 8 ++---
.../ReadwriteSplittingRuleStatementConverter.java | 17 +++++-----
...littingRuleConfigurationToDistSQLConverter.java | 16 ++++-----
...UsedReadwriteSplittingStorageUnitRetriever.java | 4 +--
.../query/ShowReadwriteSplittingRuleExecutor.java | 24 +++++++-------
.../AlterReadwriteSplittingRuleExecutor.java | 12 +++----
.../CreateReadwriteSplittingRuleExecutor.java | 4 +--
.../update/DropReadwriteSplittingRuleExecutor.java | 20 +++++++-----
...adwriteSplittingRuleStatementConverterTest.java | 10 +++---
...ingRuleConfigurationToDistSQLConverterTest.java | 10 +++---
.../ShowReadwriteSplittingRuleExecutorTest.java | 14 ++++----
.../AlterReadwriteSplittingRuleExecutorTest.java | 18 +++++-----
.../CreateReadwriteSplittingRuleExecutorTest.java | 8 ++---
.../DropReadwriteSplittingRuleExecutorTest.java | 26 +++++++--------
.../swapper/YamlProxyConfigurationSwapperTest.java | 12 +++----
38 files changed, 224 insertions(+), 220 deletions(-)
diff --git
a/docs/document/content/user-manual/shardingsphere-jdbc/java-api/rules/readwrite-splitting.cn.md
b/docs/document/content/user-manual/shardingsphere-jdbc/java-api/rules/readwrite-splitting.cn.md
index 479ce677c31..a324b5b80af 100644
---
a/docs/document/content/user-manual/shardingsphere-jdbc/java-api/rules/readwrite-splitting.cn.md
+++
b/docs/document/content/user-manual/shardingsphere-jdbc/java-api/rules/readwrite-splitting.cn.md
@@ -22,7 +22,7 @@ Java API 形式配置的读写分离可以方便的适用于各种场景，不
## 主从数据源配置
-类名称：org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration
+类名称：org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration
可配置属性：
diff --git
a/docs/document/content/user-manual/shardingsphere-jdbc/java-api/rules/readwrite-splitting.en.md
b/docs/document/content/user-manual/shardingsphere-jdbc/java-api/rules/readwrite-splitting.en.md
index 2f655ef05f0..4ed52171247 100644
---
a/docs/document/content/user-manual/shardingsphere-jdbc/java-api/rules/readwrite-splitting.en.md
+++
b/docs/document/content/user-manual/shardingsphere-jdbc/java-api/rules/readwrite-splitting.en.md
@@ -22,7 +22,7 @@ Configurable Properties:
### Primary-secondary Data Source Configuration
-Class name:
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration
+Class name:
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration
Configurable Properties:
diff --git
a/examples/shardingsphere-jdbc-example-generator/src/main/resources/template/java/config/Configuration.ftl
b/examples/shardingsphere-jdbc-example-generator/src/main/resources/template/java/config/Configuration.ftl
index a8d7ff538d3..14f156a6b4c 100644
---
a/examples/shardingsphere-jdbc-example-generator/src/main/resources/template/java/config/Configuration.ftl
+++
b/examples/shardingsphere-jdbc-example-generator/src/main/resources/template/java/config/Configuration.ftl
@@ -39,7 +39,7 @@ import
org.apache.shardingsphere.broadcast.api.config.BroadcastRuleConfiguration
</#if>
<#if feature?contains("readwrite-splitting")>
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
</#if>
<#if feature?contains("encrypt")>
import org.apache.shardingsphere.infra.config.algorithm.AlgorithmConfiguration;
diff --git
a/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/api/ReadwriteSplittingRuleConfiguration.java
b/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/api/ReadwriteSplittingRuleConfiguration.java
index bf95483ab97..e34e337733b 100644
---
a/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/api/ReadwriteSplittingRuleConfiguration.java
+++
b/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/api/ReadwriteSplittingRuleConfiguration.java
@@ -22,7 +22,7 @@ import lombok.RequiredArgsConstructor;
import
org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
import
org.apache.shardingsphere.infra.config.rule.function.DistributedRuleConfiguration;
import
org.apache.shardingsphere.infra.config.rule.scope.DatabaseRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import java.util.Collection;
import java.util.Map;
@@ -34,12 +34,12 @@ import java.util.Map;
@Getter
public final class ReadwriteSplittingRuleConfiguration implements
DatabaseRuleConfiguration, DistributedRuleConfiguration {
- private final Collection<ReadwriteSplittingDataSourceRuleConfiguration>
dataSources;
+ private final
Collection<ReadwriteSplittingDataSourceGroupRuleConfiguration> dataSourceGroups;
private final Map<String, AlgorithmConfiguration> loadBalancers;
@Override
public boolean isEmpty() {
- return dataSources.isEmpty();
+ return dataSourceGroups.isEmpty();
}
}
diff --git
a/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/api/rule/ReadwriteSplittingDataSourceRuleConfiguration.java
b/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/api/rule/ReadwriteSplittingDataSourceGroupRuleConfiguration.java
similarity index 82%
rename from
features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/api/rule/ReadwriteSplittingDataSourceRuleConfiguration.java
rename to
features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/api/rule/ReadwriteSplittingDataSourceGroupRuleConfiguration.java
index a330d40e8da..bb13eb34ddc 100644
---
a/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/api/rule/ReadwriteSplittingDataSourceRuleConfiguration.java
+++
b/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/api/rule/ReadwriteSplittingDataSourceGroupRuleConfiguration.java
@@ -24,11 +24,11 @@ import
org.apache.shardingsphere.readwritesplitting.api.transaction.Transactiona
import java.util.List;
/**
- * Readwrite-splitting data source rule configuration.
+ * Readwrite-splitting data source group rule configuration.
*/
@RequiredArgsConstructor
@Getter
-public final class ReadwriteSplittingDataSourceRuleConfiguration {
+public final class ReadwriteSplittingDataSourceGroupRuleConfiguration {
private final String name;
@@ -40,7 +40,7 @@ public final class
ReadwriteSplittingDataSourceRuleConfiguration {
private final String loadBalancerName;
- public ReadwriteSplittingDataSourceRuleConfiguration(final String name,
final String writeDataSourceName, final List<String> readDataSourceNames, final
String loadBalancerName) {
+ public ReadwriteSplittingDataSourceGroupRuleConfiguration(final String
name, final String writeDataSourceName, final List<String> readDataSourceNames,
final String loadBalancerName) {
this(name, writeDataSourceName, readDataSourceNames,
TransactionalReadQueryStrategy.DYNAMIC, loadBalancerName);
}
}
diff --git
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingDataSourceRuleConfigurationChecker.java
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingDataSourceRuleConfigurationChecker.java
index ca9d4b68a1f..730a7406cd2 100644
---
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingDataSourceRuleConfigurationChecker.java
+++
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingDataSourceRuleConfigurationChecker.java
@@ -21,7 +21,7 @@ import
org.apache.shardingsphere.infra.exception.core.ShardingSpherePrecondition
import org.apache.shardingsphere.infra.expr.core.InlineExpressionParserFactory;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import
org.apache.shardingsphere.infra.rule.attribute.datasource.DataSourceMapperRuleAttribute;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.constant.ReadwriteSplittingDataSourceType;
import
org.apache.shardingsphere.readwritesplitting.exception.ReadwriteSplittingRuleExceptionIdentifier;
import
org.apache.shardingsphere.readwritesplitting.exception.actual.DuplicateReadwriteSplittingActualDataSourceException;
@@ -40,13 +40,14 @@ public final class
ReadwriteSplittingDataSourceRuleConfigurationChecker {
private final String databaseName;
- private final ReadwriteSplittingDataSourceRuleConfiguration config;
+ private final ReadwriteSplittingDataSourceGroupRuleConfiguration config;
private final Map<String, DataSource> dataSourceMap;
private final ReadwriteSplittingRuleExceptionIdentifier
exceptionIdentifier;
- public ReadwriteSplittingDataSourceRuleConfigurationChecker(final String
databaseName, final ReadwriteSplittingDataSourceRuleConfiguration config, final
Map<String, DataSource> dataSourceMap) {
+ public ReadwriteSplittingDataSourceRuleConfigurationChecker(final String
databaseName,
+ final
ReadwriteSplittingDataSourceGroupRuleConfiguration config, final Map<String,
DataSource> dataSourceMap) {
this.databaseName = databaseName;
this.config = config;
this.dataSourceMap = dataSourceMap;
diff --git
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingRuleConfigurationChecker.java
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingRuleConfigurationChecker.java
index 0b1c5a3d4ca..c43135b1245 100644
---
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingRuleConfigurationChecker.java
+++
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingRuleConfigurationChecker.java
@@ -26,7 +26,7 @@ import
org.apache.shardingsphere.infra.exception.core.external.sql.identifier.SQ
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.constant.ReadwriteSplittingOrder;
import javax.sql.DataSource;
@@ -44,11 +44,11 @@ public final class
ReadwriteSplittingRuleConfigurationChecker implements RuleCon
@Override
public void check(final String databaseName, final
ReadwriteSplittingRuleConfiguration ruleConfig, final Map<String, DataSource>
dataSourceMap, final Collection<ShardingSphereRule> builtRules) {
- checkDataSources(databaseName, ruleConfig.getDataSources(),
dataSourceMap, builtRules);
+ checkDataSources(databaseName, ruleConfig.getDataSourceGroups(),
dataSourceMap, builtRules);
checkLoadBalancer(databaseName, ruleConfig);
}
- private void checkDataSources(final String databaseName, final
Collection<ReadwriteSplittingDataSourceRuleConfiguration> configs,
+ private void checkDataSources(final String databaseName, final
Collection<ReadwriteSplittingDataSourceGroupRuleConfiguration> configs,
final Map<String, DataSource> dataSourceMap,
final Collection<ShardingSphereRule> builtRules) {
Collection<String> builtWriteDataSourceNames = new HashSet<>();
Collection<String> builtReadDataSourceNames = new HashSet<>();
@@ -58,7 +58,7 @@ public final class ReadwriteSplittingRuleConfigurationChecker
implements RuleCon
private void checkLoadBalancer(final String databaseName, final
ReadwriteSplittingRuleConfiguration ruleConfig) {
Map<String, LoadBalanceAlgorithm> loadBalancers =
ruleConfig.getLoadBalancers().entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, entry ->
TypedSPILoader.getService(LoadBalanceAlgorithm.class,
entry.getValue().getType(), entry.getValue().getProps())));
- for (ReadwriteSplittingDataSourceRuleConfiguration each :
ruleConfig.getDataSources()) {
+ for (ReadwriteSplittingDataSourceGroupRuleConfiguration each :
ruleConfig.getDataSourceGroups()) {
if (Strings.isNullOrEmpty(each.getLoadBalancerName())) {
continue;
}
@@ -71,7 +71,7 @@ public final class ReadwriteSplittingRuleConfigurationChecker
implements RuleCon
@Override
public Collection<String> getRequiredDataSourceNames(final
ReadwriteSplittingRuleConfiguration ruleConfig) {
Collection<String> result = new LinkedHashSet<>();
- for (ReadwriteSplittingDataSourceRuleConfiguration each :
ruleConfig.getDataSources()) {
+ for (ReadwriteSplittingDataSourceGroupRuleConfiguration each :
ruleConfig.getDataSourceGroups()) {
if (null != each.getWriteDataSourceName()) {
result.add(each.getWriteDataSourceName());
}
diff --git
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceGroupRule.java
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceGroupRule.java
index 74b8c050eef..afd5e3048ad 100644
---
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceGroupRule.java
+++
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceGroupRule.java
@@ -19,7 +19,7 @@ package org.apache.shardingsphere.readwritesplitting.rule;
import lombok.Getter;
import
org.apache.shardingsphere.infra.algorithm.loadbalancer.core.LoadBalanceAlgorithm;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.api.transaction.TransactionalReadQueryStrategy;
import
org.apache.shardingsphere.readwritesplitting.group.ReadwriteSplittingGroup;
import
org.apache.shardingsphere.readwritesplitting.group.type.StaticReadwriteSplittingGroup;
@@ -43,7 +43,7 @@ public final class ReadwriteSplittingDataSourceGroupRule {
private final Collection<String> disabledDataSourceNames = new HashSet<>();
- public ReadwriteSplittingDataSourceGroupRule(final
ReadwriteSplittingDataSourceRuleConfiguration config,
+ public ReadwriteSplittingDataSourceGroupRule(final
ReadwriteSplittingDataSourceGroupRuleConfiguration config,
final
TransactionalReadQueryStrategy transactionalReadQueryStrategy, final
LoadBalanceAlgorithm loadBalancer) {
name = config.getName();
this.transactionalReadQueryStrategy = transactionalReadQueryStrategy;
@@ -51,7 +51,7 @@ public final class ReadwriteSplittingDataSourceGroupRule {
readwriteSplittingGroup = createStaticReadwriteSplittingGroup(config);
}
- private StaticReadwriteSplittingGroup
createStaticReadwriteSplittingGroup(final
ReadwriteSplittingDataSourceRuleConfiguration config) {
+ private StaticReadwriteSplittingGroup
createStaticReadwriteSplittingGroup(final
ReadwriteSplittingDataSourceGroupRuleConfiguration config) {
return new
StaticReadwriteSplittingGroup(config.getWriteDataSourceName(),
config.getReadDataSourceNames());
}
diff --git
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRule.java
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRule.java
index 4b8c4bdb86e..8921f042104 100644
---
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRule.java
+++
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRule.java
@@ -27,7 +27,7 @@ import
org.apache.shardingsphere.infra.rule.attribute.RuleAttributes;
import org.apache.shardingsphere.infra.rule.scope.DatabaseRule;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.constant.ReadwriteSplittingDataSourceType;
import
org.apache.shardingsphere.readwritesplitting.exception.ReadwriteSplittingRuleExceptionIdentifier;
import
org.apache.shardingsphere.readwritesplitting.exception.actual.InvalidReadwriteSplittingActualDataSourceInlineExpressionException;
@@ -70,8 +70,8 @@ public final class ReadwriteSplittingRule implements
DatabaseRule {
}
private Map<String, LoadBalanceAlgorithm> createLoadBalancers(final
ReadwriteSplittingRuleConfiguration ruleConfig) {
- Map<String, LoadBalanceAlgorithm> result = new
HashMap<>(ruleConfig.getDataSources().size(), 1F);
- for (ReadwriteSplittingDataSourceRuleConfiguration each :
ruleConfig.getDataSources()) {
+ Map<String, LoadBalanceAlgorithm> result = new
HashMap<>(ruleConfig.getDataSourceGroups().size(), 1F);
+ for (ReadwriteSplittingDataSourceGroupRuleConfiguration each :
ruleConfig.getDataSourceGroups()) {
if
(ruleConfig.getLoadBalancers().containsKey(each.getLoadBalancerName())) {
AlgorithmConfiguration algorithmConfig =
ruleConfig.getLoadBalancers().get(each.getLoadBalancerName());
result.put(each.getName() + "." + each.getLoadBalancerName(),
TypedSPILoader.getService(LoadBalanceAlgorithm.class,
algorithmConfig.getType(), algorithmConfig.getProps()));
@@ -81,19 +81,19 @@ public final class ReadwriteSplittingRule implements
DatabaseRule {
}
private Map<String, ReadwriteSplittingDataSourceGroupRule>
createDataSourceGroupRules(final String databaseName, final
ReadwriteSplittingRuleConfiguration ruleConfig) {
- Map<String, ReadwriteSplittingDataSourceGroupRule> result = new
HashMap<>(ruleConfig.getDataSources().size(), 1F);
- for (ReadwriteSplittingDataSourceRuleConfiguration each :
ruleConfig.getDataSources()) {
+ Map<String, ReadwriteSplittingDataSourceGroupRule> result = new
HashMap<>(ruleConfig.getDataSourceGroups().size(), 1F);
+ for (ReadwriteSplittingDataSourceGroupRuleConfiguration each :
ruleConfig.getDataSourceGroups()) {
result.putAll(createDataSourceGroupRules(databaseName, each));
}
return result;
}
- private Map<String, ReadwriteSplittingDataSourceGroupRule>
createDataSourceGroupRules(final String databaseName, final
ReadwriteSplittingDataSourceRuleConfiguration config) {
+ private Map<String, ReadwriteSplittingDataSourceGroupRule>
createDataSourceGroupRules(final String databaseName, final
ReadwriteSplittingDataSourceGroupRuleConfiguration config) {
LoadBalanceAlgorithm loadBalanceAlgorithm =
loadBalancers.getOrDefault(config.getName() + "." +
config.getLoadBalancerName(),
TypedSPILoader.getService(LoadBalanceAlgorithm.class, null));
return createStaticDataSourceGroupRules(databaseName, config,
loadBalanceAlgorithm);
}
- private Map<String, ReadwriteSplittingDataSourceGroupRule>
createStaticDataSourceGroupRules(final String databaseName, final
ReadwriteSplittingDataSourceRuleConfiguration config,
+ private Map<String, ReadwriteSplittingDataSourceGroupRule>
createStaticDataSourceGroupRules(final String databaseName, final
ReadwriteSplittingDataSourceGroupRuleConfiguration config,
final LoadBalanceAlgorithm loadBalanceAlgorithm) {
List<String> inlineLogicDataSourceNames =
InlineExpressionParserFactory.newInstance(config.getName()).splitAndEvaluate();
List<String> inlineWriteDataSourceNames =
InlineExpressionParserFactory.newInstance(config.getWriteDataSourceName()).splitAndEvaluate();
@@ -107,18 +107,18 @@ public final class ReadwriteSplittingRule implements
DatabaseRule {
ReadwriteSplittingDataSourceType.READ, new
ReadwriteSplittingRuleExceptionIdentifier(databaseName, config.getName()))));
Map<String, ReadwriteSplittingDataSourceGroupRule> result = new
HashMap<>(inlineLogicDataSourceNames.size(), 1F);
for (int i = 0; i < inlineLogicDataSourceNames.size(); i++) {
- ReadwriteSplittingDataSourceRuleConfiguration staticConfig =
createStaticDataSourceRuleConfiguration(
+ ReadwriteSplittingDataSourceGroupRuleConfiguration staticConfig =
createStaticDataSourceGroupRuleConfiguration(
config, i, inlineLogicDataSourceNames,
inlineWriteDataSourceNames, inlineReadDataSourceNames);
result.put(inlineLogicDataSourceNames.get(i), new
ReadwriteSplittingDataSourceGroupRule(staticConfig,
config.getTransactionalReadQueryStrategy(), loadBalanceAlgorithm));
}
return result;
}
- private ReadwriteSplittingDataSourceRuleConfiguration
createStaticDataSourceRuleConfiguration(final
ReadwriteSplittingDataSourceRuleConfiguration config, final int index,
-
final List<String> logicDataSourceNames, final List<String>
writeDatasourceNames,
-
final List<List<String>> readDatasourceNames) {
+ private ReadwriteSplittingDataSourceGroupRuleConfiguration
createStaticDataSourceGroupRuleConfiguration(final
ReadwriteSplittingDataSourceGroupRuleConfiguration config, final int index,
+
final List<String> logicDataSourceNames, final
List<String> writeDatasourceNames,
+
final List<List<String>> readDatasourceNames) {
List<String> readDataSourceNames =
readDatasourceNames.stream().map(each ->
each.get(index)).collect(Collectors.toList());
- return new
ReadwriteSplittingDataSourceRuleConfiguration(logicDataSourceNames.get(index),
writeDatasourceNames.get(index), readDataSourceNames,
config.getLoadBalancerName());
+ return new
ReadwriteSplittingDataSourceGroupRuleConfiguration(logicDataSourceNames.get(index),
writeDatasourceNames.get(index), readDataSourceNames,
config.getLoadBalancerName());
}
/**
diff --git
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/changed/ReadwriteSplittingDataSourceChangedProcessor.java
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/changed/ReadwriteSplittingDataSourceChangedProcessor.java
index fbf250a388c..9d0791a81bc 100644
---
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/changed/ReadwriteSplittingDataSourceChangedProcessor.java
+++
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/changed/ReadwriteSplittingDataSourceChangedProcessor.java
@@ -26,7 +26,7 @@ import
org.apache.shardingsphere.infra.rule.event.rule.drop.DropRuleItemEvent;
import org.apache.shardingsphere.infra.util.yaml.YamlEngine;
import
org.apache.shardingsphere.mode.spi.RuleItemConfigurationChangedProcessor;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.api.transaction.TransactionalReadQueryStrategy;
import
org.apache.shardingsphere.readwritesplitting.metadata.nodepath.ReadwriteSplittingRuleNodePathProvider;
import
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
@@ -39,12 +39,14 @@ import java.util.Optional;
/**
* Readwrite-splitting data source changed processor.
*/
-public final class ReadwriteSplittingDataSourceChangedProcessor implements
RuleItemConfigurationChangedProcessor<ReadwriteSplittingRuleConfiguration,
ReadwriteSplittingDataSourceRuleConfiguration> {
+public final class ReadwriteSplittingDataSourceChangedProcessor
+ implements
+
RuleItemConfigurationChangedProcessor<ReadwriteSplittingRuleConfiguration,
ReadwriteSplittingDataSourceGroupRuleConfiguration> {
@Override
- public ReadwriteSplittingDataSourceRuleConfiguration
swapRuleItemConfiguration(final AlterRuleItemEvent event, final String
yamlContent) {
+ public ReadwriteSplittingDataSourceGroupRuleConfiguration
swapRuleItemConfiguration(final AlterRuleItemEvent event, final String
yamlContent) {
YamlReadwriteSplittingDataSourceRuleConfiguration
yamlDataSourceRuleConfig = YamlEngine.unmarshal(yamlContent,
YamlReadwriteSplittingDataSourceRuleConfiguration.class);
- return new
ReadwriteSplittingDataSourceRuleConfiguration(((AlterNamedRuleItemEvent)
event).getItemName(), yamlDataSourceRuleConfig.getWriteDataSourceName(),
+ return new
ReadwriteSplittingDataSourceGroupRuleConfiguration(((AlterNamedRuleItemEvent)
event).getItemName(), yamlDataSourceRuleConfig.getWriteDataSourceName(),
yamlDataSourceRuleConfig.getReadDataSourceNames(),
getTransactionalReadQueryStrategy(yamlDataSourceRuleConfig),
yamlDataSourceRuleConfig.getLoadBalancerName());
}
@@ -63,15 +65,15 @@ public final class
ReadwriteSplittingDataSourceChangedProcessor implements RuleI
@Override
public void changeRuleItemConfiguration(final AlterRuleItemEvent event,
final ReadwriteSplittingRuleConfiguration currentRuleConfig,
- final
ReadwriteSplittingDataSourceRuleConfiguration toBeChangedItemConfig) {
+ final
ReadwriteSplittingDataSourceGroupRuleConfiguration toBeChangedItemConfig) {
// TODO refactor DistSQL to only persist config
- currentRuleConfig.getDataSources().removeIf(each ->
each.getName().equals(toBeChangedItemConfig.getName()));
- currentRuleConfig.getDataSources().add(toBeChangedItemConfig);
+ currentRuleConfig.getDataSourceGroups().removeIf(each ->
each.getName().equals(toBeChangedItemConfig.getName()));
+ currentRuleConfig.getDataSourceGroups().add(toBeChangedItemConfig);
}
@Override
public void dropRuleItemConfiguration(final DropRuleItemEvent event, final
ReadwriteSplittingRuleConfiguration currentRuleConfig) {
- currentRuleConfig.getDataSources().removeIf(each ->
each.getName().equals(((DropNamedRuleItemEvent) event).getItemName()));
+ currentRuleConfig.getDataSourceGroups().removeIf(each ->
each.getName().equals(((DropNamedRuleItemEvent) event).getItemName()));
}
@Override
diff --git
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingDataNodeRuleConfigurationSwapper.java
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingDataNodeRuleConfigurationSwapper.java
index 34303795d04..2013676313a 100644
---
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingDataNodeRuleConfigurationSwapper.java
+++
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingDataNodeRuleConfigurationSwapper.java
@@ -26,7 +26,7 @@ import
org.apache.shardingsphere.infra.algorithm.core.yaml.YamlAlgorithmConfigur
import
org.apache.shardingsphere.infra.algorithm.core.yaml.YamlAlgorithmConfigurationSwapper;
import
org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlDataNodeRuleConfigurationSwapper;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.api.transaction.TransactionalReadQueryStrategy;
import
org.apache.shardingsphere.readwritesplitting.constant.ReadwriteSplittingOrder;
import
org.apache.shardingsphere.readwritesplitting.metadata.nodepath.ReadwriteSplittingRuleNodePathProvider;
@@ -57,19 +57,19 @@ public final class
YamlReadwriteSplittingDataNodeRuleConfigurationSwapper implem
result.add(new
YamlDataNode(readwriteSplittingRuleNodePath.getNamedItem(ReadwriteSplittingRuleNodePathProvider.LOAD_BALANCERS).getPath(entry.getKey()),
YamlEngine.marshal(algorithmSwapper.swapToYamlConfiguration(entry.getValue()))));
}
- for (ReadwriteSplittingDataSourceRuleConfiguration each :
data.getDataSources()) {
+ for (ReadwriteSplittingDataSourceGroupRuleConfiguration each :
data.getDataSourceGroups()) {
result.add(new
YamlDataNode(readwriteSplittingRuleNodePath.getNamedItem(ReadwriteSplittingRuleNodePathProvider.DATA_SOURCES).getPath(each.getName()),
YamlEngine.marshal(swapToYamlConfiguration(each))));
}
return result;
}
- private YamlReadwriteSplittingDataSourceRuleConfiguration
swapToYamlConfiguration(final ReadwriteSplittingDataSourceRuleConfiguration
dataSourceRuleConfig) {
+ private YamlReadwriteSplittingDataSourceRuleConfiguration
swapToYamlConfiguration(final
ReadwriteSplittingDataSourceGroupRuleConfiguration dataSourceRuleGroupConfig) {
YamlReadwriteSplittingDataSourceRuleConfiguration result = new
YamlReadwriteSplittingDataSourceRuleConfiguration();
-
result.setWriteDataSourceName(dataSourceRuleConfig.getWriteDataSourceName());
-
result.setReadDataSourceNames(dataSourceRuleConfig.getReadDataSourceNames());
-
result.setTransactionalReadQueryStrategy(dataSourceRuleConfig.getTransactionalReadQueryStrategy().name());
- result.setLoadBalancerName(dataSourceRuleConfig.getLoadBalancerName());
+
result.setWriteDataSourceName(dataSourceRuleGroupConfig.getWriteDataSourceName());
+
result.setReadDataSourceNames(dataSourceRuleGroupConfig.getReadDataSourceNames());
+
result.setTransactionalReadQueryStrategy(dataSourceRuleGroupConfig.getTransactionalReadQueryStrategy().name());
+
result.setLoadBalancerName(dataSourceRuleGroupConfig.getLoadBalancerName());
return result;
}
@@ -79,19 +79,19 @@ public final class
YamlReadwriteSplittingDataNodeRuleConfigurationSwapper implem
if (validDataNodes.isEmpty()) {
return Optional.empty();
}
- Collection<ReadwriteSplittingDataSourceRuleConfiguration> dataSources
= new LinkedList<>();
+ Collection<ReadwriteSplittingDataSourceGroupRuleConfiguration>
dataSourceGroups = new LinkedList<>();
Map<String, AlgorithmConfiguration> loadBalancerMap = new
LinkedHashMap<>();
for (YamlDataNode each : validDataNodes) {
readwriteSplittingRuleNodePath.getNamedItem(ReadwriteSplittingRuleNodePathProvider.DATA_SOURCES).getName(each.getKey())
- .ifPresent(optional ->
dataSources.add(swapDataSource(optional, YamlEngine.unmarshal(each.getValue(),
YamlReadwriteSplittingDataSourceRuleConfiguration.class))));
+ .ifPresent(optional ->
dataSourceGroups.add(swapDataSourceGroup(optional,
YamlEngine.unmarshal(each.getValue(),
YamlReadwriteSplittingDataSourceRuleConfiguration.class))));
readwriteSplittingRuleNodePath.getNamedItem(ReadwriteSplittingRuleNodePathProvider.LOAD_BALANCERS).getName(each.getKey())
.ifPresent(optional -> loadBalancerMap.put(optional,
algorithmSwapper.swapToObject(YamlEngine.unmarshal(each.getValue(),
YamlAlgorithmConfiguration.class))));
}
- return Optional.of(new
ReadwriteSplittingRuleConfiguration(dataSources, loadBalancerMap));
+ return Optional.of(new
ReadwriteSplittingRuleConfiguration(dataSourceGroups, loadBalancerMap));
}
- private ReadwriteSplittingDataSourceRuleConfiguration swapDataSource(final
String name, final YamlReadwriteSplittingDataSourceRuleConfiguration
yamlDataSourceRuleConfig) {
- return new ReadwriteSplittingDataSourceRuleConfiguration(name,
yamlDataSourceRuleConfig.getWriteDataSourceName(),
yamlDataSourceRuleConfig.getReadDataSourceNames(),
+ private ReadwriteSplittingDataSourceGroupRuleConfiguration
swapDataSourceGroup(final String name, final
YamlReadwriteSplittingDataSourceRuleConfiguration yamlDataSourceRuleConfig) {
+ return new ReadwriteSplittingDataSourceGroupRuleConfiguration(name,
yamlDataSourceRuleConfig.getWriteDataSourceName(),
yamlDataSourceRuleConfig.getReadDataSourceNames(),
getTransactionalReadQueryStrategy(yamlDataSourceRuleConfig),
yamlDataSourceRuleConfig.getLoadBalancerName());
}
diff --git
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingRuleConfigurationSwapper.java
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingRuleConfigurationSwapper.java
index feccff89f82..d6b8d969c57 100644
---
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingRuleConfigurationSwapper.java
+++
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingRuleConfigurationSwapper.java
@@ -22,7 +22,7 @@ import
org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfigurat
import
org.apache.shardingsphere.infra.algorithm.core.yaml.YamlAlgorithmConfigurationSwapper;
import
org.apache.shardingsphere.infra.yaml.config.swapper.rule.YamlRuleConfigurationSwapper;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.api.transaction.TransactionalReadQueryStrategy;
import
org.apache.shardingsphere.readwritesplitting.constant.ReadwriteSplittingOrder;
import
org.apache.shardingsphere.readwritesplitting.yaml.config.YamlReadwriteSplittingRuleConfiguration;
@@ -45,26 +45,26 @@ public final class
YamlReadwriteSplittingRuleConfigurationSwapper implements Yam
@Override
public YamlReadwriteSplittingRuleConfiguration
swapToYamlConfiguration(final ReadwriteSplittingRuleConfiguration data) {
YamlReadwriteSplittingRuleConfiguration result = new
YamlReadwriteSplittingRuleConfiguration();
- result.setDataSources(data.getDataSources().stream().collect(
-
Collectors.toMap(ReadwriteSplittingDataSourceRuleConfiguration::getName,
this::swapToYamlConfiguration, (oldValue, currentValue) -> oldValue,
LinkedHashMap::new)));
+ result.setDataSources(data.getDataSourceGroups().stream().collect(
+
Collectors.toMap(ReadwriteSplittingDataSourceGroupRuleConfiguration::getName,
this::swapToYamlConfiguration, (oldValue, currentValue) -> oldValue,
LinkedHashMap::new)));
if (null != data.getLoadBalancers()) {
data.getLoadBalancers().forEach((key, value) ->
result.getLoadBalancers().put(key,
algorithmSwapper.swapToYamlConfiguration(value)));
}
return result;
}
- private YamlReadwriteSplittingDataSourceRuleConfiguration
swapToYamlConfiguration(final ReadwriteSplittingDataSourceRuleConfiguration
dataSourceRuleConfig) {
+ private YamlReadwriteSplittingDataSourceRuleConfiguration
swapToYamlConfiguration(final
ReadwriteSplittingDataSourceGroupRuleConfiguration dataSourceGroupRuleConfig) {
YamlReadwriteSplittingDataSourceRuleConfiguration result = new
YamlReadwriteSplittingDataSourceRuleConfiguration();
-
result.setWriteDataSourceName(dataSourceRuleConfig.getWriteDataSourceName());
-
result.setReadDataSourceNames(dataSourceRuleConfig.getReadDataSourceNames());
-
result.setTransactionalReadQueryStrategy(dataSourceRuleConfig.getTransactionalReadQueryStrategy().name());
- result.setLoadBalancerName(dataSourceRuleConfig.getLoadBalancerName());
+
result.setWriteDataSourceName(dataSourceGroupRuleConfig.getWriteDataSourceName());
+
result.setReadDataSourceNames(dataSourceGroupRuleConfig.getReadDataSourceNames());
+
result.setTransactionalReadQueryStrategy(dataSourceGroupRuleConfig.getTransactionalReadQueryStrategy().name());
+
result.setLoadBalancerName(dataSourceGroupRuleConfig.getLoadBalancerName());
return result;
}
@Override
public ReadwriteSplittingRuleConfiguration swapToObject(final
YamlReadwriteSplittingRuleConfiguration yamlConfig) {
- Collection<ReadwriteSplittingDataSourceRuleConfiguration> dataSources
= yamlConfig.getDataSources().entrySet().stream()
+ Collection<ReadwriteSplittingDataSourceGroupRuleConfiguration>
dataSources = yamlConfig.getDataSources().entrySet().stream()
.map(entry -> swapToObject(entry.getKey(),
entry.getValue())).collect(Collectors.toList());
Map<String, AlgorithmConfiguration> loadBalancerMap = null ==
yamlConfig.getLoadBalancers()
? Collections.emptyMap()
@@ -72,8 +72,8 @@ public final class
YamlReadwriteSplittingRuleConfigurationSwapper implements Yam
return new ReadwriteSplittingRuleConfiguration(dataSources,
loadBalancerMap);
}
- private ReadwriteSplittingDataSourceRuleConfiguration swapToObject(final
String name, final YamlReadwriteSplittingDataSourceRuleConfiguration
yamlDataSourceRuleConfig) {
- return new ReadwriteSplittingDataSourceRuleConfiguration(name,
yamlDataSourceRuleConfig.getWriteDataSourceName(),
yamlDataSourceRuleConfig.getReadDataSourceNames(),
+ private ReadwriteSplittingDataSourceGroupRuleConfiguration
swapToObject(final String name, final
YamlReadwriteSplittingDataSourceRuleConfiguration yamlDataSourceRuleConfig) {
+ return new ReadwriteSplittingDataSourceGroupRuleConfiguration(name,
yamlDataSourceRuleConfig.getWriteDataSourceName(),
yamlDataSourceRuleConfig.getReadDataSourceNames(),
getTransactionalReadQueryStrategy(yamlDataSourceRuleConfig),
yamlDataSourceRuleConfig.getLoadBalancerName());
}
diff --git
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingRuleConfigurationCheckerTest.java
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingRuleConfigurationCheckerTest.java
index 9ff2b3eef20..0a48221bf6d 100644
---
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingRuleConfigurationCheckerTest.java
+++
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/checker/ReadwriteSplittingRuleConfigurationCheckerTest.java
@@ -25,7 +25,7 @@ import
org.apache.shardingsphere.infra.rule.attribute.RuleAttributes;
import
org.apache.shardingsphere.infra.rule.attribute.datasource.DataSourceMapperRuleAttribute;
import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.exception.actual.ReadwriteSplittingActualDataSourceNotFoundException;
import
org.apache.shardingsphere.readwritesplitting.exception.actual.DuplicateReadwriteSplittingActualDataSourceException;
import
org.apache.shardingsphere.readwritesplitting.exception.actual.MissingRequiredReadwriteSplittingActualDataSourceException;
@@ -59,9 +59,9 @@ class ReadwriteSplittingRuleConfigurationCheckerTest {
private ReadwriteSplittingRuleConfiguration createInvalidConfiguration() {
ReadwriteSplittingRuleConfiguration result =
mock(ReadwriteSplittingRuleConfiguration.class);
- ReadwriteSplittingDataSourceRuleConfiguration dataSourceConfig =
mock(ReadwriteSplittingDataSourceRuleConfiguration.class);
- when(dataSourceConfig.getName()).thenReturn("readwrite_ds");
-
when(result.getDataSources()).thenReturn(Collections.singleton(dataSourceConfig));
+ ReadwriteSplittingDataSourceGroupRuleConfiguration
dataSourceGroupConfig =
mock(ReadwriteSplittingDataSourceGroupRuleConfiguration.class);
+ when(dataSourceGroupConfig.getName()).thenReturn("readwrite_ds");
+
when(result.getDataSourceGroups()).thenReturn(Collections.singleton(dataSourceGroupConfig));
return result;
}
@@ -69,9 +69,9 @@ class ReadwriteSplittingRuleConfigurationCheckerTest {
@Test
void assertCheckWhenConfigInvalidWriteDataSource() {
ReadwriteSplittingRuleConfiguration config =
mock(ReadwriteSplittingRuleConfiguration.class);
- List<ReadwriteSplittingDataSourceRuleConfiguration> configs =
Arrays.asList(createDataSourceRuleConfiguration(
- "write_ds_0", Arrays.asList("read_ds_0", "read_ds_1")),
createDataSourceRuleConfiguration("write_ds_2", Arrays.asList("read_ds_0",
"read_ds_1")));
- when(config.getDataSources()).thenReturn(configs);
+ List<ReadwriteSplittingDataSourceGroupRuleConfiguration> configs =
Arrays.asList(createDataSourceGroupRuleConfiguration(
+ "write_ds_0", Arrays.asList("read_ds_0", "read_ds_1")),
createDataSourceGroupRuleConfiguration("write_ds_2", Arrays.asList("read_ds_0",
"read_ds_1")));
+ when(config.getDataSourceGroups()).thenReturn(configs);
RuleConfigurationChecker checker =
OrderedSPILoader.getServicesByClass(RuleConfigurationChecker.class,
Collections.singleton(config.getClass())).get(config.getClass());
assertThrows(ReadwriteSplittingActualDataSourceNotFoundException.class, () ->
checker.check("test", config, mockDataSources(), Collections.emptyList()));
}
@@ -80,9 +80,9 @@ class ReadwriteSplittingRuleConfigurationCheckerTest {
@Test
void assertCheckWhenConfigInvalidReadDataSource() {
ReadwriteSplittingRuleConfiguration config =
mock(ReadwriteSplittingRuleConfiguration.class);
- List<ReadwriteSplittingDataSourceRuleConfiguration> configs =
Arrays.asList(createDataSourceRuleConfiguration(
- "write_ds_0", Arrays.asList("read_ds_0", "read_ds_0")),
createDataSourceRuleConfiguration("write_ds_1", Arrays.asList("read_ds_0",
"read_ds_0")));
- when(config.getDataSources()).thenReturn(configs);
+ List<ReadwriteSplittingDataSourceGroupRuleConfiguration> configs =
Arrays.asList(createDataSourceGroupRuleConfiguration(
+ "write_ds_0", Arrays.asList("read_ds_0", "read_ds_0")),
createDataSourceGroupRuleConfiguration("write_ds_1", Arrays.asList("read_ds_0",
"read_ds_0")));
+ when(config.getDataSourceGroups()).thenReturn(configs);
RuleConfigurationChecker checker =
OrderedSPILoader.getServicesByClass(RuleConfigurationChecker.class,
Collections.singleton(config.getClass())).get(config.getClass());
assertThrows(DuplicateReadwriteSplittingActualDataSourceException.class, () ->
checker.check("test", config, mockDataSources(), Collections.emptyList()));
}
@@ -91,8 +91,8 @@ class ReadwriteSplittingRuleConfigurationCheckerTest {
@Test
void assertCheckWeightLoadBalanceInvalidDataSourceName() {
ReadwriteSplittingRuleConfiguration config =
mock(ReadwriteSplittingRuleConfiguration.class);
- Collection<ReadwriteSplittingDataSourceRuleConfiguration> configs =
Collections.singleton(createDataSourceRuleConfiguration("write_ds_0",
Arrays.asList("read_ds_0", "read_ds_1")));
- when(config.getDataSources()).thenReturn(configs);
+ Collection<ReadwriteSplittingDataSourceGroupRuleConfiguration> configs
= Collections.singleton(createDataSourceGroupRuleConfiguration("write_ds_0",
Arrays.asList("read_ds_0", "read_ds_1")));
+ when(config.getDataSourceGroups()).thenReturn(configs);
AlgorithmConfiguration algorithm = new
AlgorithmConfiguration("WEIGHT", PropertiesBuilder.build(new
Property("read_ds_2", "1"), new Property("read_ds_1", "2")));
when(config.getLoadBalancers()).thenReturn(Collections.singletonMap("weight_ds",
algorithm));
RuleConfigurationChecker checker =
OrderedSPILoader.getServicesByClass(RuleConfigurationChecker.class,
Collections.singleton(config.getClass())).get(config.getClass());
@@ -113,16 +113,16 @@ class ReadwriteSplittingRuleConfigurationCheckerTest {
private ReadwriteSplittingRuleConfiguration
createContainsOtherRulesDatasourceConfiguration() {
ReadwriteSplittingRuleConfiguration result =
mock(ReadwriteSplittingRuleConfiguration.class);
- ReadwriteSplittingDataSourceRuleConfiguration dataSourceConfig =
mock(ReadwriteSplittingDataSourceRuleConfiguration.class);
- when(dataSourceConfig.getName()).thenReturn("readwrite_ds");
-
when(dataSourceConfig.getWriteDataSourceName()).thenReturn("otherDatasourceName");
-
when(dataSourceConfig.getReadDataSourceNames()).thenReturn(Arrays.asList("read_ds_0",
"read_ds_1"));
-
when(result.getDataSources()).thenReturn(Collections.singleton(dataSourceConfig));
+ ReadwriteSplittingDataSourceGroupRuleConfiguration
dataSourceGroupConfig =
mock(ReadwriteSplittingDataSourceGroupRuleConfiguration.class);
+ when(dataSourceGroupConfig.getName()).thenReturn("readwrite_ds");
+
when(dataSourceGroupConfig.getWriteDataSourceName()).thenReturn("otherDatasourceName");
+
when(dataSourceGroupConfig.getReadDataSourceNames()).thenReturn(Arrays.asList("read_ds_0",
"read_ds_1"));
+
when(result.getDataSourceGroups()).thenReturn(Collections.singleton(dataSourceGroupConfig));
return result;
}
- private ReadwriteSplittingDataSourceRuleConfiguration
createDataSourceRuleConfiguration(final String writeDataSource, final
List<String> readDataSources) {
- ReadwriteSplittingDataSourceRuleConfiguration result =
mock(ReadwriteSplittingDataSourceRuleConfiguration.class);
+ private ReadwriteSplittingDataSourceGroupRuleConfiguration
createDataSourceGroupRuleConfiguration(final String writeDataSource, final
List<String> readDataSources) {
+ ReadwriteSplittingDataSourceGroupRuleConfiguration result =
mock(ReadwriteSplittingDataSourceGroupRuleConfiguration.class);
when(result.getName()).thenReturn("readwrite_ds");
when(result.getWriteDataSourceName()).thenReturn(writeDataSource);
when(result.getReadDataSourceNames()).thenReturn(readDataSources);
diff --git
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/ReadwriteSplittingSQLRouterTest.java
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/ReadwriteSplittingSQLRouterTest.java
index 6a3843258b1..7f487577c7a 100644
---
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/ReadwriteSplittingSQLRouterTest.java
+++
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/ReadwriteSplittingSQLRouterTest.java
@@ -36,7 +36,7 @@ import
org.apache.shardingsphere.infra.session.connection.ConnectionContext;
import org.apache.shardingsphere.infra.session.query.QueryContext;
import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
import
org.apache.shardingsphere.sql.parser.sql.common.segment.dml.predicate.LockSegment;
import
org.apache.shardingsphere.sql.parser.sql.common.statement.dml.InsertStatement;
@@ -80,7 +80,7 @@ class ReadwriteSplittingSQLRouterTest {
@BeforeEach
void setUp() {
- staticRule = new ReadwriteSplittingRule("logic_db", new
ReadwriteSplittingRuleConfiguration(Collections.singleton(new
ReadwriteSplittingDataSourceRuleConfiguration(DATASOURCE_NAME,
+ staticRule = new ReadwriteSplittingRule("logic_db", new
ReadwriteSplittingRuleConfiguration(Collections.singleton(new
ReadwriteSplittingDataSourceGroupRuleConfiguration(DATASOURCE_NAME,
WRITE_DATASOURCE, Collections.singletonList(READ_DATASOURCE),
"")), Collections.emptyMap()), mock(InstanceContext.class));
sqlRouter = (ReadwriteSplittingSQLRouter)
OrderedSPILoader.getServices(SQLRouter.class,
Collections.singleton(staticRule)).get(staticRule);
}
diff --git
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/qualified/type/QualifiedReadwriteSplittingTransactionalDataSourceRouterTest.java
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/qualified/type/QualifiedReadwriteSplittingTransactionalDataSourceRouterTest.java
index 7f7209d399e..8b051430083 100644
---
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/qualified/type/QualifiedReadwriteSplittingTransactionalDataSourceRouterTest.java
+++
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/qualified/type/QualifiedReadwriteSplittingTransactionalDataSourceRouterTest.java
@@ -21,7 +21,7 @@ import
org.apache.shardingsphere.infra.algorithm.loadbalancer.round.robin.RoundR
import org.apache.shardingsphere.infra.hint.HintValueContext;
import org.apache.shardingsphere.infra.session.connection.ConnectionContext;
import
org.apache.shardingsphere.infra.session.connection.transaction.TransactionConnectionContext;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.api.transaction.TransactionalReadQueryStrategy;
import
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
import org.junit.jupiter.api.Test;
@@ -57,14 +57,14 @@ class
QualifiedReadwriteSplittingTransactionalDataSourceRouterTest {
@Test
void assertRoute() {
- ReadwriteSplittingDataSourceRuleConfiguration
readwriteSplittingDataSourceRuleConfig =
- new
ReadwriteSplittingDataSourceRuleConfiguration("test_config", "write_ds",
Arrays.asList("read_ds_0", "read_ds_1"), null);
+ ReadwriteSplittingDataSourceGroupRuleConfiguration
dataSourceGroupConfig = new ReadwriteSplittingDataSourceGroupRuleConfiguration(
+ "test_config", "write_ds", Arrays.asList("read_ds_0",
"read_ds_1"), null);
ReadwriteSplittingDataSourceGroupRule rule;
- rule = new
ReadwriteSplittingDataSourceGroupRule(readwriteSplittingDataSourceRuleConfig,
TransactionalReadQueryStrategy.PRIMARY, null);
+ rule = new
ReadwriteSplittingDataSourceGroupRule(dataSourceGroupConfig,
TransactionalReadQueryStrategy.PRIMARY, null);
assertThat(new
QualifiedReadwriteSplittingTransactionalDataSourceRouter(new
ConnectionContext()).route(rule), is("write_ds"));
- rule = new
ReadwriteSplittingDataSourceGroupRule(readwriteSplittingDataSourceRuleConfig,
TransactionalReadQueryStrategy.FIXED, new RoundRobinLoadBalanceAlgorithm());
+ rule = new
ReadwriteSplittingDataSourceGroupRule(dataSourceGroupConfig,
TransactionalReadQueryStrategy.FIXED, new RoundRobinLoadBalanceAlgorithm());
assertThat(new
QualifiedReadwriteSplittingTransactionalDataSourceRouter(new
ConnectionContext()).route(rule), is("read_ds_0"));
- rule = new
ReadwriteSplittingDataSourceGroupRule(readwriteSplittingDataSourceRuleConfig,
TransactionalReadQueryStrategy.DYNAMIC, new RoundRobinLoadBalanceAlgorithm());
+ rule = new
ReadwriteSplittingDataSourceGroupRule(dataSourceGroupConfig,
TransactionalReadQueryStrategy.DYNAMIC, new RoundRobinLoadBalanceAlgorithm());
assertThat(new
QualifiedReadwriteSplittingTransactionalDataSourceRouter(new
ConnectionContext()).route(rule), is("read_ds_0"));
}
}
diff --git
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/standard/StandardReadwriteSplittingDataSourceRouterTest.java
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/standard/StandardReadwriteSplittingDataSourceRouterTest.java
index 9e6f1165c84..4fc8b3d7ea4 100644
---
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/standard/StandardReadwriteSplittingDataSourceRouterTest.java
+++
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/standard/StandardReadwriteSplittingDataSourceRouterTest.java
@@ -18,7 +18,7 @@
package org.apache.shardingsphere.readwritesplitting.route.standard;
import
org.apache.shardingsphere.infra.algorithm.loadbalancer.round.robin.RoundRobinLoadBalanceAlgorithm;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.api.transaction.TransactionalReadQueryStrategy;
import
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
import org.junit.jupiter.api.BeforeEach;
@@ -36,7 +36,7 @@ class StandardReadwriteSplittingDataSourceRouterTest {
@BeforeEach
void setUp() {
rule = new ReadwriteSplittingDataSourceGroupRule(
- new
ReadwriteSplittingDataSourceRuleConfiguration("test_config", "write_ds",
Arrays.asList("read_ds_0", "read_ds_1"), null),
+ new
ReadwriteSplittingDataSourceGroupRuleConfiguration("test_config", "write_ds",
Arrays.asList("read_ds_0", "read_ds_1"), null),
TransactionalReadQueryStrategy.DYNAMIC, new
RoundRobinLoadBalanceAlgorithm());
}
diff --git
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/standard/filter/DisabledReadDataSourcesFilterTest.java
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/standard/filter/DisabledReadDataSourcesFilterTest.java
index 48f98185fe6..695ff5903e8 100644
---
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/standard/filter/DisabledReadDataSourcesFilterTest.java
+++
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/route/standard/filter/DisabledReadDataSourcesFilterTest.java
@@ -18,7 +18,7 @@
package org.apache.shardingsphere.readwritesplitting.route.standard.filter;
import
org.apache.shardingsphere.infra.algorithm.loadbalancer.random.RandomLoadBalanceAlgorithm;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.api.transaction.TransactionalReadQueryStrategy;
import
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
import org.junit.jupiter.api.BeforeEach;
@@ -37,7 +37,7 @@ class DisabledReadDataSourcesFilterTest {
@BeforeEach
void setUp() {
rule = new ReadwriteSplittingDataSourceGroupRule(
- new ReadwriteSplittingDataSourceRuleConfiguration("test_pr",
"write_ds", Arrays.asList("read_ds_0", "read_ds_1"), null),
+ new
ReadwriteSplittingDataSourceGroupRuleConfiguration("test_pr", "write_ds",
Arrays.asList("read_ds_0", "read_ds_1"), null),
TransactionalReadQueryStrategy.DYNAMIC, new
RandomLoadBalanceAlgorithm());
}
diff --git
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceGroupRuleTest.java
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceGroupRuleTest.java
index 0c9435323b7..d83ead15d18 100644
---
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceGroupRuleTest.java
+++
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceGroupRuleTest.java
@@ -18,7 +18,7 @@
package org.apache.shardingsphere.readwritesplitting.rule;
import
org.apache.shardingsphere.infra.algorithm.loadbalancer.random.RandomLoadBalanceAlgorithm;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.api.transaction.TransactionalReadQueryStrategy;
import org.junit.jupiter.api.Test;
@@ -32,7 +32,7 @@ class ReadwriteSplittingDataSourceGroupRuleTest {
@Test
void assertGetWriteDataSource() {
ReadwriteSplittingDataSourceGroupRule dataSourceGroupRule = new
ReadwriteSplittingDataSourceGroupRule(
- new ReadwriteSplittingDataSourceRuleConfiguration("test_pr",
"write_ds", Arrays.asList("read_ds_0", "read_ds_1"),
TransactionalReadQueryStrategy.DYNAMIC, null),
+ new
ReadwriteSplittingDataSourceGroupRuleConfiguration("test_pr", "write_ds",
Arrays.asList("read_ds_0", "read_ds_1"),
TransactionalReadQueryStrategy.DYNAMIC, null),
TransactionalReadQueryStrategy.DYNAMIC, new
RandomLoadBalanceAlgorithm());
String writeDataSourceName = dataSourceGroupRule.getWriteDataSource();
assertThat(writeDataSourceName, is("write_ds"));
diff --git
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRuleTest.java
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRuleTest.java
index 1dceb8be9a0..e08fbaf32cb 100644
---
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRuleTest.java
+++
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRuleTest.java
@@ -23,7 +23,7 @@ import
org.apache.shardingsphere.infra.metadata.database.schema.QualifiedDataSou
import
org.apache.shardingsphere.infra.rule.attribute.datasource.StaticDataSourceRuleAttribute;
import org.apache.shardingsphere.infra.state.datasource.DataSourceState;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import org.junit.jupiter.api.Test;
import java.util.Arrays;
@@ -51,8 +51,8 @@ class ReadwriteSplittingRuleTest {
}
private ReadwriteSplittingRule createReadwriteSplittingRule() {
- ReadwriteSplittingDataSourceRuleConfiguration config =
- new ReadwriteSplittingDataSourceRuleConfiguration("readwrite",
"write_ds", Arrays.asList("read_ds_0", "read_ds_1"), "random");
+ ReadwriteSplittingDataSourceGroupRuleConfiguration config =
+ new
ReadwriteSplittingDataSourceGroupRuleConfiguration("readwrite", "write_ds",
Arrays.asList("read_ds_0", "read_ds_1"), "random");
return new ReadwriteSplittingRule("logic_db", new
ReadwriteSplittingRuleConfiguration(
Collections.singleton(config),
Collections.singletonMap("random", new AlgorithmConfiguration("RANDOM", new
Properties()))), mock(InstanceContext.class));
}
@@ -93,7 +93,7 @@ class ReadwriteSplittingRuleTest {
@Test
void assertCreateReadwriteSplittingRuleWithRowValueExpressionImpl() {
- ReadwriteSplittingDataSourceRuleConfiguration config = new
ReadwriteSplittingDataSourceRuleConfiguration(
+ ReadwriteSplittingDataSourceGroupRuleConfiguration config = new
ReadwriteSplittingDataSourceGroupRuleConfiguration(
"<GROOVY>${['readwrite']}_ds",
"<GROOVY>${['write']}_ds",
Arrays.asList("<GROOVY>read_ds_${['0']}", "read_ds_${['1']}",
"read_ds_2", "<LITERAL>read_ds_3"),
diff --git
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingDataSourceMapperRuleAttributeTest.java
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingDataSourceMapperRuleAttributeTest.java
index d2ad201b258..1cce833c0cd 100644
---
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingDataSourceMapperRuleAttributeTest.java
+++
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/attribute/ReadwriteSplittingDataSourceMapperRuleAttributeTest.java
@@ -17,7 +17,7 @@
package org.apache.shardingsphere.readwritesplitting.rule.attribute;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingDataSourceGroupRule;
import org.junit.jupiter.api.Test;
@@ -40,6 +40,6 @@ class ReadwriteSplittingDataSourceMapperRuleAttributeTest {
private ReadwriteSplittingDataSourceGroupRule createDataSourceGroupRule() {
return new ReadwriteSplittingDataSourceGroupRule(
- new ReadwriteSplittingDataSourceRuleConfiguration("readwrite",
"write_ds", Arrays.asList("read_ds_0", "read_ds_1"), "random"), null, null);
+ new
ReadwriteSplittingDataSourceGroupRuleConfiguration("readwrite", "write_ds",
Arrays.asList("read_ds_0", "read_ds_1"), "random"), null, null);
}
}
diff --git
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/builder/ReadwriteSplittingRuleBuilderTest.java
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/builder/ReadwriteSplittingRuleBuilderTest.java
index e0b79221ec6..1476ec7503a 100644
---
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/builder/ReadwriteSplittingRuleBuilderTest.java
+++
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/rule/builder/ReadwriteSplittingRuleBuilderTest.java
@@ -21,7 +21,7 @@ import
org.apache.shardingsphere.infra.instance.InstanceContext;
import
org.apache.shardingsphere.infra.rule.builder.database.DatabaseRuleBuilder;
import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
import org.apache.shardingsphere.test.fixture.database.MockedDatabaseType;
import org.junit.jupiter.api.Test;
@@ -38,7 +38,7 @@ class ReadwriteSplittingRuleBuilderTest {
@Test
void assertBuild() {
ReadwriteSplittingRuleConfiguration ruleConfig = new
ReadwriteSplittingRuleConfiguration(Collections.singleton(
- new ReadwriteSplittingDataSourceRuleConfiguration("name",
"writeDataSourceName", Collections.singletonList("readDataSourceName"),
"loadBalancerName")), Collections.emptyMap());
+ new ReadwriteSplittingDataSourceGroupRuleConfiguration("name",
"writeDataSourceName", Collections.singletonList("readDataSourceName"),
"loadBalancerName")), Collections.emptyMap());
DatabaseRuleBuilder builder =
OrderedSPILoader.getServices(DatabaseRuleBuilder.class,
Collections.singleton(ruleConfig)).get(ruleConfig);
assertThat(builder.build(ruleConfig, "", new MockedDatabaseType(),
Collections.emptyMap(), Collections.emptyList(), mock(InstanceContext.class)),
instanceOf(ReadwriteSplittingRule.class));
}
diff --git
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingDataNodeRuleConfigurationSwapperTest.java
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingDataNodeRuleConfigurationSwapperTest.java
index 02f85045d4b..ab63cc7eac4 100644
---
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingDataNodeRuleConfigurationSwapperTest.java
+++
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingDataNodeRuleConfigurationSwapperTest.java
@@ -20,7 +20,7 @@ package
org.apache.shardingsphere.readwritesplitting.yaml.swapper;
import
org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
import org.apache.shardingsphere.infra.util.yaml.datanode.YamlDataNode;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.api.transaction.TransactionalReadQueryStrategy;
import org.junit.jupiter.api.Test;
@@ -41,7 +41,7 @@ class
YamlReadwriteSplittingDataNodeRuleConfigurationSwapperTest {
@Test
void assertSwapToDataNodesLoadBalancersEmpty() {
- ReadwriteSplittingRuleConfiguration config = new
ReadwriteSplittingRuleConfiguration(Collections.singleton(new
ReadwriteSplittingDataSourceRuleConfiguration("group_0",
+ ReadwriteSplittingRuleConfiguration config = new
ReadwriteSplittingRuleConfiguration(Collections.singleton(new
ReadwriteSplittingDataSourceGroupRuleConfiguration("group_0",
"write_ds", Arrays.asList("read_ds_0", "read_ds_1"), null)),
Collections.emptyMap());
Collection<YamlDataNode> result = swapper.swapToDataNodes(config);
assertThat(result.size(), is(1));
@@ -50,7 +50,7 @@ class
YamlReadwriteSplittingDataNodeRuleConfigurationSwapperTest {
@Test
void assertSwapToDataNodesLoadBalancers() {
- ReadwriteSplittingRuleConfiguration config = new
ReadwriteSplittingRuleConfiguration(Collections.singleton(new
ReadwriteSplittingDataSourceRuleConfiguration("group_0",
+ ReadwriteSplittingRuleConfiguration config = new
ReadwriteSplittingRuleConfiguration(Collections.singleton(new
ReadwriteSplittingDataSourceGroupRuleConfiguration("group_0",
"write_ds", Arrays.asList("read_ds_0", "read_ds_1"),
"random")), Collections.singletonMap("random", new
AlgorithmConfiguration("random", new Properties())));
Collection<YamlDataNode> result = swapper.swapToDataNodes(config);
assertThat(result.size(), is(2));
@@ -76,12 +76,12 @@ class
YamlReadwriteSplittingDataNodeRuleConfigurationSwapperTest {
+ "writeDataSourceName: write_ds\n"));
config.add(new
YamlDataNode("/metadata/foo_db/rules/readwrite_splitting/load_balancers/random/versions/0",
"type: random\n"));
ReadwriteSplittingRuleConfiguration result =
swapper.swapToObject(config).get();
- assertThat(result.getDataSources().size(), is(1));
- assertThat(result.getDataSources().iterator().next().getName(),
is("group_0"));
-
assertThat(result.getDataSources().iterator().next().getWriteDataSourceName(),
is("write_ds"));
-
assertThat(result.getDataSources().iterator().next().getReadDataSourceNames().size(),
is(2));
-
assertThat(result.getDataSources().iterator().next().getLoadBalancerName(),
is("random"));
-
assertThat(result.getDataSources().iterator().next().getTransactionalReadQueryStrategy(),
is(TransactionalReadQueryStrategy.DYNAMIC));
+ assertThat(result.getDataSourceGroups().size(), is(1));
+ assertThat(result.getDataSourceGroups().iterator().next().getName(),
is("group_0"));
+
assertThat(result.getDataSourceGroups().iterator().next().getWriteDataSourceName(),
is("write_ds"));
+
assertThat(result.getDataSourceGroups().iterator().next().getReadDataSourceNames().size(),
is(2));
+
assertThat(result.getDataSourceGroups().iterator().next().getLoadBalancerName(),
is("random"));
+
assertThat(result.getDataSourceGroups().iterator().next().getTransactionalReadQueryStrategy(),
is(TransactionalReadQueryStrategy.DYNAMIC));
assertThat(result.getLoadBalancers().size(), is(1));
assertThat(result.getLoadBalancers().get("random").getType(),
is("random"));
assertThat(result.getLoadBalancers().get("random").getProps().size(),
is(0));
diff --git
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingRuleConfigurationSwapperTest.java
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingRuleConfigurationSwapperTest.java
index 248acfe5134..cddd6c064ea 100644
---
a/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingRuleConfigurationSwapperTest.java
+++
b/features/readwrite-splitting/core/src/test/java/org/apache/shardingsphere/readwritesplitting/yaml/swapper/YamlReadwriteSplittingRuleConfigurationSwapperTest.java
@@ -20,7 +20,7 @@ package
org.apache.shardingsphere.readwritesplitting.yaml.swapper;
import
org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
import
org.apache.shardingsphere.infra.algorithm.core.yaml.YamlAlgorithmConfiguration;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.yaml.config.YamlReadwriteSplittingRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.yaml.config.rule.YamlReadwriteSplittingDataSourceRuleConfiguration;
import org.junit.jupiter.api.Test;
@@ -53,23 +53,23 @@ class YamlReadwriteSplittingRuleConfigurationSwapperTest {
}
void assertReadwriteSplittingRule(final
ReadwriteSplittingRuleConfiguration actual) {
- ReadwriteSplittingDataSourceRuleConfiguration config =
actual.getDataSources().iterator().next();
+ ReadwriteSplittingDataSourceGroupRuleConfiguration config =
actual.getDataSourceGroups().iterator().next();
assertThat(config.getName(), is("t_readwrite"));
assertThat(config.getWriteDataSourceName(), is("write_ds"));
assertThat(config.getLoadBalancerName(), is("random"));
}
private ReadwriteSplittingRuleConfiguration
creatReadwriteSplittingRuleConfiguration() {
- Collection<ReadwriteSplittingDataSourceRuleConfiguration> dataSources
= Collections.singleton(
- new ReadwriteSplittingDataSourceRuleConfiguration("readwrite",
"write_ds", Arrays.asList("read_ds_0", "read_ds_1"), "random"));
+ Collection<ReadwriteSplittingDataSourceGroupRuleConfiguration>
dataSourceGroupConfigs = Collections.singleton(
+ new
ReadwriteSplittingDataSourceGroupRuleConfiguration("readwrite", "write_ds",
Arrays.asList("read_ds_0", "read_ds_1"), "random"));
Map<String, AlgorithmConfiguration> loadBalancers =
Collections.singletonMap("myLoadBalancer", new AlgorithmConfiguration("RANDOM",
new Properties()));
- return new ReadwriteSplittingRuleConfiguration(dataSources,
loadBalancers);
+ return new ReadwriteSplittingRuleConfiguration(dataSourceGroupConfigs,
loadBalancers);
}
@Test
void assertSwapToObject() {
ReadwriteSplittingRuleConfiguration actual =
getSwapper().swapToObject(createYamlReadwriteSplittingRuleConfiguration());
- assertThat(actual.getDataSources().size(), is(1));
+ assertThat(actual.getDataSourceGroups().size(), is(1));
assertThat(actual.getLoadBalancers().size(), is(1));
assertReadwriteSplittingRule(actual);
}
diff --git
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/checker/ReadwriteSplittingRuleStatementChecker.java
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/checker/ReadwriteSplittingRuleStatementChecker.java
index eba0117df4e..5f3fbebdc9a 100644
---
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/checker/ReadwriteSplittingRuleStatementChecker.java
+++
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/checker/ReadwriteSplittingRuleStatementChecker.java
@@ -32,7 +32,7 @@ import
org.apache.shardingsphere.infra.metadata.database.resource.ResourceMetaDa
import
org.apache.shardingsphere.infra.rule.attribute.datasource.DataSourceMapperRuleAttribute;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.api.transaction.TransactionalReadQueryStrategy;
import
org.apache.shardingsphere.readwritesplitting.constant.ReadwriteSplittingDataSourceType;
import
org.apache.shardingsphere.readwritesplitting.distsql.segment.ReadwriteSplittingRuleSegment;
@@ -92,7 +92,7 @@ public final class ReadwriteSplittingRuleStatementChecker {
private static void checkRuleNamesExist(final
Collection<ReadwriteSplittingRuleSegment> segments, final
ReadwriteSplittingRuleConfiguration currentRuleConfig, final String
databaseName) {
Collection<String> requiredRuleNames =
segments.stream().map(ReadwriteSplittingRuleSegment::getName).collect(Collectors.toList());
- Collection<String> currentRuleNames =
currentRuleConfig.getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getName).collect(Collectors.toList());
+ Collection<String> currentRuleNames =
currentRuleConfig.getDataSourceGroups().stream().map(ReadwriteSplittingDataSourceGroupRuleConfiguration::getName).collect(Collectors.toList());
Collection<String> notExistedRuleNames =
requiredRuleNames.stream().filter(each ->
!currentRuleNames.contains(each)).collect(Collectors.toSet());
ShardingSpherePreconditions.checkMustEmpty(notExistedRuleNames, () ->
new MissingRequiredRuleException("Readwrite-splitting", databaseName,
notExistedRuleNames));
}
@@ -132,7 +132,7 @@ public final class ReadwriteSplittingRuleStatementChecker {
final
Collection<ReadwriteSplittingRuleSegment> segments) {
Collection<String> currentRuleNames = new LinkedList<>();
if (null != currentRuleConfig) {
-
currentRuleNames.addAll(currentRuleConfig.getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getName).collect(Collectors.toList()));
+
currentRuleNames.addAll(currentRuleConfig.getDataSourceGroups().stream().map(ReadwriteSplittingDataSourceGroupRuleConfiguration::getName).collect(Collectors.toList()));
}
Collection<String> toBeCreatedRuleNames =
segments.stream().map(ReadwriteSplittingRuleSegment::getName).filter(currentRuleNames::contains).collect(Collectors.toList());
ShardingSpherePreconditions.checkMustEmpty(toBeCreatedRuleNames, () ->
new DuplicateRuleException("Readwrite-splitting", databaseName,
toBeCreatedRuleNames));
@@ -162,7 +162,7 @@ public final class ReadwriteSplittingRuleStatementChecker {
Collection<String> existedReadDataSourceNames = new HashSet<>();
if (null != currentRuleConfig) {
Collection<String> toBeAlteredRuleNames = isCreating ?
Collections.emptySet() : getToBeAlteredRuleNames(segments);
- for (ReadwriteSplittingDataSourceRuleConfiguration each :
currentRuleConfig.getDataSources()) {
+ for (ReadwriteSplittingDataSourceGroupRuleConfiguration each :
currentRuleConfig.getDataSourceGroups()) {
if (toBeAlteredRuleNames.contains(each.getName())) {
continue;
}
diff --git
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/converter/ReadwriteSplittingRuleStatementConverter.java
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/converter/ReadwriteSplittingRuleStatementConverter.java
index 0ed49233806..aa86e12a50b 100644
---
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/converter/ReadwriteSplittingRuleStatementConverter.java
+++
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/converter/ReadwriteSplittingRuleStatementConverter.java
@@ -21,7 +21,7 @@ import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import
org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.api.transaction.TransactionalReadQueryStrategy;
import
org.apache.shardingsphere.readwritesplitting.distsql.segment.ReadwriteSplittingRuleSegment;
@@ -43,25 +43,24 @@ public final class ReadwriteSplittingRuleStatementConverter
{
* @return readwrite-splitting rule configuration
*/
public static ReadwriteSplittingRuleConfiguration convert(final
Collection<ReadwriteSplittingRuleSegment> ruleSegments) {
- Collection<ReadwriteSplittingDataSourceRuleConfiguration> dataSources
= new LinkedList<>();
+ Collection<ReadwriteSplittingDataSourceGroupRuleConfiguration>
dataSourceGroups = new LinkedList<>();
Map<String, AlgorithmConfiguration> loadBalancers = new
HashMap<>(ruleSegments.size(), 1F);
for (ReadwriteSplittingRuleSegment each : ruleSegments) {
if (null == each.getLoadBalancer()) {
- dataSources.add(createDataSourceRuleConfiguration(each, null));
+
dataSourceGroups.add(createDataSourceGroupRuleConfiguration(each, null));
} else {
String loadBalancerName = getLoadBalancerName(each.getName(),
each.getLoadBalancer().getName());
loadBalancers.put(loadBalancerName, createLoadBalancer(each));
- dataSources.add(createDataSourceRuleConfiguration(each,
loadBalancerName));
+
dataSourceGroups.add(createDataSourceGroupRuleConfiguration(each,
loadBalancerName));
}
}
- return new ReadwriteSplittingRuleConfiguration(dataSources,
loadBalancers);
+ return new ReadwriteSplittingRuleConfiguration(dataSourceGroups,
loadBalancers);
}
- private static ReadwriteSplittingDataSourceRuleConfiguration
createDataSourceRuleConfiguration(final ReadwriteSplittingRuleSegment segment,
-
final String loadBalancerName) {
+ private static ReadwriteSplittingDataSourceGroupRuleConfiguration
createDataSourceGroupRuleConfiguration(final ReadwriteSplittingRuleSegment
segment, final String loadBalancerName) {
return null == segment.getTransactionalReadQueryStrategy()
- ? new
ReadwriteSplittingDataSourceRuleConfiguration(segment.getName(),
segment.getWriteDataSource(), new LinkedList<>(segment.getReadDataSources()),
loadBalancerName)
- : new
ReadwriteSplittingDataSourceRuleConfiguration(segment.getName(),
segment.getWriteDataSource(), new LinkedList<>(segment.getReadDataSources()),
+ ? new
ReadwriteSplittingDataSourceGroupRuleConfiguration(segment.getName(),
segment.getWriteDataSource(), new LinkedList<>(segment.getReadDataSources()),
loadBalancerName)
+ : new
ReadwriteSplittingDataSourceGroupRuleConfiguration(segment.getName(),
segment.getWriteDataSource(), new LinkedList<>(segment.getReadDataSources()),
TransactionalReadQueryStrategy.valueOf(segment.getTransactionalReadQueryStrategy().toUpperCase()),
loadBalancerName);
}
diff --git
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/provider/ReadwriteSplittingRuleConfigurationToDistSQLConverter.java
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/provider/ReadwriteSplittingRuleConfigurationToDistSQLConverter.java
index 00f75fea061..01b99576cef 100644
---
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/provider/ReadwriteSplittingRuleConfigurationToDistSQLConverter.java
+++
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/provider/ReadwriteSplittingRuleConfigurationToDistSQLConverter.java
@@ -23,7 +23,7 @@ import
org.apache.shardingsphere.distsql.handler.engine.query.ral.convert.Algori
import
org.apache.shardingsphere.distsql.handler.engine.query.ral.convert.RuleConfigurationToDistSQLConverter;
import
org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.distsql.handler.constant.ReadwriteSplittingDistSQLConstants;
import java.util.Collection;
@@ -37,11 +37,11 @@ public final class
ReadwriteSplittingRuleConfigurationToDistSQLConverter impleme
@Override
public String convert(final ReadwriteSplittingRuleConfiguration
ruleConfig) {
- if (ruleConfig.getDataSources().isEmpty()) {
+ if (ruleConfig.getDataSourceGroups().isEmpty()) {
return "";
}
StringBuilder result = new
StringBuilder(ReadwriteSplittingDistSQLConstants.CREATE_READWRITE_SPLITTING_RULE);
- Iterator<ReadwriteSplittingDataSourceRuleConfiguration> iterator =
ruleConfig.getDataSources().iterator();
+ Iterator<ReadwriteSplittingDataSourceGroupRuleConfiguration> iterator
= ruleConfig.getDataSourceGroups().iterator();
while (iterator.hasNext()) {
appendStaticReadWriteSplittingRule(ruleConfig.getLoadBalancers(),
iterator.next(), result);
if (iterator.hasNext()) {
@@ -53,12 +53,12 @@ public final class
ReadwriteSplittingRuleConfigurationToDistSQLConverter impleme
}
private void appendStaticReadWriteSplittingRule(final Map<String,
AlgorithmConfiguration> loadBalancers,
- final
ReadwriteSplittingDataSourceRuleConfiguration dataSourceRuleConfig, final
StringBuilder stringBuilder) {
- String readDataSourceNames =
getReadDataSourceNames(dataSourceRuleConfig.getReadDataSourceNames());
- String transactionalReadQueryStrategy =
dataSourceRuleConfig.getTransactionalReadQueryStrategy().name();
- String loadBalancerType =
getLoadBalancerType(loadBalancers.get(dataSourceRuleConfig.getLoadBalancerName()));
+ final
ReadwriteSplittingDataSourceGroupRuleConfiguration dataSourceGroupRuleConfig,
final StringBuilder stringBuilder) {
+ String readDataSourceNames =
getReadDataSourceNames(dataSourceGroupRuleConfig.getReadDataSourceNames());
+ String transactionalReadQueryStrategy =
dataSourceGroupRuleConfig.getTransactionalReadQueryStrategy().name();
+ String loadBalancerType =
getLoadBalancerType(loadBalancers.get(dataSourceGroupRuleConfig.getLoadBalancerName()));
stringBuilder.append(String.format(ReadwriteSplittingDistSQLConstants.READWRITE_SPLITTING_FOR_STATIC,
- dataSourceRuleConfig.getName(),
dataSourceRuleConfig.getWriteDataSourceName(), readDataSourceNames,
transactionalReadQueryStrategy, loadBalancerType));
+ dataSourceGroupRuleConfig.getName(),
dataSourceGroupRuleConfig.getWriteDataSourceName(), readDataSourceNames,
transactionalReadQueryStrategy, loadBalancerType));
}
private String getReadDataSourceNames(final Collection<String>
readDataSourceNames) {
diff --git
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/InUsedReadwriteSplittingStorageUnitRetriever.java
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/InUsedReadwriteSplittingStorageUnitRetriever.java
index 17b397c9e2e..80cb6cfa0ba 100644
---
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/InUsedReadwriteSplittingStorageUnitRetriever.java
+++
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/InUsedReadwriteSplittingStorageUnitRetriever.java
@@ -20,7 +20,7 @@ package
org.apache.shardingsphere.readwritesplitting.distsql.handler.query;
import com.cedarsoftware.util.CaseInsensitiveSet;
import
org.apache.shardingsphere.distsql.handler.executor.rql.resource.InUsedStorageUnitRetriever;
import
org.apache.shardingsphere.distsql.statement.rql.rule.database.ShowRulesUsedStorageUnitStatement;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
import java.util.Collection;
@@ -38,7 +38,7 @@ public final class
InUsedReadwriteSplittingStorageUnitRetriever implements InUse
return Collections.emptyList();
}
Collection<String> result = new LinkedList<>();
- for (ReadwriteSplittingDataSourceRuleConfiguration each :
rule.getConfiguration().getDataSources()) {
+ for (ReadwriteSplittingDataSourceGroupRuleConfiguration each :
rule.getConfiguration().getDataSourceGroups()) {
if
(each.getWriteDataSourceName().equalsIgnoreCase(sqlStatement.getStorageUnitName().get()))
{
result.add(each.getName());
}
diff --git
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/ShowReadwriteSplittingRuleExecutor.java
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/ShowReadwriteSplittingRuleExecutor.java
index 92c9bf43780..b92a0ea61f4 100644
---
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/ShowReadwriteSplittingRuleExecutor.java
+++
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/ShowReadwriteSplittingRuleExecutor.java
@@ -28,7 +28,7 @@ import
org.apache.shardingsphere.infra.rule.attribute.exportable.constant.Export
import
org.apache.shardingsphere.infra.rule.attribute.exportable.constant.ExportableItemConstants;
import org.apache.shardingsphere.mode.manager.ContextManager;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.distsql.statement.ShowReadwriteSplittingRulesStatement;
import
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
@@ -57,7 +57,7 @@ public final class ShowReadwriteSplittingRuleExecutor
implements DistSQLQueryExe
Collection<LocalDataQueryResultRow> result = new LinkedList<>();
Map<String, Map<String, String>> exportableDataSourceMap =
getExportableDataSourceMap(rule);
ReadwriteSplittingRuleConfiguration ruleConfig =
rule.getConfiguration();
- ruleConfig.getDataSources().forEach(each -> {
+ ruleConfig.getDataSourceGroups().forEach(each -> {
LocalDataQueryResultRow dataItem =
buildDataItem(exportableDataSourceMap, each, getLoadBalancers(ruleConfig));
if (null == sqlStatement.getRuleName() ||
sqlStatement.getRuleName().equalsIgnoreCase(each.getName())) {
result.add(dataItem);
@@ -72,14 +72,14 @@ public final class ShowReadwriteSplittingRuleExecutor
implements DistSQLQueryExe
}
private LocalDataQueryResultRow buildDataItem(final Map<String,
Map<String, String>> exportableDataSourceMap,
- final
ReadwriteSplittingDataSourceRuleConfiguration dataSourceRuleConfig, final
Map<String, AlgorithmConfiguration> loadBalancers) {
- String name = dataSourceRuleConfig.getName();
+ final
ReadwriteSplittingDataSourceGroupRuleConfiguration dataSourceGroupRuleConfig,
final Map<String, AlgorithmConfiguration> loadBalancers) {
+ String name = dataSourceGroupRuleConfig.getName();
Map<String, String> exportDataSources =
exportableDataSourceMap.get(name);
- Optional<AlgorithmConfiguration> loadBalancer =
Optional.ofNullable(loadBalancers.get(dataSourceRuleConfig.getLoadBalancerName()));
+ Optional<AlgorithmConfiguration> loadBalancer =
Optional.ofNullable(loadBalancers.get(dataSourceGroupRuleConfig.getLoadBalancerName()));
return new LocalDataQueryResultRow(name,
- getWriteDataSourceName(dataSourceRuleConfig,
exportDataSources),
- getReadDataSourceNames(dataSourceRuleConfig,
exportDataSources),
-
dataSourceRuleConfig.getTransactionalReadQueryStrategy().name(),
+ getWriteDataSourceName(dataSourceGroupRuleConfig,
exportDataSources),
+ getReadDataSourceNames(dataSourceGroupRuleConfig,
exportDataSources),
+
dataSourceGroupRuleConfig.getTransactionalReadQueryStrategy().name(),
loadBalancer.map(AlgorithmConfiguration::getType).orElse(null),
loadBalancer.map(AlgorithmConfiguration::getProps).orElse(null));
}
@@ -89,12 +89,12 @@ public final class ShowReadwriteSplittingRuleExecutor
implements DistSQLQueryExe
return null == loadBalancers ? Collections.emptyMap() : loadBalancers;
}
- private String getWriteDataSourceName(final
ReadwriteSplittingDataSourceRuleConfiguration dataSourceRuleConfig, final
Map<String, String> exportDataSources) {
- return null == exportDataSources ?
dataSourceRuleConfig.getWriteDataSourceName() :
exportDataSources.get(ExportableItemConstants.PRIMARY_DATA_SOURCE_NAME);
+ private String getWriteDataSourceName(final
ReadwriteSplittingDataSourceGroupRuleConfiguration dataSourceGroupRuleConfig,
final Map<String, String> exportDataSources) {
+ return null == exportDataSources ?
dataSourceGroupRuleConfig.getWriteDataSourceName() :
exportDataSources.get(ExportableItemConstants.PRIMARY_DATA_SOURCE_NAME);
}
- private String getReadDataSourceNames(final
ReadwriteSplittingDataSourceRuleConfiguration dataSourceRuleConfig, final
Map<String, String> exportDataSources) {
- return null == exportDataSources ?
Joiner.on(",").join(dataSourceRuleConfig.getReadDataSourceNames()) :
exportDataSources.get(ExportableItemConstants.REPLICA_DATA_SOURCE_NAMES);
+ private String getReadDataSourceNames(final
ReadwriteSplittingDataSourceGroupRuleConfiguration dataSourceGroupRuleConfig,
final Map<String, String> exportDataSources) {
+ return null == exportDataSources ?
Joiner.on(",").join(dataSourceGroupRuleConfig.getReadDataSourceNames()) :
exportDataSources.get(ExportableItemConstants.REPLICA_DATA_SOURCE_NAMES);
}
@Override
diff --git
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingRuleExecutor.java
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingRuleExecutor.java
index 8a2bcafd320..4374a1b1e37 100644
---
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingRuleExecutor.java
+++
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingRuleExecutor.java
@@ -23,7 +23,7 @@ import
org.apache.shardingsphere.distsql.handler.required.DistSQLExecutorCurrent
import
org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.distsql.handler.checker.ReadwriteSplittingRuleStatementChecker;
import
org.apache.shardingsphere.readwritesplitting.distsql.handler.converter.ReadwriteSplittingRuleStatementConverter;
import
org.apache.shardingsphere.readwritesplitting.distsql.statement.AlterReadwriteSplittingRuleStatement;
@@ -59,16 +59,16 @@ public final class AlterReadwriteSplittingRuleExecutor
implements DatabaseRuleAl
@Override
public ReadwriteSplittingRuleConfiguration
buildToBeDroppedRuleConfiguration(final ReadwriteSplittingRuleConfiguration
toBeAlteredRuleConfig) {
- Collection<ReadwriteSplittingDataSourceRuleConfiguration> dataSources
= new LinkedList<>();
+ Collection<ReadwriteSplittingDataSourceGroupRuleConfiguration>
dataSourceGroups = new LinkedList<>();
Map<String, AlgorithmConfiguration> loadBalancers = new HashMap<>();
- List<String> toBeAlteredDataSourceNames =
toBeAlteredRuleConfig.getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getName).collect(Collectors.toList());
- for (ReadwriteSplittingDataSourceRuleConfiguration each :
rule.getConfiguration().getDataSources()) {
+ List<String> toBeAlteredDataSourceNames =
toBeAlteredRuleConfig.getDataSourceGroups().stream().map(ReadwriteSplittingDataSourceGroupRuleConfiguration::getName).collect(Collectors.toList());
+ for (ReadwriteSplittingDataSourceGroupRuleConfiguration each :
rule.getConfiguration().getDataSourceGroups()) {
if (toBeAlteredDataSourceNames.contains(each.getName())) {
- dataSources.add(each);
+ dataSourceGroups.add(each);
loadBalancers.put(each.getLoadBalancerName(),
rule.getConfiguration().getLoadBalancers().get(each.getLoadBalancerName()));
}
}
- return new ReadwriteSplittingRuleConfiguration(dataSources,
loadBalancers);
+ return new ReadwriteSplittingRuleConfiguration(dataSourceGroups,
loadBalancers);
}
@Override
diff --git
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutor.java
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutor.java
index dd2263054d9..9157a742e38 100644
---
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutor.java
+++
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutor.java
@@ -21,7 +21,7 @@ import lombok.Setter;
import
org.apache.shardingsphere.distsql.handler.engine.update.rdl.rule.spi.database.DatabaseRuleCreateExecutor;
import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.distsql.handler.checker.ReadwriteSplittingRuleStatementChecker;
import
org.apache.shardingsphere.readwritesplitting.distsql.handler.converter.ReadwriteSplittingRuleStatementConverter;
import
org.apache.shardingsphere.readwritesplitting.distsql.segment.ReadwriteSplittingRuleSegment;
@@ -60,7 +60,7 @@ public final class CreateReadwriteSplittingRuleExecutor
implements DatabaseRuleC
private Collection<String> getDuplicatedRuleNames(final
Collection<ReadwriteSplittingRuleSegment> segments) {
Collection<String> currentRuleNames = new LinkedList<>();
if (null != rule) {
-
currentRuleNames.addAll(rule.getConfiguration().getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getName).collect(Collectors.toList()));
+
currentRuleNames.addAll(rule.getConfiguration().getDataSourceGroups().stream().map(ReadwriteSplittingDataSourceGroupRuleConfiguration::getName).collect(Collectors.toList()));
}
return
segments.stream().map(ReadwriteSplittingRuleSegment::getName).filter(currentRuleNames::contains).collect(Collectors.toList());
}
diff --git
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleExecutor.java
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleExecutor.java
index 27707758a80..c8f87c767c1 100644
---
a/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleExecutor.java
+++
b/features/readwrite-splitting/distsql/handler/src/main/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleExecutor.java
@@ -30,7 +30,7 @@ import
org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import
org.apache.shardingsphere.infra.rule.attribute.datanode.DataNodeRuleAttribute;
import
org.apache.shardingsphere.infra.rule.attribute.datasource.DataSourceMapperRuleAttribute;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.distsql.statement.DropReadwriteSplittingRuleStatement;
import
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
import org.apache.shardingsphere.single.rule.SingleRule;
@@ -64,7 +64,7 @@ public final class DropReadwriteSplittingRuleExecutor
implements DatabaseRuleDro
}
private void checkToBeDroppedRuleNames(final
DropReadwriteSplittingRuleStatement sqlStatement) {
- Collection<String> currentRuleNames =
rule.getConfiguration().getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getName).collect(Collectors.toList());
+ Collection<String> currentRuleNames =
rule.getConfiguration().getDataSourceGroups().stream().map(ReadwriteSplittingDataSourceGroupRuleConfiguration::getName).collect(Collectors.toList());
Collection<String> notExistedRuleNames =
sqlStatement.getNames().stream().filter(each ->
!currentRuleNames.contains(each)).collect(Collectors.toList());
ShardingSpherePreconditions.checkMustEmpty(notExistedRuleNames, () ->
new MissingRequiredRuleException("Readwrite-splitting", database.getName(),
sqlStatement.getNames()));
}
@@ -105,30 +105,32 @@ public final class DropReadwriteSplittingRuleExecutor
implements DatabaseRuleDro
@Override
public ReadwriteSplittingRuleConfiguration
buildToBeDroppedRuleConfiguration(final DropReadwriteSplittingRuleStatement
sqlStatement) {
- Collection<ReadwriteSplittingDataSourceRuleConfiguration>
toBeDroppedDataSources = new LinkedList<>();
+ Collection<ReadwriteSplittingDataSourceGroupRuleConfiguration>
toBeDroppedDataSourceGroups = new LinkedList<>();
Map<String, AlgorithmConfiguration> toBeDroppedLoadBalancers = new
HashMap<>();
for (String each : sqlStatement.getNames()) {
- toBeDroppedDataSources.add(new
ReadwriteSplittingDataSourceRuleConfiguration(each, null, null, null));
+ toBeDroppedDataSourceGroups.add(new
ReadwriteSplittingDataSourceGroupRuleConfiguration(each, null, null, null));
dropRule(each);
}
findUnusedLoadBalancers().forEach(each ->
toBeDroppedLoadBalancers.put(each,
rule.getConfiguration().getLoadBalancers().get(each)));
- return new ReadwriteSplittingRuleConfiguration(toBeDroppedDataSources,
toBeDroppedLoadBalancers);
+ return new
ReadwriteSplittingRuleConfiguration(toBeDroppedDataSourceGroups,
toBeDroppedLoadBalancers);
}
private void dropRule(final String ruleName) {
- Optional<ReadwriteSplittingDataSourceRuleConfiguration>
dataSourceRuleConfig =
rule.getConfiguration().getDataSources().stream().filter(each ->
ruleName.equals(each.getName())).findAny();
- dataSourceRuleConfig.ifPresent(optional ->
rule.getConfiguration().getDataSources().remove(optional));
+ Optional<ReadwriteSplittingDataSourceGroupRuleConfiguration>
dataSourceRuleGroupConfig =
rule.getConfiguration().getDataSourceGroups().stream()
+ .filter(each -> ruleName.equals(each.getName())).findAny();
+ dataSourceRuleGroupConfig.ifPresent(optional ->
rule.getConfiguration().getDataSourceGroups().remove(optional));
}
private Collection<String> findUnusedLoadBalancers() {
- Collection<String> inUsedAlgorithms =
rule.getConfiguration().getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getLoadBalancerName).collect(Collectors.toSet());
+ Collection<String> inUsedAlgorithms =
rule.getConfiguration().getDataSourceGroups().stream()
+
.map(ReadwriteSplittingDataSourceGroupRuleConfiguration::getLoadBalancerName).collect(Collectors.toSet());
return
rule.getConfiguration().getLoadBalancers().keySet().stream().filter(each ->
!inUsedAlgorithms.contains(each)).collect(Collectors.toSet());
}
@Override
public boolean hasAnyOneToBeDropped(final
DropReadwriteSplittingRuleStatement sqlStatement) {
return !Collections.disjoint(
-
rule.getConfiguration().getDataSources().stream().map(ReadwriteSplittingDataSourceRuleConfiguration::getName).collect(Collectors.toSet()),
sqlStatement.getNames());
+
rule.getConfiguration().getDataSourceGroups().stream().map(ReadwriteSplittingDataSourceGroupRuleConfiguration::getName).collect(Collectors.toSet()),
sqlStatement.getNames());
}
@Override
diff --git
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/converter/ReadwriteSplittingRuleStatementConverterTest.java
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/converter/ReadwriteSplittingRuleStatementConverterTest.java
index f3d9d50078c..2b4f6d94361 100644
---
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/converter/ReadwriteSplittingRuleStatementConverterTest.java
+++
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/converter/ReadwriteSplittingRuleStatementConverterTest.java
@@ -20,7 +20,7 @@ package
org.apache.shardingsphere.readwritesplitting.distsql.handler.converter;
import org.apache.shardingsphere.distsql.segment.AlgorithmSegment;
import
org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.distsql.segment.ReadwriteSplittingRuleSegment;
import org.junit.jupiter.api.Test;
@@ -41,7 +41,7 @@ class ReadwriteSplittingRuleStatementConverterTest {
void assertEmptyRuleSegmentConvertResult() {
ReadwriteSplittingRuleConfiguration
actualEmptyRuleSegmentConvertResult = ReadwriteSplittingRuleStatementConverter
.convert(Collections.emptyList());
-
assertTrue(actualEmptyRuleSegmentConvertResult.getDataSources().isEmpty());
+
assertTrue(actualEmptyRuleSegmentConvertResult.getDataSourceGroups().isEmpty());
assertTrue(actualEmptyRuleSegmentConvertResult.getLoadBalancers().isEmpty());
}
@@ -51,11 +51,11 @@ class ReadwriteSplittingRuleStatementConverterTest {
"static_load_balancer_type", new Properties());
ReadwriteSplittingRuleConfiguration
actualSingleRuleSegmentConvertResult = ReadwriteSplittingRuleStatementConverter
.convert(Collections.singleton(expectedSingleReadwriteSplittingRuleSegment));
- Collection<ReadwriteSplittingDataSourceRuleConfiguration>
actualSingleRuleSegmentConvertResultDataSources =
actualSingleRuleSegmentConvertResult.getDataSources();
+ Collection<ReadwriteSplittingDataSourceGroupRuleConfiguration>
actualSingleRuleSegmentConvertResultDataSourceGroups =
actualSingleRuleSegmentConvertResult.getDataSourceGroups();
Map<String, AlgorithmConfiguration>
actualSingleRuleSegmentConvertResultLoadBalancers =
actualSingleRuleSegmentConvertResult.getLoadBalancers();
- assertThat(actualSingleRuleSegmentConvertResultDataSources.size(),
is(1));
+
assertThat(actualSingleRuleSegmentConvertResultDataSourceGroups.size(), is(1));
assertThat(actualSingleRuleSegmentConvertResultLoadBalancers.size(),
is(1));
- ReadwriteSplittingDataSourceRuleConfiguration actualRuleConfig =
actualSingleRuleSegmentConvertResultDataSources.iterator().next();
+ ReadwriteSplittingDataSourceGroupRuleConfiguration actualRuleConfig =
actualSingleRuleSegmentConvertResultDataSourceGroups.iterator().next();
assertThat(actualRuleConfig.getName(),
is(expectedSingleReadwriteSplittingRuleSegment.getName()));
String expectedLoadBalancerName = String.format("%s_%s",
expectedSingleReadwriteSplittingRuleSegment.getName(),
expectedSingleReadwriteSplittingRuleSegment.getLoadBalancer().getName());
assertThat(actualRuleConfig.getLoadBalancerName(),
is(expectedLoadBalancerName));
diff --git
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/provider/ReadwriteSplittingRuleConfigurationToDistSQLConverterTest.java
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/provider/ReadwriteSplittingRuleConfigurationToDistSQLConverterTest.java
index 6ee0ebd05af..840c8b9d3c3 100644
---
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/provider/ReadwriteSplittingRuleConfigurationToDistSQLConverterTest.java
+++
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/provider/ReadwriteSplittingRuleConfigurationToDistSQLConverterTest.java
@@ -19,7 +19,7 @@ package
org.apache.shardingsphere.readwritesplitting.distsql.handler.provider;
import
org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import org.apache.shardingsphere.test.util.PropertiesBuilder;
import org.junit.jupiter.api.Test;
@@ -36,16 +36,16 @@ class
ReadwriteSplittingRuleConfigurationToDistSQLConverterTest {
@Test
void assertConvertWithEmptyDataSources() {
ReadwriteSplittingRuleConfiguration readwriteSplittingRuleConfig =
mock(ReadwriteSplittingRuleConfiguration.class);
-
when(readwriteSplittingRuleConfig.getDataSources()).thenReturn(Collections.emptyList());
+
when(readwriteSplittingRuleConfig.getDataSourceGroups()).thenReturn(Collections.emptyList());
ReadwriteSplittingRuleConfigurationToDistSQLConverter
readwriteSplittingRuleConfigurationToDistSQLConverter = new
ReadwriteSplittingRuleConfigurationToDistSQLConverter();
assertThat(readwriteSplittingRuleConfigurationToDistSQLConverter.convert(readwriteSplittingRuleConfig),
is(""));
}
@Test
void assertConvert() {
- ReadwriteSplittingDataSourceRuleConfiguration dataSourceRuleConfig =
- new
ReadwriteSplittingDataSourceRuleConfiguration("readwrite_ds", "ds_primary",
Arrays.asList("ds_slave_0", "ds_slave_1"), "test");
- ReadwriteSplittingRuleConfiguration readwriteSplittingRuleConfig = new
ReadwriteSplittingRuleConfiguration(Collections.singleton(dataSourceRuleConfig),
+ ReadwriteSplittingDataSourceGroupRuleConfiguration
dataSourceGroupConfig =
+ new
ReadwriteSplittingDataSourceGroupRuleConfiguration("readwrite_ds",
"ds_primary", Arrays.asList("ds_slave_0", "ds_slave_1"), "test");
+ ReadwriteSplittingRuleConfiguration readwriteSplittingRuleConfig = new
ReadwriteSplittingRuleConfiguration(Collections.singleton(dataSourceGroupConfig),
Collections.singletonMap("test", new
AlgorithmConfiguration("random", PropertiesBuilder.build(new
PropertiesBuilder.Property("read_weight", "2:1")))));
ReadwriteSplittingRuleConfigurationToDistSQLConverter
readwriteSplittingRuleConfigurationToDistSQLConverter = new
ReadwriteSplittingRuleConfigurationToDistSQLConverter();
assertThat(readwriteSplittingRuleConfigurationToDistSQLConverter.convert(readwriteSplittingRuleConfig),
diff --git
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/ShowReadwriteSplittingRuleExecutorTest.java
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/ShowReadwriteSplittingRuleExecutorTest.java
index 0b2c2a88d94..8e15bd9fc7c 100644
---
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/ShowReadwriteSplittingRuleExecutorTest.java
+++
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/query/ShowReadwriteSplittingRuleExecutorTest.java
@@ -26,7 +26,7 @@ import
org.apache.shardingsphere.infra.rule.attribute.RuleAttributes;
import
org.apache.shardingsphere.infra.rule.attribute.exportable.constant.ExportableConstants;
import org.apache.shardingsphere.mode.manager.ContextManager;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.distsql.statement.ShowReadwriteSplittingRulesStatement;
import
org.apache.shardingsphere.readwritesplitting.rule.attribute.ReadwriteSplittingExportableRuleAttribute;
import
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
@@ -110,10 +110,10 @@ class ShowReadwriteSplittingRuleExecutorTest {
}
private ReadwriteSplittingRuleConfiguration createRuleConfiguration() {
- ReadwriteSplittingDataSourceRuleConfiguration dataSourceRuleConfig =
- new
ReadwriteSplittingDataSourceRuleConfiguration("readwrite_ds", "ds_primary",
Arrays.asList("ds_slave_0", "ds_slave_1"), "test");
+ ReadwriteSplittingDataSourceGroupRuleConfiguration
dataSourceGroupConfig =
+ new
ReadwriteSplittingDataSourceGroupRuleConfiguration("readwrite_ds",
"ds_primary", Arrays.asList("ds_slave_0", "ds_slave_1"), "test");
return new ReadwriteSplittingRuleConfiguration(
- Collections.singleton(dataSourceRuleConfig),
Collections.singletonMap("test", new AlgorithmConfiguration("random",
PropertiesBuilder.build(new Property("read_weight", "2:1")))));
+ Collections.singleton(dataSourceGroupConfig),
Collections.singletonMap("test", new AlgorithmConfiguration("random",
PropertiesBuilder.build(new Property("read_weight", "2:1")))));
}
@Test
@@ -133,8 +133,8 @@ class ShowReadwriteSplittingRuleExecutorTest {
}
private ReadwriteSplittingRuleConfiguration
createRuleConfigurationWithoutLoadBalancer() {
- ReadwriteSplittingDataSourceRuleConfiguration dataSourceRuleConfig =
- new
ReadwriteSplittingDataSourceRuleConfiguration("readwrite_ds", "write_ds",
Arrays.asList("read_ds_0", "read_ds_1"), null);
- return new
ReadwriteSplittingRuleConfiguration(Collections.singleton(dataSourceRuleConfig),
null);
+ ReadwriteSplittingDataSourceGroupRuleConfiguration
dataSourceGroupConfig =
+ new
ReadwriteSplittingDataSourceGroupRuleConfiguration("readwrite_ds", "write_ds",
Arrays.asList("read_ds_0", "read_ds_1"), null);
+ return new
ReadwriteSplittingRuleConfiguration(Collections.singleton(dataSourceGroupConfig),
null);
}
}
diff --git
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingRuleExecutorTest.java
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingRuleExecutorTest.java
index 75050a1ccb2..70a85de3960 100644
---
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingRuleExecutorTest.java
+++
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/AlterReadwriteSplittingRuleExecutorTest.java
@@ -24,7 +24,7 @@ import
org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import
org.apache.shardingsphere.infra.metadata.database.resource.ResourceMetaData;
import
org.apache.shardingsphere.infra.spi.exception.ServiceProviderNotFoundException;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.distsql.segment.ReadwriteSplittingRuleSegment;
import
org.apache.shardingsphere.readwritesplitting.distsql.statement.AlterReadwriteSplittingRuleStatement;
import
org.apache.shardingsphere.readwritesplitting.exception.actual.DuplicateReadwriteSplittingActualDataSourceException;
@@ -165,16 +165,16 @@ class AlterReadwriteSplittingRuleExecutorTest {
}
private ReadwriteSplittingRuleConfiguration
createCurrentRuleConfiguration() {
- ReadwriteSplittingDataSourceRuleConfiguration dataSourceRuleConfig =
- new
ReadwriteSplittingDataSourceRuleConfiguration("readwrite_ds", "ds_write",
Arrays.asList("read_ds_0", "read_ds_1"), "TEST");
- return new ReadwriteSplittingRuleConfiguration(new
LinkedList<>(Collections.singleton(dataSourceRuleConfig)),
Collections.emptyMap());
+ ReadwriteSplittingDataSourceGroupRuleConfiguration
dataSourceGroupConfig =
+ new
ReadwriteSplittingDataSourceGroupRuleConfiguration("readwrite_ds", "ds_write",
Arrays.asList("read_ds_0", "read_ds_1"), "TEST");
+ return new ReadwriteSplittingRuleConfiguration(new
LinkedList<>(Collections.singleton(dataSourceGroupConfig)),
Collections.emptyMap());
}
private ReadwriteSplittingRuleConfiguration
createCurrentRuleConfigurationWithMultipleRules() {
- ReadwriteSplittingDataSourceRuleConfiguration dataSourceRuleConfig0 =
- new
ReadwriteSplittingDataSourceRuleConfiguration("readwrite_ds_0", "ds_write_0",
Arrays.asList("read_ds_0_0", "read_ds_0_1"), "TEST");
- ReadwriteSplittingDataSourceRuleConfiguration dataSourceRuleConfig1 =
- new
ReadwriteSplittingDataSourceRuleConfiguration("readwrite_ds_1", "ds_write_1",
Arrays.asList("read_ds_1_0", "read_ds_1_1"), "TEST");
- return new ReadwriteSplittingRuleConfiguration(new
LinkedList<>(Arrays.asList(dataSourceRuleConfig0, dataSourceRuleConfig1)),
Collections.emptyMap());
+ ReadwriteSplittingDataSourceGroupRuleConfiguration
dataSourceGroupConfig0 =
+ new
ReadwriteSplittingDataSourceGroupRuleConfiguration("readwrite_ds_0",
"ds_write_0", Arrays.asList("read_ds_0_0", "read_ds_0_1"), "TEST");
+ ReadwriteSplittingDataSourceGroupRuleConfiguration
dataSourceGroupConfig1 =
+ new
ReadwriteSplittingDataSourceGroupRuleConfiguration("readwrite_ds_1",
"ds_write_1", Arrays.asList("read_ds_1_0", "read_ds_1_1"), "TEST");
+ return new ReadwriteSplittingRuleConfiguration(new
LinkedList<>(Arrays.asList(dataSourceGroupConfig0, dataSourceGroupConfig1)),
Collections.emptyMap());
}
}
diff --git
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutorTest.java
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutorTest.java
index fad29f3bc2a..c7a75d97ddb 100644
---
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutorTest.java
+++
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/CreateReadwriteSplittingRuleExecutorTest.java
@@ -26,7 +26,7 @@ import
org.apache.shardingsphere.infra.metadata.database.resource.ResourceMetaDa
import
org.apache.shardingsphere.infra.rule.attribute.datasource.DataSourceMapperRuleAttribute;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.distsql.segment.ReadwriteSplittingRuleSegment;
import
org.apache.shardingsphere.readwritesplitting.distsql.statement.CreateReadwriteSplittingRuleStatement;
import
org.apache.shardingsphere.readwritesplitting.exception.actual.DuplicateReadwriteSplittingActualDataSourceException;
@@ -158,7 +158,7 @@ class CreateReadwriteSplittingRuleExecutorTest {
executor.checkBeforeUpdate(sqlStatement);
executor.setRule(mock(ReadwriteSplittingRule.class));
ReadwriteSplittingRuleConfiguration toBeCreatedRuleConfig =
executor.buildToBeCreatedRuleConfiguration(sqlStatement);
- assertThat(toBeCreatedRuleConfig.getDataSources().size(), is(1));
+ assertThat(toBeCreatedRuleConfig.getDataSourceGroups().size(), is(1));
assertThat(toBeCreatedRuleConfig.getLoadBalancers().size(), is(1));
}
@@ -197,8 +197,8 @@ class CreateReadwriteSplittingRuleExecutorTest {
}
private ReadwriteSplittingRuleConfiguration
createCurrentRuleConfiguration() {
- ReadwriteSplittingDataSourceRuleConfiguration dataSourceRuleConfig =
new ReadwriteSplittingDataSourceRuleConfiguration("readwrite_ds_0", "ds_write",
+ ReadwriteSplittingDataSourceGroupRuleConfiguration
dataSourceGroupConfig = new
ReadwriteSplittingDataSourceGroupRuleConfiguration("readwrite_ds_0", "ds_write",
Arrays.asList("read_ds_0", "read_ds_1"), "TEST");
- return new ReadwriteSplittingRuleConfiguration(new
LinkedList<>(Collections.singleton(dataSourceRuleConfig)),
Collections.emptyMap());
+ return new ReadwriteSplittingRuleConfiguration(new
LinkedList<>(Collections.singleton(dataSourceGroupConfig)),
Collections.emptyMap());
}
}
diff --git
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleExecutorTest.java
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleExecutorTest.java
index 3952df05d47..d5322cadbe3 100644
---
a/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleExecutorTest.java
+++
b/features/readwrite-splitting/distsql/handler/src/test/java/org/apache/shardingsphere/readwritesplitting/distsql/handler/update/DropReadwriteSplittingRuleExecutorTest.java
@@ -27,7 +27,7 @@ import
org.apache.shardingsphere.infra.rule.attribute.RuleAttributes;
import
org.apache.shardingsphere.infra.rule.attribute.datanode.DataNodeRuleAttribute;
import
org.apache.shardingsphere.infra.rule.attribute.datasource.DataSourceMapperRuleAttribute;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import
org.apache.shardingsphere.readwritesplitting.distsql.statement.DropReadwriteSplittingRuleStatement;
import
org.apache.shardingsphere.readwritesplitting.rule.ReadwriteSplittingRule;
import org.junit.jupiter.api.BeforeEach;
@@ -98,7 +98,7 @@ class DropReadwriteSplittingRuleExecutorTest {
when(rule.getConfiguration()).thenReturn(ruleConfig);
executor.setRule(rule);
ReadwriteSplittingRuleConfiguration actual =
executor.buildToBeDroppedRuleConfiguration(createSQLStatement());
- assertThat(actual.getDataSources().size(), is(1));
+ assertThat(actual.getDataSourceGroups().size(), is(1));
assertThat(actual.getLoadBalancers().size(), is(1));
}
@@ -109,7 +109,7 @@ class DropReadwriteSplittingRuleExecutorTest {
when(rule.getConfiguration()).thenReturn(ruleConfig);
executor.setRule(rule);
ReadwriteSplittingRuleConfiguration actual =
executor.buildToBeDroppedRuleConfiguration(createSQLStatement());
- assertThat(actual.getDataSources().size(), is(1));
+ assertThat(actual.getDataSourceGroups().size(), is(1));
assertThat(actual.getLoadBalancers().size(), is(0));
}
@@ -120,7 +120,7 @@ class DropReadwriteSplittingRuleExecutorTest {
when(rule.getConfiguration()).thenReturn(ruleConfig);
executor.setRule(rule);
ReadwriteSplittingRuleConfiguration actual =
executor.buildToBeDroppedRuleConfiguration(createSQLStatement());
- assertThat(actual.getDataSources().size(), is(1));
+ assertThat(actual.getDataSourceGroups().size(), is(1));
assertThat(actual.getLoadBalancers().size(), is(1));
}
@@ -129,28 +129,28 @@ class DropReadwriteSplittingRuleExecutorTest {
}
private ReadwriteSplittingRuleConfiguration
createCurrentRuleConfiguration() {
- ReadwriteSplittingDataSourceRuleConfiguration dataSourceRuleConfig =
new ReadwriteSplittingDataSourceRuleConfiguration("readwrite_ds",
+ ReadwriteSplittingDataSourceGroupRuleConfiguration
dataSourceGroupConfig = new
ReadwriteSplittingDataSourceGroupRuleConfiguration("readwrite_ds",
"", Collections.emptyList(), "readwrite_ds");
Map<String, AlgorithmConfiguration> loadBalancers = new
LinkedHashMap<>();
loadBalancers.put("readwrite_ds", new AlgorithmConfiguration("TEST",
new Properties()));
- return new ReadwriteSplittingRuleConfiguration(new
LinkedList<>(Collections.singleton(dataSourceRuleConfig)), loadBalancers);
+ return new ReadwriteSplittingRuleConfiguration(new
LinkedList<>(Collections.singleton(dataSourceGroupConfig)), loadBalancers);
}
private ReadwriteSplittingRuleConfiguration
createCurrentRuleConfigurationWithoutLoadBalancerName() {
- ReadwriteSplittingDataSourceRuleConfiguration dataSourceRuleConfig =
new ReadwriteSplittingDataSourceRuleConfiguration("readwrite_ds",
+ ReadwriteSplittingDataSourceGroupRuleConfiguration
dataSourceGroupConfig = new
ReadwriteSplittingDataSourceGroupRuleConfiguration("readwrite_ds",
"", new LinkedList<>(), null);
Map<String, AlgorithmConfiguration> loadBalancers = new
LinkedHashMap<>();
loadBalancers.put("readwrite_ds", new AlgorithmConfiguration("TEST",
new Properties()));
- return new ReadwriteSplittingRuleConfiguration(new
LinkedList<>(Collections.singleton(dataSourceRuleConfig)), loadBalancers);
+ return new ReadwriteSplittingRuleConfiguration(new
LinkedList<>(Collections.singleton(dataSourceGroupConfig)), loadBalancers);
}
private ReadwriteSplittingRuleConfiguration
createMultipleCurrentRuleConfigurations() {
- ReadwriteSplittingDataSourceRuleConfiguration fooDataSourceRuleConfig
= new ReadwriteSplittingDataSourceRuleConfiguration("foo_ds",
- "", new LinkedList<>(), "TEST");
- ReadwriteSplittingDataSourceRuleConfiguration barDataSourceRuleConfig
= new ReadwriteSplittingDataSourceRuleConfiguration("bar_ds",
- "", new LinkedList<>(), "TEST");
+ ReadwriteSplittingDataSourceGroupRuleConfiguration
fooDataSourceGroupConfig = new
ReadwriteSplittingDataSourceGroupRuleConfiguration(
+ "foo_ds", "", new LinkedList<>(), "TEST");
+ ReadwriteSplittingDataSourceGroupRuleConfiguration
barDataSourceGroupConfig = new
ReadwriteSplittingDataSourceGroupRuleConfiguration(
+ "bar_ds", "", new LinkedList<>(), "TEST");
Map<String, AlgorithmConfiguration> loadBalancers = new
LinkedHashMap<>();
loadBalancers.put("TEST", new AlgorithmConfiguration("TEST", new
Properties()));
- return new ReadwriteSplittingRuleConfiguration(new
LinkedList<>(Arrays.asList(fooDataSourceRuleConfig, barDataSourceRuleConfig)),
loadBalancers);
+ return new ReadwriteSplittingRuleConfiguration(new
LinkedList<>(Arrays.asList(fooDataSourceGroupConfig,
barDataSourceGroupConfig)), loadBalancers);
}
}
diff --git
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/config/yaml/swapper/YamlProxyConfigurationSwapperTest.java
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/config/yaml/swapper/YamlProxyConfigurationSwapperTest.java
index a61489f2af6..d5ea5d631a8 100644
---
a/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/config/yaml/swapper/YamlProxyConfigurationSwapperTest.java
+++
b/proxy/backend/core/src/test/java/org/apache/shardingsphere/proxy/backend/config/yaml/swapper/YamlProxyConfigurationSwapperTest.java
@@ -27,7 +27,7 @@ import
org.apache.shardingsphere.proxy.backend.config.ProxyConfiguration;
import org.apache.shardingsphere.proxy.backend.config.ProxyConfigurationLoader;
import org.apache.shardingsphere.proxy.backend.config.YamlProxyConfiguration;
import
org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
-import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import
org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
import org.junit.jupiter.api.Test;
import java.io.IOException;
@@ -77,11 +77,11 @@ class YamlProxyConfigurationSwapperTest {
}
private void assertReadwriteSplittingRuleConfiguration(final
ReadwriteSplittingRuleConfiguration actual) {
- assertThat(actual.getDataSources().size(), is(1));
- ReadwriteSplittingDataSourceRuleConfiguration dataSource =
actual.getDataSources().iterator().next();
- assertThat(dataSource.getName(), is("readwrite_ds"));
- assertThat(dataSource.getWriteDataSourceName(), is("foo_db"));
- assertThat(dataSource.getReadDataSourceNames(),
is(Collections.singletonList("foo_db")));
+ assertThat(actual.getDataSourceGroups().size(), is(1));
+ ReadwriteSplittingDataSourceGroupRuleConfiguration
dataSourceGroupConfig = actual.getDataSourceGroups().iterator().next();
+ assertThat(dataSourceGroupConfig.getName(), is("readwrite_ds"));
+ assertThat(dataSourceGroupConfig.getWriteDataSourceName(),
is("foo_db"));
+ assertThat(dataSourceGroupConfig.getReadDataSourceNames(),
is(Collections.singletonList("foo_db")));
assertThat(actual.getLoadBalancers().size(), is(1));
AlgorithmConfiguration loadBalancer =
actual.getLoadBalancers().get("round_robin");
assertThat(loadBalancer.getProps().size(), is(1));
