You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by zh...@apache.org on 2026/09/19 15:19:15 UTC
(shardingsphere) branch master updated: Refactor rule configuration validation with Bean Validation (#39898)
This is an automated email from the ASF dual-hosted git repository.
terrymanu 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 3294acd45ed Refactor rule configuration validation with Bean Validation (#39898)
3294acd45ed is described below
commit 3294acd45ed9c24474c479f4ef2b8e66a17ba786
Author: Liang Zhang <zh...@apache.org>
AuthorDate: Sat Sep 19 23:19:08 2026 +0800
Refactor rule configuration validation with Bean Validation (#39898)
* Refactor rule configuration validation with Bean Validation
* Refactor rule configuration validation with Bean Validation
---
.../user-manual/error-code/sql-error-code.cn.md | 2 -
.../user-manual/error-code/sql-error-code.en.md | 2 -
.../encrypt/config/EncryptRuleConfiguration.java | 3 +
.../EncryptRuleConfigurationValidator.java | 60 ++++++++++++
.../validator/ValidEncryptRuleConfiguration.java | 57 +++++++++++
.../config/EncryptRuleConfigurationTest.java | 18 +++-
.../config/EncryptRuleConfigurationChecker.java | 34 -------
.../EncryptRuleConfigurationCheckerTest.java | 65 +------------
.../mask/config/MaskRuleConfiguration.java | 3 +
.../validator/MaskRuleConfigurationValidator.java | 49 ++++++++++
.../validator/ValidMaskRuleConfiguration.java | 57 +++++++++++
.../mask/config/MaskRuleConfigurationTest.java | 3 +-
.../mask/checker/MaskRuleConfigurationChecker.java | 26 -----
.../checker/MaskRuleConfigurationCheckerTest.java | 23 +----
features/readwrite-splitting/api/pom.xml | 2 +-
.../ReadwriteSplittingRuleConfiguration.java | 5 +
...adwriteSplittingRuleConfigurationValidator.java | 47 +++++++++
.../ValidReadwriteSplittingRuleConfiguration.java | 57 +++++++++++
.../ReadwriteSplittingRuleConfigurationTest.java | 10 +-
.../fixture/LoadBalanceAlgorithmFixture.java} | 21 ++--
...algorithm.loadbalancer.spi.LoadBalanceAlgorithm | 18 ++++
...ReadwriteSplittingRuleConfigurationChecker.java | 4 -
.../shadow/config/ShadowRuleConfiguration.java | 3 +
.../ShadowRuleConfigurationValidator.java | 85 +++++++++++++++++
.../validator/ValidShadowRuleConfiguration.java | 57 +++++++++++
.../shadow/config/ShadowRuleConfigurationTest.java | 30 +++++-
.../config/fixture/ShadowAlgorithmFixture.java | 8 ++
.../checker/ShadowRuleConfigurationChecker.java | 33 -------
.../ShadowRuleConfigurationCheckerTest.java | 66 -------------
features/sharding/api/pom.xml | 2 +-
.../api/config/ShardingRuleConfiguration.java | 4 +
.../ShardingRuleConfigurationValidator.java | 106 +++++++++++++++++++++
.../validator/ValidShardingRuleConfiguration.java | 57 +++++++++++
.../api/config/ShardingRuleConfigurationTest.java | 72 +++++++++++++-
.../fixture/KeyGenerateAlgorithmFixture.java} | 18 +++-
.../fixture/ShardingAuditAlgorithmFixture.java} | 20 +++-
...infra.algorithm.keygen.spi.KeyGenerateAlgorithm | 18 ++++
...rdingsphere.sharding.spi.ShardingAuditAlgorithm | 18 ++++
.../config/ShardingRuleConfigurationChecker.java | 68 +------------
.../ShardingRuleConfigurationCheckerTest.java | 106 +--------------------
.../checker/DatabaseRuleConfigurationChecker.java | 3 +-
.../rule/validator/RuleConfigurationValidator.java | 9 +-
.../RuleConfigurationTypeValidationGroup.java | 14 +--
.../DatabaseRuleConfigurationCheckerTest.java | 46 +++++++++
.../validator/RuleConfigurationValidatorTest.java | 27 ++++++
.../fixture/ValidRuleConfigurationTypeFixture.java | 70 ++++++++++++++
.../config/TimestampServiceRuleConfiguration.java | 2 +
.../TimestampServiceRuleConfigurationTest.java | 7 +-
.../config/fixture/TimestampServiceFixture.java | 21 ++--
...shardingsphere.timeservice.spi.TimestampService | 18 ++++
.../config/TransactionRuleConfiguration.java | 3 +-
.../TransactionProviderTypeValidator.java | 2 +-
.../config/TransactionRuleConfigurationTest.java | 4 +-
.../validator/MCPLaunchConfigurationValidator.java | 5 +-
.../UniqueMCPPromptArgumentNamesValidator.java | 9 +-
55 files changed, 1092 insertions(+), 485 deletions(-)
diff --git a/docs/document/content/user-manual/error-code/sql-error-code.cn.md b/docs/document/content/user-manual/error-code/sql-error-code.cn.md
index c29ba1350f2..8957f63747b 100644
--- a/docs/document/content/user-manual/error-code/sql-error-code.cn.md
+++ b/docs/document/content/user-manual/error-code/sql-error-code.cn.md
@@ -246,8 +246,6 @@ SQL 错误码以标准的 SQL State,Vendor Code 和详细错误信息提供,
|-------------|-----------|-------------------------------------------------------------------------|
| 22000 | 42S02 | Production data source configuration does not exist in database '%s'. |
| 22001 | 42S02 | Shadow data source configuration does not exist in database '%s'. |
-| 22002 | 42S02 | No available shadow data sources mappings in shadow table '%s'. |
-| 22003 | 44000 | Default shadow algorithm class should be implement HintShadowAlgorithm. |
| 22010 | HY004 | Shadow column '%s' of table '%s' does not support '%s' type. |
| 22020 | 42000 | Insert value of index '%d' can not support for shadow. |
diff --git a/docs/document/content/user-manual/error-code/sql-error-code.en.md b/docs/document/content/user-manual/error-code/sql-error-code.en.md
index dae92ada4f9..7fbf94c6617 100644
--- a/docs/document/content/user-manual/error-code/sql-error-code.en.md
+++ b/docs/document/content/user-manual/error-code/sql-error-code.en.md
@@ -247,8 +247,6 @@ SQL error codes provide by standard `SQL State`, `Vendor Code` and `Reason`, whi
|-------------|-----------|-------------------------------------------------------------------------|
| 22000 | 42S02 | Production data source configuration does not exist in database '%s'. |
| 22001 | 42S02 | Shadow data source configuration does not exist in database '%s'. |
-| 22002 | 42S02 | No available shadow data sources mappings in shadow table '%s'. |
-| 22003 | 44000 | Default shadow algorithm class should be implement HintShadowAlgorithm. |
| 22010 | HY004 | Shadow column '%s' of table '%s' does not support '%s' type. |
| 22020 | 42000 | Insert value of index '%d' can not support for shadow. |
diff --git a/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/EncryptRuleConfiguration.java b/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/EncryptRuleConfiguration.java
index 822c008b760..71ad246c497 100644
--- a/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/EncryptRuleConfiguration.java
+++ b/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/EncryptRuleConfiguration.java
@@ -21,10 +21,12 @@ import com.cedarsoftware.util.CaseInsensitiveSet;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import org.apache.shardingsphere.encrypt.config.rule.EncryptTableRuleConfiguration;
+import org.apache.shardingsphere.encrypt.config.validator.ValidEncryptRuleConfiguration;
import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
import org.apache.shardingsphere.infra.config.rule.function.EnhancedRuleConfiguration;
import org.apache.shardingsphere.infra.config.rule.scope.DatabaseRuleConfiguration;
import org.apache.shardingsphere.infra.config.rule.validator.constraint.spi.SPITypeExists;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
import javax.validation.Valid;
import javax.validation.constraints.NotBlank;
@@ -38,6 +40,7 @@ import java.util.stream.Collectors;
*/
@RequiredArgsConstructor
@Getter
+@ValidEncryptRuleConfiguration(groups = RuleConfigurationTypeValidationGroup.class)
public final class EncryptRuleConfiguration implements DatabaseRuleConfiguration, EnhancedRuleConfiguration {
@NotNull
diff --git a/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/validator/EncryptRuleConfigurationValidator.java b/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/validator/EncryptRuleConfigurationValidator.java
new file mode 100644
index 00000000000..1f54d6aaa10
--- /dev/null
+++ b/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/validator/EncryptRuleConfigurationValidator.java
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.encrypt.config.validator;
+
+import org.apache.shardingsphere.encrypt.config.EncryptRuleConfiguration;
+import org.apache.shardingsphere.encrypt.config.rule.EncryptColumnItemRuleConfiguration;
+import org.apache.shardingsphere.encrypt.config.rule.EncryptColumnRuleConfiguration;
+import org.apache.shardingsphere.encrypt.config.rule.EncryptTableRuleConfiguration;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+
+/**
+ * Encrypt rule configuration validator.
+ */
+public final class EncryptRuleConfigurationValidator implements ConstraintValidator<ValidEncryptRuleConfiguration, EncryptRuleConfiguration> {
+
+ @Override
+ public boolean isValid(final EncryptRuleConfiguration value, final ConstraintValidatorContext context) {
+ return value.getTables().stream().allMatch(each -> isTableValid(each, value, context));
+ }
+
+ private boolean isTableValid(final EncryptTableRuleConfiguration tableConfig, final EncryptRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+ return tableConfig.getColumns().stream().allMatch(each -> isColumnValid(each, ruleConfig, context));
+ }
+
+ private boolean isColumnValid(final EncryptColumnRuleConfiguration columnConfig, final EncryptRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+ if (!isEncryptorReferenceValid(columnConfig.getCipher(), ruleConfig, context)) {
+ return false;
+ }
+ if (columnConfig.getAssistedQuery().isPresent() && !isEncryptorReferenceValid(columnConfig.getAssistedQuery().get(), ruleConfig, context)) {
+ return false;
+ }
+ return !columnConfig.getLikeQuery().isPresent() || isEncryptorReferenceValid(columnConfig.getLikeQuery().get(), ruleConfig, context);
+ }
+
+ private boolean isEncryptorReferenceValid(final EncryptColumnItemRuleConfiguration columnItemConfig, final EncryptRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+ if (ruleConfig.getEncryptors().containsKey(columnItemConfig.getEncryptorName())) {
+ return true;
+ }
+ context.disableDefaultConstraintViolation();
+ context.buildConstraintViolationWithTemplate(String.format("references unconfigured encryptor `%s`", columnItemConfig.getEncryptorName())).addPropertyNode("tables").addConstraintViolation();
+ return false;
+ }
+}
diff --git a/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/validator/ValidEncryptRuleConfiguration.java b/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/validator/ValidEncryptRuleConfiguration.java
new file mode 100644
index 00000000000..aa87f2799ee
--- /dev/null
+++ b/features/encrypt/api/src/main/java/org/apache/shardingsphere/encrypt/config/validator/ValidEncryptRuleConfiguration.java
@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.encrypt.config.validator;
+
+import javax.validation.Constraint;
+import javax.validation.Payload;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Valid encrypt rule configuration constraint.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Constraint(validatedBy = EncryptRuleConfigurationValidator.class)
+@Documented
+public @interface ValidEncryptRuleConfiguration {
+
+ /**
+ * Get message.
+ *
+ * @return message
+ */
+ String message() default "contains invalid references";
+
+ /**
+ * Get groups.
+ *
+ * @return groups
+ */
+ Class<?>[] groups() default {};
+
+ /**
+ * Get payload.
+ *
+ * @return payload
+ */
+ Class<? extends Payload>[] payload() default {};
+}
diff --git a/features/encrypt/api/src/test/java/org/apache/shardingsphere/encrypt/config/EncryptRuleConfigurationTest.java b/features/encrypt/api/src/test/java/org/apache/shardingsphere/encrypt/config/EncryptRuleConfigurationTest.java
index ba3746eac68..cb3a7d85378 100644
--- a/features/encrypt/api/src/test/java/org/apache/shardingsphere/encrypt/config/EncryptRuleConfigurationTest.java
+++ b/features/encrypt/api/src/test/java/org/apache/shardingsphere/encrypt/config/EncryptRuleConfigurationTest.java
@@ -31,6 +31,7 @@ import org.junit.jupiter.params.provider.MethodSource;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
+import java.util.Map;
import java.util.Properties;
import java.util.stream.Stream;
@@ -92,6 +93,10 @@ class EncryptRuleConfigurationTest {
invalidLikeQueryName.setLikeQuery(new EncryptColumnItemRuleConfiguration("", "foo_encryptor"));
EncryptColumnRuleConfiguration invalidLikeQueryEncryptor = createValidColumnConfiguration();
invalidLikeQueryEncryptor.setLikeQuery(new EncryptColumnItemRuleConfiguration("foo_like", ""));
+ EncryptColumnRuleConfiguration missingAssistedQueryEncryptor = createValidColumnConfiguration();
+ missingAssistedQueryEncryptor.setAssistedQuery(new EncryptColumnItemRuleConfiguration("foo_assisted", "bar_encryptor"));
+ EncryptColumnRuleConfiguration missingLikeQueryEncryptor = createValidColumnConfiguration();
+ missingLikeQueryEncryptor.setLikeQuery(new EncryptColumnItemRuleConfiguration("foo_like", "bar_encryptor"));
AlgorithmConfiguration algorithmConfig = new AlgorithmConfiguration("FIXTURE", new Properties());
return Stream.of(
Arguments.of("Null tables", new EncryptRuleConfiguration(null, Collections.emptyMap())),
@@ -117,7 +122,12 @@ class EncryptRuleConfigurationTest {
Arguments.of("Blank assisted query name", createRuleConfiguration(invalidAssistedQueryName)),
Arguments.of("Blank assisted query encryptor", createRuleConfiguration(invalidAssistedQueryEncryptor)),
Arguments.of("Blank like query name", createRuleConfiguration(invalidLikeQueryName)),
- Arguments.of("Blank like query encryptor", createRuleConfiguration(invalidLikeQueryEncryptor)));
+ Arguments.of("Blank like query encryptor", createRuleConfiguration(invalidLikeQueryEncryptor)),
+ Arguments.of("Unconfigured cipher encryptor", createRuleConfiguration(createValidColumnConfiguration())),
+ Arguments.of("Unconfigured assisted query encryptor", createRuleConfiguration(missingAssistedQueryEncryptor,
+ Collections.singletonMap("foo_encryptor", algorithmConfig))),
+ Arguments.of("Unconfigured like query encryptor", createRuleConfiguration(missingLikeQueryEncryptor,
+ Collections.singletonMap("foo_encryptor", algorithmConfig))));
}
private static EncryptColumnRuleConfiguration createValidColumnConfiguration() {
@@ -125,7 +135,11 @@ class EncryptRuleConfigurationTest {
}
private static EncryptRuleConfiguration createRuleConfiguration(final EncryptColumnRuleConfiguration columnConfig) {
+ return createRuleConfiguration(columnConfig, Collections.emptyMap());
+ }
+
+ private static EncryptRuleConfiguration createRuleConfiguration(final EncryptColumnRuleConfiguration columnConfig, final Map<String, AlgorithmConfiguration> encryptors) {
EncryptTableRuleConfiguration tableConfig = new EncryptTableRuleConfiguration("foo_tbl", Collections.singleton(columnConfig));
- return new EncryptRuleConfiguration(Collections.singleton(tableConfig), Collections.emptyMap());
+ return new EncryptRuleConfiguration(Collections.singleton(tableConfig), encryptors);
}
}
diff --git a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationChecker.java b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationChecker.java
index e9df89c841f..429796130be 100644
--- a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationChecker.java
+++ b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationChecker.java
@@ -18,20 +18,11 @@
package org.apache.shardingsphere.encrypt.checker.config;
import org.apache.shardingsphere.encrypt.config.EncryptRuleConfiguration;
-import org.apache.shardingsphere.encrypt.config.rule.EncryptColumnItemRuleConfiguration;
-import org.apache.shardingsphere.encrypt.config.rule.EncryptColumnRuleConfiguration;
import org.apache.shardingsphere.encrypt.config.rule.EncryptTableRuleConfiguration;
import org.apache.shardingsphere.encrypt.constant.EncryptOrder;
-import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
-import org.apache.shardingsphere.infra.algorithm.core.exception.UnregisteredAlgorithmException;
import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
-import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
-import org.apache.shardingsphere.infra.exception.external.sql.identifier.SQLExceptionIdentifier;
-import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
-import javax.sql.DataSource;
import java.util.Collection;
-import java.util.Map;
import java.util.stream.Collectors;
/**
@@ -39,31 +30,6 @@ import java.util.stream.Collectors;
*/
public final class EncryptRuleConfigurationChecker implements DatabaseRuleConfigurationChecker<EncryptRuleConfiguration> {
- @Override
- public void check(final String databaseName, final EncryptRuleConfiguration ruleConfig, final Map<String, DataSource> dataSourceMap, final Collection<ShardingSphereRule> builtRules) {
- checkTables(databaseName, ruleConfig.getTables(), ruleConfig.getEncryptors());
- }
-
- private void checkTables(final String databaseName, final Collection<EncryptTableRuleConfiguration> tableRuleConfigs, final Map<String, AlgorithmConfiguration> encryptors) {
- tableRuleConfigs.forEach(each -> checkColumns(databaseName, each, encryptors));
- }
-
- private void checkColumns(final String databaseName, final EncryptTableRuleConfiguration tableRuleConfig, final Map<String, AlgorithmConfiguration> encryptors) {
- tableRuleConfig.getColumns().forEach(each -> checkColumn(databaseName, tableRuleConfig.getName(), each, encryptors));
- }
-
- private void checkColumn(final String databaseName, final String tableName, final EncryptColumnRuleConfiguration columnRuleConfig, final Map<String, AlgorithmConfiguration> encryptors) {
- checkEncryptColumnItem(databaseName, tableName, columnRuleConfig.getName(), columnRuleConfig.getCipher(), encryptors, "Cipher");
- columnRuleConfig.getAssistedQuery().ifPresent(optional -> checkEncryptColumnItem(databaseName, tableName, columnRuleConfig.getName(), optional, encryptors, "Assist Query"));
- columnRuleConfig.getLikeQuery().ifPresent(optional -> checkEncryptColumnItem(databaseName, tableName, columnRuleConfig.getName(), optional, encryptors, "Like Query"));
- }
-
- private void checkEncryptColumnItem(final String databaseName, final String tableName, final String logicColumnName,
- final EncryptColumnItemRuleConfiguration columnItem, final Map<String, AlgorithmConfiguration> encryptors, final String itemType) {
- ShardingSpherePreconditions.checkContainsKey(encryptors, columnItem.getEncryptorName(),
- () -> new UnregisteredAlgorithmException(itemType + " encrypt", columnItem.getEncryptorName(), new SQLExceptionIdentifier(databaseName, tableName, logicColumnName)));
- }
-
@Override
public Collection<String> getTableNames(final EncryptRuleConfiguration ruleConfig) {
return ruleConfig.getTables().stream().map(EncryptTableRuleConfiguration::getName).collect(Collectors.toList());
diff --git a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationCheckerTest.java b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationCheckerTest.java
index 12fe9957466..fac2d6f05cd 100644
--- a/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationCheckerTest.java
+++ b/features/encrypt/core/src/test/java/org/apache/shardingsphere/encrypt/checker/config/EncryptRuleConfigurationCheckerTest.java
@@ -18,25 +18,16 @@
package org.apache.shardingsphere.encrypt.checker.config;
import org.apache.shardingsphere.encrypt.config.EncryptRuleConfiguration;
-import org.apache.shardingsphere.encrypt.config.rule.EncryptColumnItemRuleConfiguration;
-import org.apache.shardingsphere.encrypt.config.rule.EncryptColumnRuleConfiguration;
import org.apache.shardingsphere.encrypt.config.rule.EncryptTableRuleConfiguration;
-import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
-import org.apache.shardingsphere.infra.algorithm.core.exception.UnregisteredAlgorithmException;
import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-import java.util.Collection;
import java.util.Collections;
-import java.util.Map;
-import java.util.Properties;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
-import static org.junit.jupiter.api.Assertions.assertThrows;
class EncryptRuleConfigurationCheckerTest {
@@ -48,62 +39,8 @@ class EncryptRuleConfigurationCheckerTest {
checker = OrderedSPILoader.getServicesByClass(DatabaseRuleConfigurationChecker.class, Collections.singleton(EncryptRuleConfiguration.class)).get(EncryptRuleConfiguration.class);
}
- @SuppressWarnings("unchecked")
- @Test
- void assertCheckSuccess() {
- EncryptRuleConfiguration ruleConfig = createValidRuleConfiguration();
- assertDoesNotThrow(() -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
- }
-
private EncryptRuleConfiguration createValidRuleConfiguration() {
- EncryptColumnRuleConfiguration columnRuleConfig = new EncryptColumnRuleConfiguration("user_id", new EncryptColumnItemRuleConfiguration("user_cipher", "aes_encryptor"));
- Collection<EncryptTableRuleConfiguration> tables = Collections.singleton(new EncryptTableRuleConfiguration("t_encrypt", Collections.singleton(columnRuleConfig)));
- Map<String, AlgorithmConfiguration> encryptors = Collections.singletonMap("aes_encryptor", new AlgorithmConfiguration("MD5", new Properties()));
- return new EncryptRuleConfiguration(tables, encryptors);
- }
-
- @SuppressWarnings("unchecked")
- @Test
- void assertCheckWithUnregisteredCipherEncryptor() {
- EncryptRuleConfiguration ruleConfig = createRuleConfigurationWithUnregisteredCipherEncryptor();
- assertThrows(UnregisteredAlgorithmException.class, () -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
- }
-
- private EncryptRuleConfiguration createRuleConfigurationWithUnregisteredCipherEncryptor() {
- EncryptColumnRuleConfiguration columnRuleConfig = new EncryptColumnRuleConfiguration("user_id", new EncryptColumnItemRuleConfiguration("user_cipher", "no_encryptor"));
- Collection<EncryptTableRuleConfiguration> tables = Collections.singleton(new EncryptTableRuleConfiguration("t_encrypt", Collections.singleton(columnRuleConfig)));
- Map<String, AlgorithmConfiguration> encryptors = Collections.singletonMap("aes_encryptor", new AlgorithmConfiguration("MD5", new Properties()));
- return new EncryptRuleConfiguration(tables, encryptors);
- }
-
- @SuppressWarnings("unchecked")
- @Test
- void assertCheckWithInvalidAssistColumn() {
- EncryptRuleConfiguration ruleConfig = createRuleConfigurationWithInvalidAssistColumn();
- assertThrows(UnregisteredAlgorithmException.class, () -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
- }
-
- private EncryptRuleConfiguration createRuleConfigurationWithInvalidAssistColumn() {
- EncryptColumnRuleConfiguration columnRuleConfig = new EncryptColumnRuleConfiguration("user_id", new EncryptColumnItemRuleConfiguration("user_cipher", "aes_encryptor"));
- columnRuleConfig.setAssistedQuery(new EncryptColumnItemRuleConfiguration("user_assisted", "aes_assisted_encryptor"));
- Collection<EncryptTableRuleConfiguration> tables = Collections.singleton(new EncryptTableRuleConfiguration("t_encrypt", Collections.singleton(columnRuleConfig)));
- Map<String, AlgorithmConfiguration> encryptors = Collections.singletonMap("aes_encryptor", new AlgorithmConfiguration("MD5", new Properties()));
- return new EncryptRuleConfiguration(tables, encryptors);
- }
-
- @SuppressWarnings("unchecked")
- @Test
- void assertCheckWithInvalidLikeColumn() {
- EncryptRuleConfiguration ruleConfig = createRuleConfigurationWithInvalidLikeColumn();
- assertThrows(UnregisteredAlgorithmException.class, () -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
- }
-
- private EncryptRuleConfiguration createRuleConfigurationWithInvalidLikeColumn() {
- EncryptColumnRuleConfiguration columnRuleConfig = new EncryptColumnRuleConfiguration("user_id", new EncryptColumnItemRuleConfiguration("user_cipher", "aes_encryptor"));
- columnRuleConfig.setLikeQuery(new EncryptColumnItemRuleConfiguration("user_like", "like_cn_encryptor"));
- Collection<EncryptTableRuleConfiguration> tables = Collections.singleton(new EncryptTableRuleConfiguration("t_encrypt", Collections.singleton(columnRuleConfig)));
- Map<String, AlgorithmConfiguration> encryptors = Collections.singletonMap("aes_encryptor", new AlgorithmConfiguration("MD5", new Properties()));
- return new EncryptRuleConfiguration(tables, encryptors);
+ return new EncryptRuleConfiguration(Collections.singleton(new EncryptTableRuleConfiguration("t_encrypt", Collections.emptyList())), Collections.emptyMap());
}
@SuppressWarnings("unchecked")
diff --git a/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/MaskRuleConfiguration.java b/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/MaskRuleConfiguration.java
index 778c9883fe0..436d4c64f33 100644
--- a/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/MaskRuleConfiguration.java
+++ b/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/MaskRuleConfiguration.java
@@ -24,7 +24,9 @@ import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfigurat
import org.apache.shardingsphere.infra.config.rule.function.EnhancedRuleConfiguration;
import org.apache.shardingsphere.infra.config.rule.scope.DatabaseRuleConfiguration;
import org.apache.shardingsphere.infra.config.rule.validator.constraint.spi.SPITypeExists;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
import org.apache.shardingsphere.mask.config.rule.MaskTableRuleConfiguration;
+import org.apache.shardingsphere.mask.config.validator.ValidMaskRuleConfiguration;
import javax.validation.Valid;
import javax.validation.constraints.NotBlank;
@@ -38,6 +40,7 @@ import java.util.stream.Collectors;
*/
@RequiredArgsConstructor
@Getter
+@ValidMaskRuleConfiguration(groups = RuleConfigurationTypeValidationGroup.class)
public final class MaskRuleConfiguration implements DatabaseRuleConfiguration, EnhancedRuleConfiguration {
@NotNull
diff --git a/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/validator/MaskRuleConfigurationValidator.java b/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/validator/MaskRuleConfigurationValidator.java
new file mode 100644
index 00000000000..ff30672097c
--- /dev/null
+++ b/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/validator/MaskRuleConfigurationValidator.java
@@ -0,0 +1,49 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.mask.config.validator;
+
+import org.apache.shardingsphere.mask.config.MaskRuleConfiguration;
+import org.apache.shardingsphere.mask.config.rule.MaskColumnRuleConfiguration;
+import org.apache.shardingsphere.mask.config.rule.MaskTableRuleConfiguration;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+
+/**
+ * Mask rule configuration validator.
+ */
+public final class MaskRuleConfigurationValidator implements ConstraintValidator<ValidMaskRuleConfiguration, MaskRuleConfiguration> {
+
+ @Override
+ public boolean isValid(final MaskRuleConfiguration value, final ConstraintValidatorContext context) {
+ return value.getTables().stream().allMatch(each -> isTableValid(each, value, context));
+ }
+
+ private boolean isTableValid(final MaskTableRuleConfiguration tableConfig, final MaskRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+ return tableConfig.getColumns().stream().allMatch(each -> isColumnValid(each, ruleConfig, context));
+ }
+
+ private boolean isColumnValid(final MaskColumnRuleConfiguration columnConfig, final MaskRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+ if (ruleConfig.getMaskAlgorithms().containsKey(columnConfig.getMaskAlgorithm())) {
+ return true;
+ }
+ context.disableDefaultConstraintViolation();
+ context.buildConstraintViolationWithTemplate(String.format("references unconfigured mask algorithm `%s`", columnConfig.getMaskAlgorithm())).addPropertyNode("tables").addConstraintViolation();
+ return false;
+ }
+}
diff --git a/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/validator/ValidMaskRuleConfiguration.java b/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/validator/ValidMaskRuleConfiguration.java
new file mode 100644
index 00000000000..e180304829a
--- /dev/null
+++ b/features/mask/api/src/main/java/org/apache/shardingsphere/mask/config/validator/ValidMaskRuleConfiguration.java
@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.mask.config.validator;
+
+import javax.validation.Constraint;
+import javax.validation.Payload;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Valid mask rule configuration constraint.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Constraint(validatedBy = MaskRuleConfigurationValidator.class)
+@Documented
+public @interface ValidMaskRuleConfiguration {
+
+ /**
+ * Get message.
+ *
+ * @return message
+ */
+ String message() default "contains invalid references";
+
+ /**
+ * Get groups.
+ *
+ * @return groups
+ */
+ Class<?>[] groups() default {};
+
+ /**
+ * Get payload.
+ *
+ * @return payload
+ */
+ Class<? extends Payload>[] payload() default {};
+}
diff --git a/features/mask/api/src/test/java/org/apache/shardingsphere/mask/config/MaskRuleConfigurationTest.java b/features/mask/api/src/test/java/org/apache/shardingsphere/mask/config/MaskRuleConfigurationTest.java
index d69e484736c..fba5178de20 100644
--- a/features/mask/api/src/test/java/org/apache/shardingsphere/mask/config/MaskRuleConfigurationTest.java
+++ b/features/mask/api/src/test/java/org/apache/shardingsphere/mask/config/MaskRuleConfigurationTest.java
@@ -92,7 +92,8 @@ class MaskRuleConfigurationTest {
Arguments.of("Null column", new MaskRuleConfiguration(
Collections.singleton(new MaskTableRuleConfiguration("foo_tbl", Collections.singleton(null))), Collections.emptyMap())),
Arguments.of("Blank logic column", createRuleConfiguration(new MaskColumnRuleConfiguration("", "foo_mask"))),
- Arguments.of("Blank column mask algorithm", createRuleConfiguration(new MaskColumnRuleConfiguration("foo_col", ""))));
+ Arguments.of("Blank column mask algorithm", createRuleConfiguration(new MaskColumnRuleConfiguration("foo_col", ""))),
+ Arguments.of("Unconfigured column mask algorithm", createRuleConfiguration(new MaskColumnRuleConfiguration("foo_col", "foo_mask"))));
}
private static MaskRuleConfiguration createRuleConfiguration(final MaskColumnRuleConfiguration columnConfig) {
diff --git a/features/mask/core/src/main/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationChecker.java b/features/mask/core/src/main/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationChecker.java
index 980661c2c36..44930f13ad9 100644
--- a/features/mask/core/src/main/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationChecker.java
+++ b/features/mask/core/src/main/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationChecker.java
@@ -17,20 +17,12 @@
package org.apache.shardingsphere.mask.checker;
-import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
-import org.apache.shardingsphere.infra.algorithm.core.exception.UnregisteredAlgorithmException;
import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
-import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
-import org.apache.shardingsphere.infra.exception.external.sql.identifier.SQLExceptionIdentifier;
-import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.mask.config.MaskRuleConfiguration;
-import org.apache.shardingsphere.mask.config.rule.MaskColumnRuleConfiguration;
import org.apache.shardingsphere.mask.config.rule.MaskTableRuleConfiguration;
import org.apache.shardingsphere.mask.constant.MaskOrder;
-import javax.sql.DataSource;
import java.util.Collection;
-import java.util.Map;
import java.util.stream.Collectors;
/**
@@ -38,24 +30,6 @@ import java.util.stream.Collectors;
*/
public final class MaskRuleConfigurationChecker implements DatabaseRuleConfigurationChecker<MaskRuleConfiguration> {
- @Override
- public void check(final String databaseName, final MaskRuleConfiguration ruleConfig, final Map<String, DataSource> dataSourceMap, final Collection<ShardingSphereRule> builtRules) {
- checkTables(databaseName, ruleConfig.getTables(), ruleConfig.getMaskAlgorithms());
- }
-
- private void checkTables(final String databaseName, final Collection<MaskTableRuleConfiguration> tables, final Map<String, AlgorithmConfiguration> maskAlgorithms) {
- tables.forEach(each -> checkColumns(databaseName, each, maskAlgorithms));
- }
-
- private void checkColumns(final String databaseName, final MaskTableRuleConfiguration tableRuleConfig, final Map<String, AlgorithmConfiguration> maskAlgorithms) {
- tableRuleConfig.getColumns().forEach(each -> checkColumn(databaseName, tableRuleConfig.getName(), each, maskAlgorithms));
- }
-
- private void checkColumn(final String databaseName, final String tableName, final MaskColumnRuleConfiguration columnRuleConfig, final Map<String, AlgorithmConfiguration> maskAlgorithms) {
- ShardingSpherePreconditions.checkContainsKey(maskAlgorithms, columnRuleConfig.getMaskAlgorithm(),
- () -> new UnregisteredAlgorithmException("Mask", columnRuleConfig.getMaskAlgorithm(), new SQLExceptionIdentifier(databaseName, tableName, columnRuleConfig.getLogicColumn())));
- }
-
@Override
public Collection<String> getTableNames(final MaskRuleConfiguration ruleConfig) {
return ruleConfig.getTables().stream().map(MaskTableRuleConfiguration::getName).collect(Collectors.toList());
diff --git a/features/mask/core/src/test/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationCheckerTest.java b/features/mask/core/src/test/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationCheckerTest.java
index 1c0f0b7fac8..00ae6600335 100644
--- a/features/mask/core/src/test/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationCheckerTest.java
+++ b/features/mask/core/src/test/java/org/apache/shardingsphere/mask/checker/MaskRuleConfigurationCheckerTest.java
@@ -17,19 +17,15 @@
package org.apache.shardingsphere.mask.checker;
-import org.apache.shardingsphere.infra.algorithm.core.exception.UnregisteredAlgorithmException;
import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
import org.apache.shardingsphere.mask.config.MaskRuleConfiguration;
-import org.apache.shardingsphere.mask.config.rule.MaskColumnRuleConfiguration;
import org.apache.shardingsphere.mask.config.rule.MaskTableRuleConfiguration;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.Collections;
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
-import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@@ -46,9 +42,8 @@ class MaskRuleConfigurationCheckerTest {
@SuppressWarnings("unchecked")
@Test
- void assertValidCheck() {
+ void assertGetTableNames() {
MaskRuleConfiguration ruleConfig = mockValidConfiguration();
- assertDoesNotThrow(() -> checker.check("test", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
assertTrue(checker.getTableNames(ruleConfig).contains("t_mask"));
}
@@ -60,20 +55,4 @@ class MaskRuleConfigurationCheckerTest {
return result;
}
- @SuppressWarnings("unchecked")
- @Test
- void assertInvalidCheck() {
- MaskRuleConfiguration ruleConfig = mockInvalidConfiguration();
- assertThrows(UnregisteredAlgorithmException.class, () -> checker.check("test", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
- }
-
- private MaskRuleConfiguration mockInvalidConfiguration() {
- MaskRuleConfiguration result = mock(MaskRuleConfiguration.class);
- MaskTableRuleConfiguration tableRuleConfig = mock(MaskTableRuleConfiguration.class);
- MaskColumnRuleConfiguration columnRuleConfig = mock(MaskColumnRuleConfiguration.class);
- when(columnRuleConfig.getMaskAlgorithm()).thenReturn("md5");
- when(tableRuleConfig.getColumns()).thenReturn(Collections.singleton(columnRuleConfig));
- when(result.getTables()).thenReturn(Collections.singleton(tableRuleConfig));
- return result;
- }
}
diff --git a/features/readwrite-splitting/api/pom.xml b/features/readwrite-splitting/api/pom.xml
index f19fd9f23d7..fffe3c0a126 100644
--- a/features/readwrite-splitting/api/pom.xml
+++ b/features/readwrite-splitting/api/pom.xml
@@ -29,7 +29,7 @@
<dependencies>
<dependency>
<groupId>org.apache.shardingsphere</groupId>
- <artifactId>shardingsphere-infra-algorithm-core</artifactId>
+ <artifactId>shardingsphere-infra-algorithm-load-balancer-spi</artifactId>
<version>${project.version}</version>
</dependency>
diff --git a/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/ReadwriteSplittingRuleConfiguration.java b/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/ReadwriteSplittingRuleConfiguration.java
index 8a81b473f9e..1e573d01325 100644
--- a/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/ReadwriteSplittingRuleConfiguration.java
+++ b/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/ReadwriteSplittingRuleConfiguration.java
@@ -22,7 +22,10 @@ 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.infra.config.rule.validator.constraint.spi.SPITypeExists;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
import org.apache.shardingsphere.readwritesplitting.config.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
+import org.apache.shardingsphere.readwritesplitting.config.validator.ValidReadwriteSplittingRuleConfiguration;
import javax.validation.Valid;
import javax.validation.constraints.NotBlank;
@@ -35,6 +38,7 @@ import java.util.Map;
*/
@RequiredArgsConstructor
@Getter
+@ValidReadwriteSplittingRuleConfiguration(groups = RuleConfigurationTypeValidationGroup.class)
public final class ReadwriteSplittingRuleConfiguration implements DatabaseRuleConfiguration, DistributedRuleConfiguration {
@NotNull
@@ -42,5 +46,6 @@ public final class ReadwriteSplittingRuleConfiguration implements DatabaseRuleCo
private final Collection<@NotNull ReadwriteSplittingDataSourceGroupRuleConfiguration> dataSourceGroups;
@NotNull
+ @SPITypeExists(spiClassName = "org.apache.shardingsphere.infra.algorithm.loadbalancer.spi.LoadBalanceAlgorithm")
private final Map<@NotBlank String, @NotNull AlgorithmConfiguration> loadBalancers;
}
diff --git a/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/validator/ReadwriteSplittingRuleConfigurationValidator.java b/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/validator/ReadwriteSplittingRuleConfigurationValidator.java
new file mode 100644
index 00000000000..1c732eb681a
--- /dev/null
+++ b/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/validator/ReadwriteSplittingRuleConfigurationValidator.java
@@ -0,0 +1,47 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.readwritesplitting.config.validator;
+
+import com.google.common.base.Strings;
+import org.apache.shardingsphere.readwritesplitting.config.ReadwriteSplittingRuleConfiguration;
+import org.apache.shardingsphere.readwritesplitting.config.rule.ReadwriteSplittingDataSourceGroupRuleConfiguration;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+
+/**
+ * Readwrite-splitting rule configuration validator.
+ */
+public final class ReadwriteSplittingRuleConfigurationValidator implements ConstraintValidator<ValidReadwriteSplittingRuleConfiguration, ReadwriteSplittingRuleConfiguration> {
+
+ @Override
+ public boolean isValid(final ReadwriteSplittingRuleConfiguration value, final ConstraintValidatorContext context) {
+ return value.getDataSourceGroups().stream().allMatch(each -> isLoadBalancerReferenceValid(each, value, context));
+ }
+
+ private boolean isLoadBalancerReferenceValid(final ReadwriteSplittingDataSourceGroupRuleConfiguration dataSourceGroupConfig,
+ final ReadwriteSplittingRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+ if (Strings.isNullOrEmpty(dataSourceGroupConfig.getLoadBalancerName()) || ruleConfig.getLoadBalancers().containsKey(dataSourceGroupConfig.getLoadBalancerName())) {
+ return true;
+ }
+ context.disableDefaultConstraintViolation();
+ context.buildConstraintViolationWithTemplate(String.format("references unconfigured load balancer `%s`", dataSourceGroupConfig.getLoadBalancerName()))
+ .addPropertyNode("dataSourceGroups").addConstraintViolation();
+ return false;
+ }
+}
diff --git a/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/validator/ValidReadwriteSplittingRuleConfiguration.java b/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/validator/ValidReadwriteSplittingRuleConfiguration.java
new file mode 100644
index 00000000000..b4cd57e365e
--- /dev/null
+++ b/features/readwrite-splitting/api/src/main/java/org/apache/shardingsphere/readwritesplitting/config/validator/ValidReadwriteSplittingRuleConfiguration.java
@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.readwritesplitting.config.validator;
+
+import javax.validation.Constraint;
+import javax.validation.Payload;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Valid readwrite-splitting rule configuration constraint.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Constraint(validatedBy = ReadwriteSplittingRuleConfigurationValidator.class)
+@Documented
+public @interface ValidReadwriteSplittingRuleConfiguration {
+
+ /**
+ * Get message.
+ *
+ * @return message
+ */
+ String message() default "contains invalid references";
+
+ /**
+ * Get groups.
+ *
+ * @return groups
+ */
+ Class<?>[] groups() default {};
+
+ /**
+ * Get payload.
+ *
+ * @return payload
+ */
+ Class<? extends Payload>[] payload() default {};
+}
diff --git a/features/readwrite-splitting/api/src/test/java/org/apache/shardingsphere/readwritesplitting/config/ReadwriteSplittingRuleConfigurationTest.java b/features/readwrite-splitting/api/src/test/java/org/apache/shardingsphere/readwritesplitting/config/ReadwriteSplittingRuleConfigurationTest.java
index 930ad7ea26d..ced5782afa7 100644
--- a/features/readwrite-splitting/api/src/test/java/org/apache/shardingsphere/readwritesplitting/config/ReadwriteSplittingRuleConfigurationTest.java
+++ b/features/readwrite-splitting/api/src/test/java/org/apache/shardingsphere/readwritesplitting/config/ReadwriteSplittingRuleConfigurationTest.java
@@ -52,7 +52,7 @@ class ReadwriteSplittingRuleConfigurationTest {
"foo_group", "foo_write", Collections.singletonList("foo_read"), null)),
Collections.emptyMap())),
Arguments.of("Complete configuration", new ReadwriteSplittingRuleConfiguration(Collections.singleton(dataSourceGroupConfig),
- Collections.singletonMap("foo_load_balancer", new AlgorithmConfiguration("ROUND_ROBIN", new Properties())))));
+ Collections.singletonMap("foo_load_balancer", new AlgorithmConfiguration("FIXTURE", new Properties())))));
}
@ParameterizedTest(name = "{0}")
@@ -62,7 +62,7 @@ class ReadwriteSplittingRuleConfigurationTest {
}
private static Stream<Arguments> invalidRuleConfigurationArguments() {
- AlgorithmConfiguration loadBalancer = new AlgorithmConfiguration("ROUND_ROBIN", new Properties());
+ AlgorithmConfiguration loadBalancer = new AlgorithmConfiguration("FIXTURE", new Properties());
return Stream.of(
Arguments.of("Null data source groups", new ReadwriteSplittingRuleConfiguration(null, Collections.emptyMap())),
Arguments.of("Null data source group", new ReadwriteSplittingRuleConfiguration(Collections.singleton(null), Collections.emptyMap())),
@@ -71,6 +71,12 @@ class ReadwriteSplittingRuleConfigurationTest {
Collections.emptyList(), Collections.singletonMap("", loadBalancer))),
Arguments.of("Null load balancer", new ReadwriteSplittingRuleConfiguration(
Collections.emptyList(), Collections.singletonMap("foo_load_balancer", null))),
+ Arguments.of("Missing load balancer type", new ReadwriteSplittingRuleConfiguration(
+ Collections.emptyList(), Collections.singletonMap("foo_load_balancer", new AlgorithmConfiguration("MISSING", new Properties())))),
+ Arguments.of("Unconfigured group load balancer", new ReadwriteSplittingRuleConfiguration(Collections.singleton(
+ new ReadwriteSplittingDataSourceGroupRuleConfiguration(
+ "foo_group", "foo_write", Collections.singletonList("foo_read"), TransactionalReadQueryStrategy.PRIMARY, "bar_load_balancer")),
+ Collections.singletonMap("foo_load_balancer", loadBalancer))),
Arguments.of("Blank group name", createRuleConfiguration(new ReadwriteSplittingDataSourceGroupRuleConfiguration(
"", "foo_write", Collections.singletonList("foo_read"), TransactionalReadQueryStrategy.PRIMARY, null))),
Arguments.of("Blank write data source", createRuleConfiguration(new ReadwriteSplittingDataSourceGroupRuleConfiguration(
diff --git a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/exception/metadata/NotImplementHintShadowAlgorithmException.java b/features/readwrite-splitting/api/src/test/java/org/apache/shardingsphere/readwritesplitting/config/fixture/LoadBalanceAlgorithmFixture.java
similarity index 57%
rename from features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/exception/metadata/NotImplementHintShadowAlgorithmException.java
rename to features/readwrite-splitting/api/src/test/java/org/apache/shardingsphere/readwritesplitting/config/fixture/LoadBalanceAlgorithmFixture.java
index 64c85f532ac..ee56bcbe278 100644
--- a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/exception/metadata/NotImplementHintShadowAlgorithmException.java
+++ b/features/readwrite-splitting/api/src/test/java/org/apache/shardingsphere/readwritesplitting/config/fixture/LoadBalanceAlgorithmFixture.java
@@ -15,19 +15,24 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.shadow.exception.metadata;
+package org.apache.shardingsphere.readwritesplitting.config.fixture;
-import org.apache.shardingsphere.infra.exception.external.sql.sqlstate.XOpenSQLState;
-import org.apache.shardingsphere.shadow.exception.ShadowSQLException;
+import org.apache.shardingsphere.infra.algorithm.loadbalancer.spi.LoadBalanceAlgorithm;
+
+import java.util.List;
/**
- * Not implement hint shadow algorithm exception.
+ * Load balance algorithm fixture.
*/
-public final class NotImplementHintShadowAlgorithmException extends ShadowSQLException {
+public final class LoadBalanceAlgorithmFixture implements LoadBalanceAlgorithm {
- private static final long serialVersionUID = -5012158924968675485L;
+ @Override
+ public String getTargetName(final String groupName, final List<String> availableTargetNames) {
+ return availableTargetNames.get(0);
+ }
- public NotImplementHintShadowAlgorithmException() {
- super(XOpenSQLState.CHECK_OPTION_VIOLATION, 3, "Default shadow algorithm class should be implement HintShadowAlgorithm.");
+ @Override
+ public String getType() {
+ return "FIXTURE";
}
}
diff --git a/features/readwrite-splitting/api/src/test/resources/META-INF/services/org.apache.shardingsphere.infra.algorithm.loadbalancer.spi.LoadBalanceAlgorithm b/features/readwrite-splitting/api/src/test/resources/META-INF/services/org.apache.shardingsphere.infra.algorithm.loadbalancer.spi.LoadBalanceAlgorithm
new file mode 100644
index 00000000000..23109945814
--- /dev/null
+++ b/features/readwrite-splitting/api/src/test/resources/META-INF/services/org.apache.shardingsphere.infra.algorithm.loadbalancer.spi.LoadBalanceAlgorithm
@@ -0,0 +1,18 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+org.apache.shardingsphere.readwritesplitting.config.fixture.LoadBalanceAlgorithmFixture
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 fa81656d915..19507692772 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
@@ -18,11 +18,8 @@
package org.apache.shardingsphere.readwritesplitting.checker;
import com.google.common.base.Strings;
-import org.apache.shardingsphere.infra.algorithm.core.exception.UnregisteredAlgorithmException;
import org.apache.shardingsphere.infra.algorithm.loadbalancer.spi.LoadBalanceAlgorithm;
import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
-import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
-import org.apache.shardingsphere.infra.exception.external.sql.identifier.SQLExceptionIdentifier;
import org.apache.shardingsphere.infra.expr.entry.InlineExpressionParserFactory;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.infra.spi.type.typed.TypedSPILoader;
@@ -65,7 +62,6 @@ public final class ReadwriteSplittingRuleConfigurationChecker implements Databas
continue;
}
LoadBalanceAlgorithm loadBalancer = loadBalancers.get(each.getLoadBalancerName());
- ShardingSpherePreconditions.checkNotNull(loadBalancer, () -> new UnregisteredAlgorithmException("Load balancer", each.getLoadBalancerName(), new SQLExceptionIdentifier(databaseName)));
loadBalancer.check(databaseName, getActualDataSourceNames(each.getReadDataSourceNames()));
}
}
diff --git a/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/ShadowRuleConfiguration.java b/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/ShadowRuleConfiguration.java
index 7480cfda1d5..fa04928d73b 100644
--- a/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/ShadowRuleConfiguration.java
+++ b/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/ShadowRuleConfiguration.java
@@ -23,8 +23,10 @@ import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfigurat
import org.apache.shardingsphere.infra.config.rule.function.DistributedRuleConfiguration;
import org.apache.shardingsphere.infra.config.rule.scope.DatabaseRuleConfiguration;
import org.apache.shardingsphere.infra.config.rule.validator.constraint.spi.SPITypeExists;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
import org.apache.shardingsphere.shadow.config.datasource.ShadowDataSourceConfiguration;
import org.apache.shardingsphere.shadow.config.table.ShadowTableConfiguration;
+import org.apache.shardingsphere.shadow.config.validator.ValidShadowRuleConfiguration;
import javax.validation.Valid;
import javax.validation.constraints.NotBlank;
@@ -39,6 +41,7 @@ import java.util.Map;
*/
@Getter
@Setter
+@ValidShadowRuleConfiguration(groups = RuleConfigurationTypeValidationGroup.class)
public final class ShadowRuleConfiguration implements DatabaseRuleConfiguration, DistributedRuleConfiguration {
@NotNull
diff --git a/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/validator/ShadowRuleConfigurationValidator.java b/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/validator/ShadowRuleConfigurationValidator.java
new file mode 100644
index 00000000000..a640e91b2ef
--- /dev/null
+++ b/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/validator/ShadowRuleConfigurationValidator.java
@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.shadow.config.validator;
+
+import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
+import org.apache.shardingsphere.shadow.config.ShadowRuleConfiguration;
+import org.apache.shardingsphere.shadow.config.datasource.ShadowDataSourceConfiguration;
+import org.apache.shardingsphere.shadow.config.table.ShadowTableConfiguration;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+import java.util.Collection;
+import java.util.stream.Collectors;
+
+/**
+ * Shadow rule configuration validator.
+ */
+public final class ShadowRuleConfigurationValidator implements ConstraintValidator<ValidShadowRuleConfiguration, ShadowRuleConfiguration> {
+
+ @Override
+ public boolean isValid(final ShadowRuleConfiguration value, final ConstraintValidatorContext context) {
+ return isDefaultShadowAlgorithmValid(value, context) && areTableDataSourcesValid(value, context) && areTableAlgorithmsValid(value, context);
+ }
+
+ private boolean isDefaultShadowAlgorithmValid(final ShadowRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+ if (null == ruleConfig.getDefaultShadowAlgorithmName()) {
+ return true;
+ }
+ AlgorithmConfiguration algorithmConfig = ruleConfig.getShadowAlgorithms().get(ruleConfig.getDefaultShadowAlgorithmName());
+ if (null != algorithmConfig && "SQL_HINT".equals(algorithmConfig.getType())) {
+ return true;
+ }
+ context.disableDefaultConstraintViolation();
+ context.buildConstraintViolationWithTemplate("must reference a configured SQL_HINT shadow algorithm").addPropertyNode("defaultShadowAlgorithmName").addConstraintViolation();
+ return false;
+ }
+
+ private boolean areTableDataSourcesValid(final ShadowRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+ Collection<String> dataSourceNames = ruleConfig.getDataSources().stream().map(ShadowDataSourceConfiguration::getName).collect(Collectors.toSet());
+ return ruleConfig.getTables().entrySet().stream().allMatch(entry -> areTableDataSourcesValid(entry.getKey(), entry.getValue(), dataSourceNames, context));
+ }
+
+ private boolean areTableDataSourcesValid(final String tableName, final ShadowTableConfiguration tableConfig, final Collection<String> dataSourceNames, final ConstraintValidatorContext context) {
+ for (String each : tableConfig.getDataSourceNames()) {
+ if (!dataSourceNames.contains(each)) {
+ context.disableDefaultConstraintViolation();
+ context.buildConstraintViolationWithTemplate(String.format("table `%s` references unconfigured shadow data source `%s`", tableName, each))
+ .addPropertyNode("tables").addConstraintViolation();
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private boolean areTableAlgorithmsValid(final ShadowRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+ return ruleConfig.getTables().entrySet().stream().allMatch(entry -> areTableAlgorithmsValid(entry.getKey(), entry.getValue(), ruleConfig, context));
+ }
+
+ private boolean areTableAlgorithmsValid(final String tableName, final ShadowTableConfiguration tableConfig, final ShadowRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+ for (String each : tableConfig.getShadowAlgorithmNames()) {
+ if (!ruleConfig.getShadowAlgorithms().containsKey(each)) {
+ context.disableDefaultConstraintViolation();
+ context.buildConstraintViolationWithTemplate(String.format("table `%s` references unconfigured shadow algorithm `%s`", tableName, each))
+ .addPropertyNode("tables").addConstraintViolation();
+ return false;
+ }
+ }
+ return true;
+ }
+}
diff --git a/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/validator/ValidShadowRuleConfiguration.java b/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/validator/ValidShadowRuleConfiguration.java
new file mode 100644
index 00000000000..626c3d7c7d5
--- /dev/null
+++ b/features/shadow/api/src/main/java/org/apache/shardingsphere/shadow/config/validator/ValidShadowRuleConfiguration.java
@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.shadow.config.validator;
+
+import javax.validation.Constraint;
+import javax.validation.Payload;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Valid shadow rule configuration constraint.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Constraint(validatedBy = ShadowRuleConfigurationValidator.class)
+@Documented
+public @interface ValidShadowRuleConfiguration {
+
+ /**
+ * Get message.
+ *
+ * @return message
+ */
+ String message() default "contains invalid references";
+
+ /**
+ * Get groups.
+ *
+ * @return groups
+ */
+ Class<?>[] groups() default {};
+
+ /**
+ * Get payload.
+ *
+ * @return payload
+ */
+ Class<? extends Payload>[] payload() default {};
+}
diff --git a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/ShadowRuleConfigurationTest.java b/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/ShadowRuleConfigurationTest.java
index 421f468f866..bbb051c6b8d 100644
--- a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/ShadowRuleConfigurationTest.java
+++ b/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/ShadowRuleConfigurationTest.java
@@ -26,7 +26,6 @@ import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
-import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
@@ -45,6 +44,10 @@ class ShadowRuleConfigurationTest {
}
private static Stream<Arguments> validRuleConfigurationArguments() {
+ ShadowRuleConfiguration defaultAlgorithmRuleConfig = createRuleConfiguration(
+ Collections.singleton(new ShadowDataSourceConfiguration("foo_ds", "foo_primary", "foo_shadow")), Collections.emptyMap(),
+ Collections.singletonMap("foo_shadow_algorithm", new AlgorithmConfiguration("SQL_HINT", new Properties())));
+ defaultAlgorithmRuleConfig.setDefaultShadowAlgorithmName("foo_shadow_algorithm");
return Stream.of(
Arguments.of("Empty configuration", new ShadowRuleConfiguration()),
Arguments.of("Data source configuration", createRuleConfiguration(
@@ -53,8 +56,9 @@ class ShadowRuleConfigurationTest {
Arguments.of("Complete configuration", createRuleConfiguration(
Collections.singleton(new ShadowDataSourceConfiguration("foo_ds", "foo_primary", "foo_shadow")),
Collections.singletonMap("foo_tbl", new ShadowTableConfiguration(
- Arrays.asList("foo_ds", "bar_ds"), Collections.singleton("foo_shadow_algorithm"))),
- Collections.singletonMap("foo_shadow_algorithm", new AlgorithmConfiguration("FIXTURE", new Properties())))));
+ Collections.singleton("foo_ds"), Collections.singleton("foo_shadow_algorithm"))),
+ Collections.singletonMap("foo_shadow_algorithm", new AlgorithmConfiguration("FIXTURE", new Properties())))),
+ Arguments.of("Default SQL hint algorithm", defaultAlgorithmRuleConfig));
}
private static ShadowRuleConfiguration createRuleConfiguration(final Collection<ShadowDataSourceConfiguration> dataSources,
@@ -75,6 +79,12 @@ class ShadowRuleConfigurationTest {
private static Stream<Arguments> invalidRuleConfigurationArguments() {
AlgorithmConfiguration algorithmConfig = new AlgorithmConfiguration("FIXTURE", new Properties());
+ ShadowRuleConfiguration missingDefaultAlgorithm = createRuleConfiguration(Collections.emptyList(), Collections.emptyMap(),
+ Collections.singletonMap("foo_shadow_algorithm", new AlgorithmConfiguration("SQL_HINT", new Properties())));
+ missingDefaultAlgorithm.setDefaultShadowAlgorithmName("bar_shadow_algorithm");
+ ShadowRuleConfiguration invalidDefaultAlgorithmType = createRuleConfiguration(
+ Collections.emptyList(), Collections.emptyMap(), Collections.singletonMap("foo_shadow_algorithm", algorithmConfig));
+ invalidDefaultAlgorithmType.setDefaultShadowAlgorithmName("foo_shadow_algorithm");
return Stream.of(
Arguments.of("Null data sources", createRuleConfiguration(null, Collections.emptyMap(), Collections.emptyMap())),
Arguments.of("Null data source", createRuleConfiguration(Collections.singleton(null), Collections.emptyMap(), Collections.emptyMap())),
@@ -108,7 +118,19 @@ class ShadowRuleConfigurationTest {
Arguments.of("Null shadow algorithm", createRuleConfiguration(
Collections.emptyList(), Collections.emptyMap(), Collections.singletonMap("foo_shadow_algorithm", null))),
Arguments.of("Missing shadow algorithm type", createRuleConfiguration(Collections.emptyList(), Collections.emptyMap(),
- Collections.singletonMap("foo_shadow_algorithm", new AlgorithmConfiguration("MISSING", new Properties())))));
+ Collections.singletonMap("foo_shadow_algorithm", new AlgorithmConfiguration("MISSING", new Properties())))),
+ Arguments.of("Unconfigured table data source", createRuleConfiguration(
+ Collections.singleton(new ShadowDataSourceConfiguration("foo_ds", "foo_primary", "foo_shadow")),
+ Collections.singletonMap("foo_tbl", new ShadowTableConfiguration(
+ Collections.singleton("bar_ds"), Collections.singleton("foo_shadow_algorithm"))),
+ Collections.singletonMap("foo_shadow_algorithm", algorithmConfig))),
+ Arguments.of("Unconfigured table shadow algorithm", createRuleConfiguration(
+ Collections.singleton(new ShadowDataSourceConfiguration("foo_ds", "foo_primary", "foo_shadow")),
+ Collections.singletonMap("foo_tbl", new ShadowTableConfiguration(
+ Collections.singleton("foo_ds"), Collections.singleton("bar_shadow_algorithm"))),
+ Collections.singletonMap("foo_shadow_algorithm", algorithmConfig))),
+ Arguments.of("Unconfigured default shadow algorithm", missingDefaultAlgorithm),
+ Arguments.of("Default shadow algorithm without SQL hint type", invalidDefaultAlgorithmType));
}
}
diff --git a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java b/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
index 6fd6cf66cdf..f590455a8bc 100644
--- a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
+++ b/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
@@ -19,10 +19,18 @@ package org.apache.shardingsphere.shadow.config.fixture;
import org.apache.shardingsphere.shadow.spi.ShadowAlgorithm;
+import java.util.Collection;
+import java.util.Collections;
+
public final class ShadowAlgorithmFixture implements ShadowAlgorithm {
@Override
public String getType() {
return "FIXTURE";
}
+
+ @Override
+ public Collection<Object> getTypeAliases() {
+ return Collections.singleton("SQL_HINT");
+ }
}
diff --git a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationChecker.java b/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationChecker.java
index d0b89f33a34..241feb2ae79 100644
--- a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationChecker.java
+++ b/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationChecker.java
@@ -17,26 +17,19 @@
package org.apache.shardingsphere.shadow.checker;
-import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
-import org.apache.shardingsphere.infra.algorithm.core.exception.MissingRequiredAlgorithmException;
import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
-import org.apache.shardingsphere.infra.exception.external.sql.identifier.SQLExceptionIdentifier;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.shadow.config.ShadowRuleConfiguration;
import org.apache.shardingsphere.shadow.config.datasource.ShadowDataSourceConfiguration;
-import org.apache.shardingsphere.shadow.config.table.ShadowTableConfiguration;
import org.apache.shardingsphere.shadow.constant.ShadowOrder;
import org.apache.shardingsphere.shadow.exception.metadata.MissingRequiredProductionDataSourceException;
import org.apache.shardingsphere.shadow.exception.metadata.MissingRequiredShadowDataSourceException;
-import org.apache.shardingsphere.shadow.exception.metadata.NotImplementHintShadowAlgorithmException;
-import org.apache.shardingsphere.shadow.exception.metadata.ShadowDataSourceMappingNotFoundException;
import javax.sql.DataSource;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.Map;
-import java.util.stream.Collectors;
/**
* Shadow rule configuration checker.
@@ -45,17 +38,7 @@ public final class ShadowRuleConfigurationChecker implements DatabaseRuleConfigu
@Override
public void check(final String databaseName, final ShadowRuleConfiguration ruleConfig, final Map<String, DataSource> dataSourceMap, final Collection<ShardingSphereRule> builtRules) {
- checkDefaultShadowAlgorithm(ruleConfig.getDefaultShadowAlgorithmName(), ruleConfig.getShadowAlgorithms());
checkDataSources(ruleConfig.getDataSources(), dataSourceMap, databaseName);
- checkShadowTableDataSourcesReferences(ruleConfig.getTables(), ruleConfig.getDataSources());
- checkShadowTableAlgorithmsReferences(ruleConfig.getTables(), ruleConfig.getShadowAlgorithms(), databaseName);
- }
-
- private void checkDefaultShadowAlgorithm(final String defaultShadowAlgorithmName, final Map<String, AlgorithmConfiguration> shadowAlgorithmConfigs) {
- if (null != defaultShadowAlgorithmName) {
- AlgorithmConfiguration algorithmConfig = shadowAlgorithmConfigs.get(defaultShadowAlgorithmName);
- ShardingSpherePreconditions.checkState(null != algorithmConfig && "SQL_HINT".equals(algorithmConfig.getType()), NotImplementHintShadowAlgorithmException::new);
- }
}
private void checkDataSources(final Collection<ShadowDataSourceConfiguration> shadowDataSources, final Map<String, DataSource> dataSourceMap, final String databaseName) {
@@ -65,22 +48,6 @@ public final class ShadowRuleConfigurationChecker implements DatabaseRuleConfigu
}
}
- private void checkShadowTableDataSourcesReferences(final Map<String, ShadowTableConfiguration> shadowTables, final Collection<ShadowDataSourceConfiguration> shadowDataSources) {
- Collection<String> dataSourceNames = shadowDataSources.stream().map(ShadowDataSourceConfiguration::getName).collect(Collectors.toSet());
- shadowTables.forEach((key, value) -> {
- for (String each : value.getDataSourceNames()) {
- ShardingSpherePreconditions.checkContains(dataSourceNames, each, () -> new ShadowDataSourceMappingNotFoundException(key));
- }
- });
- }
-
- private void checkShadowTableAlgorithmsReferences(final Map<String, ShadowTableConfiguration> shadowTables, final Map<String, AlgorithmConfiguration> shadowAlgorithms, final String databaseName) {
- for (ShadowTableConfiguration each : shadowTables.values()) {
- each.getShadowAlgorithmNames().forEach(shadowAlgorithmName -> ShardingSpherePreconditions.checkContainsKey(shadowAlgorithms, shadowAlgorithmName,
- () -> new MissingRequiredAlgorithmException("Shadow", new SQLExceptionIdentifier(databaseName))));
- }
- }
-
@Override
public Collection<String> getRequiredDataSourceNames(final ShadowRuleConfiguration ruleConfig) {
Collection<String> result = new LinkedHashSet<>();
diff --git a/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationCheckerTest.java b/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationCheckerTest.java
index 3208fa17be2..effb53e8209 100644
--- a/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationCheckerTest.java
+++ b/features/shadow/core/src/test/java/org/apache/shardingsphere/shadow/checker/ShadowRuleConfigurationCheckerTest.java
@@ -18,18 +18,13 @@
package org.apache.shardingsphere.shadow.checker;
import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
-import org.apache.shardingsphere.infra.algorithm.core.exception.MissingRequiredAlgorithmException;
import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
-import org.apache.shardingsphere.infra.util.props.PropertiesBuilder;
-import org.apache.shardingsphere.infra.util.props.PropertiesBuilder.Property;
import org.apache.shardingsphere.shadow.config.ShadowRuleConfiguration;
import org.apache.shardingsphere.shadow.config.datasource.ShadowDataSourceConfiguration;
import org.apache.shardingsphere.shadow.config.table.ShadowTableConfiguration;
import org.apache.shardingsphere.shadow.exception.metadata.MissingRequiredProductionDataSourceException;
import org.apache.shardingsphere.shadow.exception.metadata.MissingRequiredShadowDataSourceException;
-import org.apache.shardingsphere.shadow.exception.metadata.NotImplementHintShadowAlgorithmException;
-import org.apache.shardingsphere.shadow.exception.metadata.ShadowDataSourceMappingNotFoundException;
import org.apache.shardingsphere.test.infra.fixture.jdbc.MockedDataSource;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -57,67 +52,6 @@ class ShadowRuleConfigurationCheckerTest {
DatabaseRuleConfigurationChecker.class, Collections.singleton(ShadowRuleConfiguration.class)).get(ShadowRuleConfiguration.class);
}
- @Test
- void assertCheckWithNotExistedDefaultShadowAlgorithm() {
- assertThrows(NotImplementHintShadowAlgorithmException.class,
- () -> ruleConfigChecker.check("foo_db", createRuleConfigurationWithNotExistedDefaultShadowAlgorithm(), createDataSourceMap(), Collections.emptyList()));
- }
-
- private ShadowRuleConfiguration createRuleConfigurationWithNotExistedDefaultShadowAlgorithm() {
- ShadowRuleConfiguration result = new ShadowRuleConfiguration();
- result.setShadowAlgorithms(Collections.singletonMap("foo-algo", new AlgorithmConfiguration("SQL_HINT", new Properties())));
- result.setDefaultShadowAlgorithmName("bar-algo");
- result.setDataSources(Collections.singleton(new ShadowDataSourceConfiguration("foo_ds", "prod_ds", "shadow_ds")));
- result.setTables(Collections.singletonMap("foo_tbl", new ShadowTableConfiguration(Collections.singletonList("foo_ds"), Collections.singleton("foo-algo"))));
- return result;
- }
-
- @Test
- void assertCheckWithInvalidDefaultShadowAlgorithm() {
- assertThrows(NotImplementHintShadowAlgorithmException.class,
- () -> ruleConfigChecker.check("foo_db", createRuleConfigurationWithInvalidDefaultShadowAlgorithm(), createDataSourceMap(), Collections.emptyList()));
- }
-
- private ShadowRuleConfiguration createRuleConfigurationWithInvalidDefaultShadowAlgorithm() {
- ShadowRuleConfiguration result = new ShadowRuleConfiguration();
- result.setShadowAlgorithms(Collections.singletonMap("foo-algo", new AlgorithmConfiguration("REGEX_MATCH",
- PropertiesBuilder.build(new Property("column", "foo_id"), new Property("operation", "insert"), new Property("regex", "[1]")))));
- result.setDefaultShadowAlgorithmName("foo-algo");
- result.setDataSources(Collections.singleton(new ShadowDataSourceConfiguration("foo_ds", "prod_ds", "shadow_ds")));
- result.setTables(Collections.singletonMap("foo_tbl", new ShadowTableConfiguration(Collections.singletonList("foo_ds"), Collections.singleton("foo-algo"))));
- return result;
- }
-
- @Test
- void assertCheckWithInvalidShadowTableDataSourcesReferences() {
- assertThrows(ShadowDataSourceMappingNotFoundException.class,
- () -> ruleConfigChecker.check("foo_db", createRuleConfigurationWithInvalidShadowTableDataSourcesReferences(), createDataSourceMap(), Collections.emptyList()));
- }
-
- private ShadowRuleConfiguration createRuleConfigurationWithInvalidShadowTableDataSourcesReferences() {
- ShadowRuleConfiguration result = new ShadowRuleConfiguration();
- result.setShadowAlgorithms(Collections.singletonMap("foo-algo", new AlgorithmConfiguration("SQL_HINT", new Properties())));
- result.setDefaultShadowAlgorithmName("foo-algo");
- result.setDataSources(Collections.singleton(new ShadowDataSourceConfiguration("foo_ds", "prod_ds", "shadow_ds")));
- result.setTables(Collections.singletonMap("foo_tbl", new ShadowTableConfiguration(Collections.singletonList("bar_ds"), Collections.singleton("foo-algo"))));
- return result;
- }
-
- @Test
- void assertCheckWithInvalidShadowTableAlgorithmsReferences() {
- assertThrows(MissingRequiredAlgorithmException.class,
- () -> ruleConfigChecker.check("foo_db", createRuleConfigurationWithInvalidShadowTableAlgorithmsReferences(), createDataSourceMap(), Collections.emptyList()));
- }
-
- private ShadowRuleConfiguration createRuleConfigurationWithInvalidShadowTableAlgorithmsReferences() {
- ShadowRuleConfiguration result = new ShadowRuleConfiguration();
- result.setShadowAlgorithms(Collections.singletonMap("foo-algo", new AlgorithmConfiguration("SQL_HINT", new Properties())));
- result.setDefaultShadowAlgorithmName("foo-algo");
- result.setDataSources(Collections.singleton(new ShadowDataSourceConfiguration("foo_ds", "prod_ds", "shadow_ds")));
- result.setTables(Collections.singletonMap("foo_tbl", new ShadowTableConfiguration(Collections.singletonList("foo_ds"), Collections.singleton("bar-algo"))));
- return result;
- }
-
@Test
void assertCheckWithoutProductionDataSourceName() {
assertThrows(MissingRequiredProductionDataSourceException.class,
diff --git a/features/sharding/api/pom.xml b/features/sharding/api/pom.xml
index 6532a025cf8..ef383e634de 100644
--- a/features/sharding/api/pom.xml
+++ b/features/sharding/api/pom.xml
@@ -29,7 +29,7 @@
<dependencies>
<dependency>
<groupId>org.apache.shardingsphere</groupId>
- <artifactId>shardingsphere-infra-algorithm-core</artifactId>
+ <artifactId>shardingsphere-infra-algorithm-key-generator-spi</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
diff --git a/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/ShardingRuleConfiguration.java b/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/ShardingRuleConfiguration.java
index f18522d9e60..ae2e4617e38 100644
--- a/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/ShardingRuleConfiguration.java
+++ b/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/ShardingRuleConfiguration.java
@@ -25,12 +25,14 @@ import org.apache.shardingsphere.infra.config.keygen.KeyGenerateStrategiesConfig
import org.apache.shardingsphere.infra.config.rule.function.DistributedRuleConfiguration;
import org.apache.shardingsphere.infra.config.rule.scope.DatabaseRuleConfiguration;
import org.apache.shardingsphere.infra.config.rule.validator.constraint.spi.SPITypeExists;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
import org.apache.shardingsphere.sharding.api.config.rule.ShardingAutoTableRuleConfiguration;
import org.apache.shardingsphere.sharding.api.config.rule.ShardingTableReferenceRuleConfiguration;
import org.apache.shardingsphere.sharding.api.config.rule.ShardingTableRuleConfiguration;
import org.apache.shardingsphere.sharding.api.config.strategy.audit.ShardingAuditStrategyConfiguration;
import org.apache.shardingsphere.sharding.api.config.strategy.keygen.KeyGenerateStrategyConfiguration;
import org.apache.shardingsphere.sharding.api.config.strategy.sharding.ShardingStrategyConfiguration;
+import org.apache.shardingsphere.sharding.api.config.validator.ValidShardingRuleConfiguration;
import javax.validation.Valid;
import javax.validation.constraints.NotBlank;
@@ -46,6 +48,7 @@ import java.util.stream.Collectors;
*/
@Getter
@Setter
+@ValidShardingRuleConfiguration(groups = RuleConfigurationTypeValidationGroup.class)
public final class ShardingRuleConfiguration implements DatabaseRuleConfiguration, DistributedRuleConfiguration {
@NotNull
@@ -87,6 +90,7 @@ public final class ShardingRuleConfiguration implements DatabaseRuleConfiguratio
private Map<@NotBlank String, @NotNull AlgorithmConfiguration> keyGenerators = new LinkedHashMap<>();
@NotNull
+ @SPITypeExists(spiClassName = "org.apache.shardingsphere.sharding.spi.ShardingAuditAlgorithm")
private Map<@NotBlank String, @NotNull AlgorithmConfiguration> auditors = new LinkedHashMap<>();
@Override
diff --git a/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/validator/ShardingRuleConfigurationValidator.java b/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/validator/ShardingRuleConfigurationValidator.java
new file mode 100644
index 00000000000..fd32b06e1fd
--- /dev/null
+++ b/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/validator/ShardingRuleConfigurationValidator.java
@@ -0,0 +1,106 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.sharding.api.config.validator;
+
+import org.apache.shardingsphere.infra.config.keygen.KeyGenerateStrategiesConfiguration;
+import org.apache.shardingsphere.infra.config.keygen.impl.ColumnKeyGenerateStrategiesRuleConfiguration;
+import org.apache.shardingsphere.infra.config.keygen.impl.SequenceKeyGenerateStrategiesRuleConfiguration;
+import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
+import org.apache.shardingsphere.sharding.api.config.strategy.audit.ShardingAuditStrategyConfiguration;
+import org.apache.shardingsphere.sharding.api.config.strategy.keygen.KeyGenerateStrategyConfiguration;
+import org.apache.shardingsphere.sharding.api.config.strategy.sharding.NoneShardingStrategyConfiguration;
+import org.apache.shardingsphere.sharding.api.config.strategy.sharding.ShardingStrategyConfiguration;
+
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+
+/**
+ * Sharding rule configuration validator.
+ */
+public final class ShardingRuleConfigurationValidator implements ConstraintValidator<ValidShardingRuleConfiguration, ShardingRuleConfiguration> {
+
+ @Override
+ public boolean isValid(final ShardingRuleConfiguration value, final ConstraintValidatorContext context) {
+ return areTablesValid(value, context)
+ && areAutoTablesValid(value, context)
+ && isKeyGenerateStrategyValid(value.getDefaultKeyGenerateStrategy(), "defaultKeyGenerateStrategy", value, context)
+ && areKeyGenerateStrategiesValid(value, context)
+ && isAuditStrategyValid(value.getDefaultAuditStrategy(), "defaultAuditStrategy", value, context)
+ && isShardingStrategyValid(value.getDefaultDatabaseShardingStrategy(), "defaultDatabaseShardingStrategy", value, context)
+ && isShardingStrategyValid(value.getDefaultTableShardingStrategy(), "defaultTableShardingStrategy", value, context);
+ }
+
+ private boolean areTablesValid(final ShardingRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+ return ruleConfig.getTables().stream().noneMatch(each -> !isAuditStrategyValid(each.getAuditStrategy(), "tables", ruleConfig, context)
+ || !isShardingStrategyValid(each.getDatabaseShardingStrategy(), "tables", ruleConfig, context)
+ || !isShardingStrategyValid(each.getTableShardingStrategy(), "tables", ruleConfig, context));
+ }
+
+ private boolean areAutoTablesValid(final ShardingRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+ return ruleConfig.getAutoTables().stream().noneMatch(each -> !isAuditStrategyValid(each.getAuditStrategy(), "autoTables", ruleConfig, context)
+ || !isShardingStrategyValid(each.getShardingStrategy(), "autoTables", ruleConfig, context));
+ }
+
+ private boolean isKeyGenerateStrategyValid(final KeyGenerateStrategyConfiguration strategyConfig, final String propertyName,
+ final ShardingRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+ if (null == strategyConfig || ruleConfig.getKeyGenerators().containsKey(strategyConfig.getKeyGeneratorName())) {
+ return true;
+ }
+ return addViolation(propertyName, String.format("references unconfigured key generator `%s`", strategyConfig.getKeyGeneratorName()), context);
+ }
+
+ private boolean areKeyGenerateStrategiesValid(final ShardingRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+ return ruleConfig.getKeyGenerateStrategies().entrySet().stream().allMatch(entry -> isKeyGenerateStrategiesValid(entry.getKey(), entry.getValue(), ruleConfig, context));
+ }
+
+ private boolean isKeyGenerateStrategiesValid(final String strategyName, final KeyGenerateStrategiesConfiguration strategyConfig,
+ final ShardingRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+ if (!(strategyConfig instanceof ColumnKeyGenerateStrategiesRuleConfiguration) && !(strategyConfig instanceof SequenceKeyGenerateStrategiesRuleConfiguration)) {
+ return addViolation("keyGenerateStrategies", String.format("strategy `%s` must use column or sequence key generation", strategyName), context);
+ }
+ if (!ruleConfig.getKeyGenerators().containsKey(strategyConfig.getKeyGeneratorName())) {
+ return addViolation("keyGenerateStrategies", String.format("strategy `%s` references unconfigured key generator `%s`",
+ strategyName, strategyConfig.getKeyGeneratorName()), context);
+ }
+ return true;
+ }
+
+ private boolean isAuditStrategyValid(final ShardingAuditStrategyConfiguration strategyConfig, final String propertyName,
+ final ShardingRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+ if (null == strategyConfig) {
+ return true;
+ }
+ return strategyConfig.getAuditorNames().stream()
+ .filter(each -> !ruleConfig.getAuditors().containsKey(each)).findFirst()
+ .map(each -> addViolation(propertyName, String.format("references unconfigured auditor `%s`", each), context)).orElse(true);
+ }
+
+ private boolean isShardingStrategyValid(final ShardingStrategyConfiguration strategyConfig, final String propertyName,
+ final ShardingRuleConfiguration ruleConfig, final ConstraintValidatorContext context) {
+ if (null == strategyConfig || strategyConfig instanceof NoneShardingStrategyConfiguration || ruleConfig.getShardingAlgorithms().containsKey(strategyConfig.getShardingAlgorithmName())) {
+ return true;
+ }
+ return addViolation(propertyName, String.format("references unconfigured sharding algorithm `%s`", strategyConfig.getShardingAlgorithmName()), context);
+ }
+
+ private boolean addViolation(final String propertyName, final String message, final ConstraintValidatorContext context) {
+ context.disableDefaultConstraintViolation();
+ context.buildConstraintViolationWithTemplate(message).addPropertyNode(propertyName).addConstraintViolation();
+ return false;
+ }
+}
diff --git a/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/validator/ValidShardingRuleConfiguration.java b/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/validator/ValidShardingRuleConfiguration.java
new file mode 100644
index 00000000000..e35f5449211
--- /dev/null
+++ b/features/sharding/api/src/main/java/org/apache/shardingsphere/sharding/api/config/validator/ValidShardingRuleConfiguration.java
@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.sharding.api.config.validator;
+
+import javax.validation.Constraint;
+import javax.validation.Payload;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Valid sharding rule configuration constraint.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Constraint(validatedBy = ShardingRuleConfigurationValidator.class)
+@Documented
+public @interface ValidShardingRuleConfiguration {
+
+ /**
+ * Get message.
+ *
+ * @return message
+ */
+ String message() default "contains invalid references";
+
+ /**
+ * Get groups.
+ *
+ * @return groups
+ */
+ Class<?>[] groups() default {};
+
+ /**
+ * Get payload.
+ *
+ * @return payload
+ */
+ Class<? extends Payload>[] payload() default {};
+}
diff --git a/features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/ShardingRuleConfigurationTest.java b/features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/ShardingRuleConfigurationTest.java
index a7e0443dd8c..b763c52ea2d 100644
--- a/features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/ShardingRuleConfigurationTest.java
+++ b/features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/ShardingRuleConfigurationTest.java
@@ -74,6 +74,7 @@ class ShardingRuleConfigurationTest {
ShardingRuleConfiguration defaultShardingColumnRuleConfig = new ShardingRuleConfiguration();
defaultShardingColumnRuleConfig.setDefaultShardingColumn("user_id");
defaultShardingColumnRuleConfig.getTables().add(createTableRuleConfiguration(new StandardShardingStrategyConfiguration(null, "foo_standard")));
+ defaultShardingColumnRuleConfig.getShardingAlgorithms().put("foo_standard", new AlgorithmConfiguration("FIXTURE", new Properties()));
return Stream.of(
Arguments.of("Empty configuration", new ShardingRuleConfiguration()),
Arguments.of("Table with nullable optional values", tableRuleConfig),
@@ -100,8 +101,12 @@ class ShardingRuleConfigurationTest {
result.setDefaultShardingColumn("user_id");
result.getKeyGenerateStrategies().put("foo_column", new ColumnKeyGenerateStrategiesRuleConfiguration("foo_key_generator", "foo_tbl", "order_id"));
result.getKeyGenerateStrategies().put("foo_sequence", new SequenceKeyGenerateStrategiesRuleConfiguration("foo_key_generator", "foo_sequence"));
- result.getShardingAlgorithms().put("foo_sharding", new AlgorithmConfiguration("FIXTURE", new Properties()));
- result.getAuditors().put("foo_auditor", new AlgorithmConfiguration("INLINE", new Properties()));
+ AlgorithmConfiguration shardingAlgorithmConfig = new AlgorithmConfiguration("FIXTURE", new Properties());
+ result.getShardingAlgorithms().put("foo_standard", shardingAlgorithmConfig);
+ result.getShardingAlgorithms().put("foo_complex", shardingAlgorithmConfig);
+ result.getShardingAlgorithms().put("foo_hint", shardingAlgorithmConfig);
+ result.getKeyGenerators().put("foo_key_generator", new AlgorithmConfiguration("FIXTURE", new Properties()));
+ result.getAuditors().put("foo_auditor", new AlgorithmConfiguration("FIXTURE_AUDIT", new Properties()));
return result;
}
@@ -162,9 +167,13 @@ class ShardingRuleConfigurationTest {
"foo_sharding", new AlgorithmConfiguration("MISSING", new Properties()))),
Arguments.of("Null key generators", nullKeyGenerators),
Arguments.of("Null key generator", createKeyGeneratorsRuleConfiguration("foo_key_generator", null)),
+ Arguments.of("Missing key generator type", createKeyGeneratorsRuleConfiguration(
+ "foo_key_generator", new AlgorithmConfiguration("MISSING", new Properties()))),
Arguments.of("Null auditors", nullAuditors),
Arguments.of("Blank auditor name", createAuditorsRuleConfiguration("", algorithmConfig)),
Arguments.of("Null auditor", createAuditorsRuleConfiguration("foo_auditor", null)),
+ Arguments.of("Missing auditor type", createAuditorsRuleConfiguration(
+ "foo_auditor", new AlgorithmConfiguration("MISSING", new Properties()))),
Arguments.of("Blank table logic name", createRuleConfiguration(new ShardingTableRuleConfiguration("", null))),
Arguments.of("Invalid table sharding strategy", createRuleConfiguration(invalidTableStrategy)),
Arguments.of("Invalid table audit strategy", createRuleConfiguration(invalidTableAuditStrategy)),
@@ -206,6 +215,52 @@ class ShardingRuleConfigurationTest {
new SequenceKeyGenerateStrategiesRuleConfiguration("foo_key_generator", ""))));
}
+ @ParameterizedTest(name = "{0}")
+ @MethodSource("invalidReferenceRuleConfigurationArguments")
+ void assertValidateInvalidReferenceRuleConfiguration(final String name, final ShardingRuleConfiguration ruleConfig) {
+ assertThrows(InvalidRuleConfigurationException.class, () -> RuleConfigurationValidator.validate(ruleConfig));
+ }
+
+ private static Stream<Arguments> invalidReferenceRuleConfigurationArguments() {
+ ShardingRuleConfiguration unconfiguredTableDatabaseShardingAlgorithm = createValidRuleConfiguration();
+ unconfiguredTableDatabaseShardingAlgorithm.getTables().iterator().next()
+ .setDatabaseShardingStrategy(new StandardShardingStrategyConfiguration("user_id", "bar_standard"));
+ ShardingRuleConfiguration unconfiguredTableShardingAlgorithm = createValidRuleConfiguration();
+ unconfiguredTableShardingAlgorithm.getTables().iterator().next()
+ .setTableShardingStrategy(new ComplexShardingStrategyConfiguration("order_id,user_id", "bar_complex"));
+ ShardingRuleConfiguration unconfiguredAutoTableShardingAlgorithm = createValidRuleConfiguration();
+ unconfiguredAutoTableShardingAlgorithm.getAutoTables().iterator().next().setShardingStrategy(new HintShardingStrategyConfiguration("bar_hint"));
+ ShardingRuleConfiguration unconfiguredDefaultDatabaseShardingAlgorithm = createValidRuleConfiguration();
+ unconfiguredDefaultDatabaseShardingAlgorithm.setDefaultDatabaseShardingStrategy(new StandardShardingStrategyConfiguration("user_id", "bar_standard"));
+ ShardingRuleConfiguration unconfiguredDefaultTableShardingAlgorithm = createValidRuleConfiguration();
+ unconfiguredDefaultTableShardingAlgorithm.setDefaultTableShardingStrategy(new ComplexShardingStrategyConfiguration("order_id,user_id", "bar_complex"));
+ ShardingRuleConfiguration unconfiguredTableAuditor = createValidRuleConfiguration();
+ unconfiguredTableAuditor.getTables().iterator().next().setAuditStrategy(new ShardingAuditStrategyConfiguration(Collections.singleton("bar_auditor"), false));
+ ShardingRuleConfiguration unconfiguredAutoTableAuditor = createValidRuleConfiguration();
+ unconfiguredAutoTableAuditor.getAutoTables().iterator().next().setAuditStrategy(new ShardingAuditStrategyConfiguration(Collections.singleton("bar_auditor"), false));
+ ShardingRuleConfiguration unconfiguredDefaultAuditor = createValidRuleConfiguration();
+ unconfiguredDefaultAuditor.setDefaultAuditStrategy(new ShardingAuditStrategyConfiguration(Collections.singleton("bar_auditor"), false));
+ ShardingRuleConfiguration unconfiguredDefaultKeyGenerator = createValidRuleConfiguration();
+ unconfiguredDefaultKeyGenerator.setDefaultKeyGenerateStrategy(new KeyGenerateStrategyConfiguration("order_id", "bar_key_generator"));
+ ShardingRuleConfiguration unconfiguredKeyGenerateStrategiesKeyGenerator = createValidRuleConfiguration();
+ unconfiguredKeyGenerateStrategiesKeyGenerator.getKeyGenerateStrategies().put(
+ "bar_column", new ColumnKeyGenerateStrategiesRuleConfiguration("bar_key_generator", "foo_tbl", "order_id"));
+ ShardingRuleConfiguration unsupportedKeyGenerateStrategies = createValidRuleConfiguration();
+ unsupportedKeyGenerateStrategies.getKeyGenerateStrategies().put("bar_strategy", new UnsupportedKeyGenerateStrategiesConfiguration());
+ return Stream.of(
+ Arguments.of("Unconfigured table database sharding algorithm", unconfiguredTableDatabaseShardingAlgorithm),
+ Arguments.of("Unconfigured table sharding algorithm", unconfiguredTableShardingAlgorithm),
+ Arguments.of("Unconfigured auto table sharding algorithm", unconfiguredAutoTableShardingAlgorithm),
+ Arguments.of("Unconfigured default database sharding algorithm", unconfiguredDefaultDatabaseShardingAlgorithm),
+ Arguments.of("Unconfigured default table sharding algorithm", unconfiguredDefaultTableShardingAlgorithm),
+ Arguments.of("Unconfigured table auditor", unconfiguredTableAuditor),
+ Arguments.of("Unconfigured auto table auditor", unconfiguredAutoTableAuditor),
+ Arguments.of("Unconfigured default auditor", unconfiguredDefaultAuditor),
+ Arguments.of("Unconfigured default key generator", unconfiguredDefaultKeyGenerator),
+ Arguments.of("Unconfigured key generate strategies key generator", unconfiguredKeyGenerateStrategiesKeyGenerator),
+ Arguments.of("Unsupported key generate strategies type", unsupportedKeyGenerateStrategies));
+ }
+
private static ShardingAutoTableRuleConfiguration createValidAutoTableRuleConfiguration() {
return createAutoTableRuleConfiguration("foo_auto_tbl", new HintShardingStrategyConfiguration("foo_hint"));
}
@@ -282,4 +337,17 @@ class ShardingRuleConfigurationTest {
result.getBindingTableGroups().add(tableGroupConfig);
return result;
}
+
+ private static final class UnsupportedKeyGenerateStrategiesConfiguration implements KeyGenerateStrategiesConfiguration {
+
+ @Override
+ public String getKeyGenerateType() {
+ return "unsupported";
+ }
+
+ @Override
+ public String getKeyGeneratorName() {
+ return "foo_key_generator";
+ }
+ }
}
diff --git a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java b/features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/fixture/KeyGenerateAlgorithmFixture.java
similarity index 59%
copy from features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
copy to features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/fixture/KeyGenerateAlgorithmFixture.java
index 6fd6cf66cdf..1c628109da6 100644
--- a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
+++ b/features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/fixture/KeyGenerateAlgorithmFixture.java
@@ -15,11 +15,23 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.shadow.config.fixture;
+package org.apache.shardingsphere.sharding.api.config.fixture;
-import org.apache.shardingsphere.shadow.spi.ShadowAlgorithm;
+import org.apache.shardingsphere.infra.algorithm.core.context.AlgorithmSQLContext;
+import org.apache.shardingsphere.infra.algorithm.keygen.spi.KeyGenerateAlgorithm;
-public final class ShadowAlgorithmFixture implements ShadowAlgorithm {
+import java.util.Collection;
+import java.util.Collections;
+
+/**
+ * Key generate algorithm fixture.
+ */
+public final class KeyGenerateAlgorithmFixture implements KeyGenerateAlgorithm {
+
+ @Override
+ public Collection<? extends Comparable<?>> generateKeys(final AlgorithmSQLContext context, final int keyGenerateCount) {
+ return Collections.emptyList();
+ }
@Override
public String getType() {
diff --git a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java b/features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/fixture/ShardingAuditAlgorithmFixture.java
similarity index 53%
copy from features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
copy to features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/fixture/ShardingAuditAlgorithmFixture.java
index 6fd6cf66cdf..85ee9f2c327 100644
--- a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
+++ b/features/sharding/api/src/test/java/org/apache/shardingsphere/sharding/api/config/fixture/ShardingAuditAlgorithmFixture.java
@@ -15,14 +15,26 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.shadow.config.fixture;
+package org.apache.shardingsphere.sharding.api.config.fixture;
-import org.apache.shardingsphere.shadow.spi.ShadowAlgorithm;
+import org.apache.shardingsphere.infra.binder.context.statement.SQLStatementContext;
+import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
+import org.apache.shardingsphere.infra.metadata.database.rule.RuleMetaData;
+import org.apache.shardingsphere.sharding.spi.ShardingAuditAlgorithm;
-public final class ShadowAlgorithmFixture implements ShadowAlgorithm {
+import java.util.List;
+
+/**
+ * Sharding audit algorithm fixture.
+ */
+public final class ShardingAuditAlgorithmFixture implements ShardingAuditAlgorithm {
+
+ @Override
+ public void check(final SQLStatementContext sqlStatementContext, final List<Object> params, final RuleMetaData globalRuleMetaData, final ShardingSphereDatabase database) {
+ }
@Override
public String getType() {
- return "FIXTURE";
+ return "FIXTURE_AUDIT";
}
}
diff --git a/features/sharding/api/src/test/resources/META-INF/services/org.apache.shardingsphere.infra.algorithm.keygen.spi.KeyGenerateAlgorithm b/features/sharding/api/src/test/resources/META-INF/services/org.apache.shardingsphere.infra.algorithm.keygen.spi.KeyGenerateAlgorithm
new file mode 100644
index 00000000000..07c90ab314a
--- /dev/null
+++ b/features/sharding/api/src/test/resources/META-INF/services/org.apache.shardingsphere.infra.algorithm.keygen.spi.KeyGenerateAlgorithm
@@ -0,0 +1,18 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+org.apache.shardingsphere.sharding.api.config.fixture.KeyGenerateAlgorithmFixture
diff --git a/features/sharding/api/src/test/resources/META-INF/services/org.apache.shardingsphere.sharding.spi.ShardingAuditAlgorithm b/features/sharding/api/src/test/resources/META-INF/services/org.apache.shardingsphere.sharding.spi.ShardingAuditAlgorithm
new file mode 100644
index 00000000000..d41c55060ec
--- /dev/null
+++ b/features/sharding/api/src/test/resources/META-INF/services/org.apache.shardingsphere.sharding.spi.ShardingAuditAlgorithm
@@ -0,0 +1,18 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+org.apache.shardingsphere.sharding.api.config.fixture.ShardingAuditAlgorithmFixture
diff --git a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationChecker.java b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationChecker.java
index 552e122009a..bb53d75f9c6 100644
--- a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationChecker.java
+++ b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationChecker.java
@@ -17,27 +17,16 @@
package org.apache.shardingsphere.sharding.checker.config;
-import com.google.common.base.Joiner;
-import org.apache.shardingsphere.infra.algorithm.core.exception.UnregisteredAlgorithmException;
-import org.apache.shardingsphere.infra.config.keygen.KeyGenerateStrategiesConfiguration;
-import org.apache.shardingsphere.infra.config.keygen.impl.ColumnKeyGenerateStrategiesRuleConfiguration;
-import org.apache.shardingsphere.infra.config.keygen.impl.SequenceKeyGenerateStrategiesRuleConfiguration;
import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
import org.apache.shardingsphere.infra.datanode.DataNode;
import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
-import org.apache.shardingsphere.infra.exception.external.sql.identifier.SQLExceptionIdentifier;
import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.InvalidRuleConfigurationException;
import org.apache.shardingsphere.infra.expr.entry.InlineExpressionParserFactory;
import org.apache.shardingsphere.infra.rule.ShardingSphereRule;
import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
import org.apache.shardingsphere.sharding.api.config.rule.ShardingAutoTableRuleConfiguration;
import org.apache.shardingsphere.sharding.api.config.rule.ShardingTableRuleConfiguration;
-import org.apache.shardingsphere.sharding.api.config.strategy.audit.ShardingAuditStrategyConfiguration;
-import org.apache.shardingsphere.sharding.api.config.strategy.keygen.KeyGenerateStrategyConfiguration;
-import org.apache.shardingsphere.sharding.api.config.strategy.sharding.NoneShardingStrategyConfiguration;
-import org.apache.shardingsphere.sharding.api.config.strategy.sharding.ShardingStrategyConfiguration;
import org.apache.shardingsphere.sharding.constant.ShardingOrder;
-import org.apache.shardingsphere.sharding.exception.metadata.MissingRequiredShardingConfigurationException;
import javax.sql.DataSource;
import java.util.Collection;
@@ -55,62 +44,7 @@ public final class ShardingRuleConfigurationChecker implements DatabaseRuleConfi
@Override
public void check(final String databaseName, final ShardingRuleConfiguration ruleConfig, final Map<String, DataSource> dataSourceMap, final Collection<ShardingSphereRule> builtRules) {
- Collection<String> keyGenerators = ruleConfig.getKeyGenerators().keySet();
- Collection<String> auditors = ruleConfig.getAuditors().keySet();
- Collection<String> shardingAlgorithms = ruleConfig.getShardingAlgorithms().keySet();
- checkTables(databaseName, ruleConfig.getTables(), ruleConfig.getAutoTables(), auditors, shardingAlgorithms);
- checkKeyGenerateStrategy(databaseName, ruleConfig.getDefaultKeyGenerateStrategy(), keyGenerators);
- checkKeyGenerateStrategies(databaseName, ruleConfig.getKeyGenerateStrategies().values(), keyGenerators);
- checkAuditStrategy(databaseName, ruleConfig.getDefaultAuditStrategy(), auditors);
- checkShardingStrategy(databaseName, ruleConfig.getDefaultDatabaseShardingStrategy(), shardingAlgorithms);
- checkShardingStrategy(databaseName, ruleConfig.getDefaultTableShardingStrategy(), shardingAlgorithms);
- }
-
- private void checkTables(final String databaseName, final Collection<ShardingTableRuleConfiguration> tables,
- final Collection<ShardingAutoTableRuleConfiguration> autoTables, final Collection<String> auditors, final Collection<String> shardingAlgorithms) {
- for (ShardingTableRuleConfiguration each : tables) {
- checkAuditStrategy(databaseName, each.getAuditStrategy(), auditors);
- checkShardingStrategy(databaseName, each.getDatabaseShardingStrategy(), shardingAlgorithms);
- checkShardingStrategy(databaseName, each.getTableShardingStrategy(), shardingAlgorithms);
- checkDataNodeSchemas(each);
- }
- for (ShardingAutoTableRuleConfiguration each : autoTables) {
- checkAuditStrategy(databaseName, each.getAuditStrategy(), auditors);
- checkShardingStrategy(databaseName, each.getShardingStrategy(), shardingAlgorithms);
- }
- }
-
- private void checkKeyGenerateStrategy(final String databaseName, final KeyGenerateStrategyConfiguration keyGenerateStrategy, final Collection<String> keyGenerators) {
- if (null == keyGenerateStrategy) {
- return;
- }
- ShardingSpherePreconditions.checkContains(keyGenerators, keyGenerateStrategy.getKeyGeneratorName(),
- () -> new UnregisteredAlgorithmException("Key generate", keyGenerateStrategy.getKeyGeneratorName(), new SQLExceptionIdentifier(databaseName)));
- }
-
- private void checkAuditStrategy(final String databaseName, final ShardingAuditStrategyConfiguration auditStrategy, final Collection<String> auditors) {
- if (null == auditStrategy) {
- return;
- }
- ShardingSpherePreconditions.checkState(auditors.containsAll(auditStrategy.getAuditorNames()),
- () -> new UnregisteredAlgorithmException("Sharding audit", Joiner.on(",").join(auditStrategy.getAuditorNames()), new SQLExceptionIdentifier(databaseName)));
- }
-
- private void checkKeyGenerateStrategies(final String databaseName, final Collection<KeyGenerateStrategiesConfiguration> keyGenerateStrategies, final Collection<String> keyGenerators) {
- for (KeyGenerateStrategiesConfiguration each : keyGenerateStrategies) {
- ShardingSpherePreconditions.checkContains(keyGenerators, each.getKeyGeneratorName(),
- () -> new UnregisteredAlgorithmException("Key generate", each.getKeyGeneratorName(), new SQLExceptionIdentifier(databaseName)));
- ShardingSpherePreconditions.checkState(each instanceof ColumnKeyGenerateStrategiesRuleConfiguration || each instanceof SequenceKeyGenerateStrategiesRuleConfiguration,
- () -> new MissingRequiredShardingConfigurationException("Key generate type should be column or sequence", databaseName));
- }
- }
-
- private void checkShardingStrategy(final String databaseName, final ShardingStrategyConfiguration shardingStrategy, final Collection<String> shardingAlgorithms) {
- if (null == shardingStrategy || shardingStrategy instanceof NoneShardingStrategyConfiguration) {
- return;
- }
- ShardingSpherePreconditions.checkContains(shardingAlgorithms, shardingStrategy.getShardingAlgorithmName(),
- () -> new UnregisteredAlgorithmException("sharding", shardingStrategy.getShardingAlgorithmName(), new SQLExceptionIdentifier(databaseName)));
+ ruleConfig.getTables().forEach(this::checkDataNodeSchemas);
}
private void checkDataNodeSchemas(final ShardingTableRuleConfiguration tableRuleConfig) {
diff --git a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationCheckerTest.java b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationCheckerTest.java
index 9439d2ebc8a..5c01f007431 100644
--- a/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationCheckerTest.java
+++ b/features/sharding/core/src/test/java/org/apache/shardingsphere/sharding/checker/config/ShardingRuleConfigurationCheckerTest.java
@@ -17,23 +17,12 @@
package org.apache.shardingsphere.sharding.checker.config;
-import org.apache.shardingsphere.infra.algorithm.core.config.AlgorithmConfiguration;
-import org.apache.shardingsphere.infra.algorithm.core.exception.UnregisteredAlgorithmException;
-import org.apache.shardingsphere.infra.config.keygen.KeyGenerateStrategiesConfiguration;
-import org.apache.shardingsphere.infra.config.keygen.impl.ColumnKeyGenerateStrategiesRuleConfiguration;
-import org.apache.shardingsphere.infra.config.keygen.impl.SequenceKeyGenerateStrategiesRuleConfiguration;
import org.apache.shardingsphere.infra.config.rule.checker.DatabaseRuleConfigurationChecker;
import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.InvalidRuleConfigurationException;
import org.apache.shardingsphere.infra.spi.type.ordered.OrderedSPILoader;
-import org.apache.shardingsphere.infra.util.props.PropertiesBuilder;
-import org.apache.shardingsphere.infra.util.props.PropertiesBuilder.Property;
import org.apache.shardingsphere.sharding.api.config.ShardingRuleConfiguration;
import org.apache.shardingsphere.sharding.api.config.rule.ShardingAutoTableRuleConfiguration;
import org.apache.shardingsphere.sharding.api.config.rule.ShardingTableRuleConfiguration;
-import org.apache.shardingsphere.sharding.api.config.strategy.audit.ShardingAuditStrategyConfiguration;
-import org.apache.shardingsphere.sharding.api.config.strategy.sharding.NoneShardingStrategyConfiguration;
-import org.apache.shardingsphere.sharding.api.config.strategy.sharding.ShardingStrategyConfiguration;
-import org.apache.shardingsphere.sharding.api.config.strategy.sharding.StandardShardingStrategyConfiguration;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
@@ -44,7 +33,6 @@ import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
-import java.util.Properties;
import java.util.stream.Stream;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -62,18 +50,6 @@ class ShardingRuleConfigurationCheckerTest {
DatabaseRuleConfigurationChecker.class, Collections.singleton(ShardingRuleConfiguration.class)).get(ShardingRuleConfiguration.class);
}
- @Test
- void assertCheckSuccess() {
- ShardingRuleConfiguration ruleConfig = createRuleConfiguration();
- ShardingAuditStrategyConfiguration shardingAuditStrategyConfig = new ShardingAuditStrategyConfiguration(Collections.singleton("foo_audit"), false);
- ShardingStrategyConfiguration shardingStrategyConfig = createShardingStrategyConfiguration();
- ruleConfig.setTables(Collections.singleton(createShardingTableRuleConfiguration(shardingStrategyConfig, shardingAuditStrategyConfig)));
- ruleConfig.setAutoTables(Collections.singleton(createShardingAutoTableRuleConfiguration(shardingStrategyConfig, shardingAuditStrategyConfig)));
- ruleConfig.getKeyGenerateStrategies().put("foo_column_strategy", createColumnKeyGenerateStrategyRuleConfiguration("foo_keygen"));
- ruleConfig.getKeyGenerateStrategies().put("foo_sequence_strategy", createSequenceKeyGenerateStrategyRuleConfiguration("foo_keygen"));
- assertDoesNotThrow(() -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
- }
-
@Test
void assertCheckWithMultipleSchemasForSameDataSource() {
ShardingRuleConfiguration ruleConfig = createRuleConfiguration();
@@ -106,95 +82,23 @@ class ShardingRuleConfigurationCheckerTest {
new ShardingTableRuleConfiguration("bar_tbl", "ds_0.bar_schema.bar_tbl_0"))));
}
- @Test
- void assertCheckKeyGenerateStrategiesFailed() {
- ShardingRuleConfiguration ruleConfig = createRuleConfiguration();
- ruleConfig.getKeyGenerateStrategies().put("foo_sequence_strategy", createSequenceKeyGenerateStrategyRuleConfiguration("bar_keygen"));
- assertThrows(UnregisteredAlgorithmException.class, () -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
- }
-
- @Test
- void assertCheckKeyGenerateStrategiesWithUnregisteredKeyGeneratorFailed() {
- ShardingRuleConfiguration ruleConfig = createRuleConfiguration();
- ruleConfig.getKeyGenerateStrategies().put("bar_tbl_foo_col", new ColumnKeyGenerateStrategiesRuleConfiguration("bar_keygen", "bar_tbl", "foo_col"));
- assertThrows(UnregisteredAlgorithmException.class, () -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
- }
-
- @Test
- void assertCheckAuditStrategyFailed() {
- ShardingRuleConfiguration ruleConfig = createRuleConfiguration();
- ShardingStrategyConfiguration shardingStrategyConfig = createShardingStrategyConfiguration();
- ruleConfig.setTables(Collections.singleton(createShardingTableRuleConfiguration(shardingStrategyConfig, null)));
- ruleConfig.setAutoTables(Collections.singleton(createShardingAutoTableRuleConfiguration(shardingStrategyConfig,
- new ShardingAuditStrategyConfiguration(Collections.singleton("bar_audit"), false))));
- assertThrows(UnregisteredAlgorithmException.class, () -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
- }
-
- @Test
- void assertCheckShardingStrategyFailedWithUnregisteredAlgorithm() {
- ShardingRuleConfiguration ruleConfig = createRuleConfiguration();
- ShardingAuditStrategyConfiguration shardingAuditStrategyConfig = new ShardingAuditStrategyConfiguration(Collections.singleton("foo_audit"), false);
- ruleConfig.setTables(Collections.singleton(
- createShardingTableRuleConfiguration(new NoneShardingStrategyConfiguration(), shardingAuditStrategyConfig)));
- ruleConfig.setAutoTables(Collections.singleton(createShardingAutoTableRuleConfiguration(
- new StandardShardingStrategyConfiguration("foo_col", "bar_algorithm"), shardingAuditStrategyConfig)));
- assertThrows(UnregisteredAlgorithmException.class, () -> checker.check("foo_db", ruleConfig, Collections.emptyMap(), Collections.emptyList()));
- }
-
@Test
void assertGetRequiredDataSourceNames() {
ShardingRuleConfiguration ruleConfig = createRuleConfiguration();
- ShardingAuditStrategyConfiguration shardingAuditStrategyConfig = new ShardingAuditStrategyConfiguration(Collections.singleton("foo_audit"), false);
- ShardingStrategyConfiguration shardingStrategyConfig = createShardingStrategyConfiguration();
- ruleConfig.setTables(Collections.singleton(createShardingTableRuleConfiguration(shardingStrategyConfig, shardingAuditStrategyConfig)));
- ruleConfig.setAutoTables(Collections.singleton(createShardingAutoTableRuleConfiguration(shardingStrategyConfig, shardingAuditStrategyConfig)));
+ ruleConfig.setTables(Collections.singleton(new ShardingTableRuleConfiguration("foo_tbl", "ds_0.foo_tbl")));
+ ruleConfig.setAutoTables(Collections.singleton(new ShardingAutoTableRuleConfiguration("bar_tbl", "ds_1")));
assertThat(checker.getRequiredDataSourceNames(ruleConfig), is(new LinkedHashSet<>(Arrays.asList("ds_0", "ds_1"))));
}
@Test
void assertGetTableNames() {
ShardingRuleConfiguration ruleConfig = createRuleConfiguration();
- ShardingAuditStrategyConfiguration shardingAuditStrategyConfig = new ShardingAuditStrategyConfiguration(Collections.singleton("foo_audit"), false);
- ShardingStrategyConfiguration shardingStrategyConfig = createShardingStrategyConfiguration();
- ruleConfig.setTables(Collections.singleton(createShardingTableRuleConfiguration(shardingStrategyConfig, shardingAuditStrategyConfig)));
- ruleConfig.setAutoTables(Collections.singleton(createShardingAutoTableRuleConfiguration(shardingStrategyConfig, shardingAuditStrategyConfig)));
+ ruleConfig.setTables(Collections.singleton(new ShardingTableRuleConfiguration("foo_tbl", "ds_0.foo_tbl")));
+ ruleConfig.setAutoTables(Collections.singleton(new ShardingAutoTableRuleConfiguration("bar_tbl", "ds_1")));
assertThat(checker.getTableNames(ruleConfig), is(Arrays.asList("foo_tbl", "bar_tbl")));
}
private ShardingRuleConfiguration createRuleConfiguration() {
- ShardingRuleConfiguration result = new ShardingRuleConfiguration();
- result.getShardingAlgorithms().put("foo_algorithm", new AlgorithmConfiguration("MOD", PropertiesBuilder.build(new Property("sharding-count", "1"))));
- result.getAuditors().put("foo_audit", new AlgorithmConfiguration("foo", new Properties()));
- result.getKeyGenerators().put("foo_keygen", new AlgorithmConfiguration("UUID", new Properties()));
- return result;
- }
-
- private ShardingStrategyConfiguration createShardingStrategyConfiguration() {
- return new StandardShardingStrategyConfiguration("foo_col", "foo_algorithm");
- }
-
- private ShardingTableRuleConfiguration createShardingTableRuleConfiguration(final ShardingStrategyConfiguration shardingStrategyConfig,
- final ShardingAuditStrategyConfiguration shardingAuditStrategyConfig) {
- ShardingTableRuleConfiguration result = new ShardingTableRuleConfiguration("foo_tbl", "ds_0.foo_tbl");
- result.setDatabaseShardingStrategy(shardingStrategyConfig);
- result.setTableShardingStrategy(shardingStrategyConfig);
- result.setAuditStrategy(shardingAuditStrategyConfig);
- return result;
- }
-
- private ShardingAutoTableRuleConfiguration createShardingAutoTableRuleConfiguration(final ShardingStrategyConfiguration shardingStrategyConfig,
- final ShardingAuditStrategyConfiguration shardingAuditStrategyConfig) {
- ShardingAutoTableRuleConfiguration result = new ShardingAutoTableRuleConfiguration("bar_tbl", "ds_1");
- result.setShardingStrategy(shardingStrategyConfig);
- result.setAuditStrategy(shardingAuditStrategyConfig);
- return result;
- }
-
- private KeyGenerateStrategiesConfiguration createColumnKeyGenerateStrategyRuleConfiguration(final String keyGeneratorName) {
- return new ColumnKeyGenerateStrategiesRuleConfiguration(keyGeneratorName, "foo_tbl", "foo_col");
- }
-
- private KeyGenerateStrategiesConfiguration createSequenceKeyGenerateStrategyRuleConfiguration(final String keyGeneratorName) {
- return new SequenceKeyGenerateStrategiesRuleConfiguration(keyGeneratorName, "foo_sequence");
+ return new ShardingRuleConfiguration();
}
}
diff --git a/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/checker/DatabaseRuleConfigurationChecker.java b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/checker/DatabaseRuleConfigurationChecker.java
index a366f72ea71..9eb08406138 100644
--- a/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/checker/DatabaseRuleConfigurationChecker.java
+++ b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/checker/DatabaseRuleConfigurationChecker.java
@@ -43,7 +43,8 @@ public interface DatabaseRuleConfigurationChecker<T extends RuleConfiguration> e
* @param dataSourceMap data sources to be checked
* @param builtRules built rules
*/
- void check(String databaseName, T ruleConfig, Map<String, DataSource> dataSourceMap, Collection<ShardingSphereRule> builtRules);
+ default void check(final String databaseName, final T ruleConfig, final Map<String, DataSource> dataSourceMap, final Collection<ShardingSphereRule> builtRules) {
+ }
/**
* Get required data source names.
diff --git a/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/validator/RuleConfigurationValidator.java b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/validator/RuleConfigurationValidator.java
index 7f24c58538e..ff155356d68 100644
--- a/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/validator/RuleConfigurationValidator.java
+++ b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/validator/RuleConfigurationValidator.java
@@ -21,6 +21,7 @@ import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.apache.bval.jsr.ApacheValidationProvider;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
import org.apache.shardingsphere.infra.exception.ShardingSpherePreconditions;
import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.InvalidRuleConfigurationException;
import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.RuleConfigurationValidationException;
@@ -29,6 +30,7 @@ import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.ValidationException;
import javax.validation.Validator;
+import javax.validation.groups.Default;
import java.util.Collection;
import java.util.Set;
import java.util.stream.Collectors;
@@ -62,9 +64,14 @@ public final class RuleConfigurationValidator {
}
private static void validate(final Object config, final String ruleType) {
+ validate(config, ruleType, Default.class);
+ validate(config, ruleType, RuleConfigurationTypeValidationGroup.class);
+ }
+
+ private static void validate(final Object config, final String ruleType, final Class<?> group) {
Set<ConstraintViolation<Object>> violations;
try {
- violations = VALIDATOR.validate(config);
+ violations = VALIDATOR.validate(config, group);
} catch (final ValidationException ex) {
throw new RuleConfigurationValidationException(ruleType, ex);
}
diff --git a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/validator/group/RuleConfigurationTypeValidationGroup.java
similarity index 74%
copy from features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
copy to infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/validator/group/RuleConfigurationTypeValidationGroup.java
index 6fd6cf66cdf..089ec43445c 100644
--- a/features/shadow/api/src/test/java/org/apache/shardingsphere/shadow/config/fixture/ShadowAlgorithmFixture.java
+++ b/infra/common/src/main/java/org/apache/shardingsphere/infra/config/rule/validator/group/RuleConfigurationTypeValidationGroup.java
@@ -15,14 +15,10 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.shadow.config.fixture;
+package org.apache.shardingsphere.infra.config.rule.validator.group;
-import org.apache.shardingsphere.shadow.spi.ShadowAlgorithm;
-
-public final class ShadowAlgorithmFixture implements ShadowAlgorithm {
-
- @Override
- public String getType() {
- return "FIXTURE";
- }
+/**
+ * Rule configuration type validation group.
+ */
+public interface RuleConfigurationTypeValidationGroup {
}
diff --git a/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/checker/DatabaseRuleConfigurationCheckerTest.java b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/checker/DatabaseRuleConfigurationCheckerTest.java
new file mode 100644
index 00000000000..932651dc814
--- /dev/null
+++ b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/checker/DatabaseRuleConfigurationCheckerTest.java
@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.infra.config.rule.checker;
+
+import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
+import org.junit.jupiter.api.Test;
+
+import java.util.Collections;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+
+class DatabaseRuleConfigurationCheckerTest {
+
+ @Test
+ void assertCheck() {
+ DatabaseRuleConfigurationChecker<RuleConfiguration> checker = new DatabaseRuleConfigurationChecker<RuleConfiguration>() {
+
+ @Override
+ public int getOrder() {
+ return 0;
+ }
+
+ @Override
+ public Class<RuleConfiguration> getTypeClass() {
+ return RuleConfiguration.class;
+ }
+ };
+ assertDoesNotThrow(() -> checker.check("foo_db", new RuleConfiguration() {
+ }, Collections.emptyMap(), Collections.emptyList()));
+ }
+}
diff --git a/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/validator/RuleConfigurationValidatorTest.java b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/validator/RuleConfigurationValidatorTest.java
index c7cc95f5fdf..bbc15961262 100644
--- a/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/validator/RuleConfigurationValidatorTest.java
+++ b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/validator/RuleConfigurationValidatorTest.java
@@ -21,6 +21,8 @@ import lombok.Getter;
import lombok.RequiredArgsConstructor;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import org.apache.shardingsphere.infra.config.rule.validator.constraint.spi.SPITypeExists;
+import org.apache.shardingsphere.infra.config.rule.validator.fixture.ValidRuleConfigurationTypeFixture;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
import org.apache.shardingsphere.infra.exception.external.sql.sqlstate.XOpenSQLState;
import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.InvalidRuleConfigurationException;
import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.RuleConfigurationValidationException;
@@ -37,6 +39,7 @@ import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.isA;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
class RuleConfigurationValidatorTest {
@@ -81,6 +84,21 @@ class RuleConfigurationValidatorTest {
assertThat(actualSQLException.getErrorCode(), is(10205));
}
+ @Test
+ void assertValidateDefaultGroupBeforeTypeGroup() {
+ InvalidRuleConfigurationException actual = assertThrows(InvalidRuleConfigurationException.class,
+ () -> RuleConfigurationValidator.validate(new TypeValidationFixtureRuleConfiguration("")));
+ assertThat(actual.getMessage(), containsString("Property `name`"));
+ assertFalse(actual.getMessage().contains("contains invalid type configuration"));
+ }
+
+ @Test
+ void assertValidateTypeGroup() {
+ InvalidRuleConfigurationException actual = assertThrows(InvalidRuleConfigurationException.class,
+ () -> RuleConfigurationValidator.validate(new TypeValidationFixtureRuleConfiguration("fixture")));
+ assertThat(actual.getMessage(), containsString("contains invalid type configuration"));
+ }
+
@Getter
private static final class FixtureRuleConfiguration implements RuleConfiguration {
@@ -106,4 +124,13 @@ class RuleConfigurationValidatorTest {
@SPITypeExists(spiClassName = "org.apache.shardingsphere.infra.config.rule.validator.constraint.spi.fixture.MissingSPITypeFixture")
private final String type = "FIXTURE";
}
+
+ @RequiredArgsConstructor
+ @Getter
+ @ValidRuleConfigurationTypeFixture(groups = RuleConfigurationTypeValidationGroup.class)
+ private static final class TypeValidationFixtureRuleConfiguration implements RuleConfiguration {
+
+ @NotBlank
+ private final String name;
+ }
}
diff --git a/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/validator/fixture/ValidRuleConfigurationTypeFixture.java b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/validator/fixture/ValidRuleConfigurationTypeFixture.java
new file mode 100644
index 00000000000..5e21b855a93
--- /dev/null
+++ b/infra/common/src/test/java/org/apache/shardingsphere/infra/config/rule/validator/fixture/ValidRuleConfigurationTypeFixture.java
@@ -0,0 +1,70 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.shardingsphere.infra.config.rule.validator.fixture;
+
+import javax.validation.Constraint;
+import javax.validation.ConstraintValidator;
+import javax.validation.ConstraintValidatorContext;
+import javax.validation.Payload;
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Valid rule configuration type fixture constraint.
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Constraint(validatedBy = ValidRuleConfigurationTypeFixture.Validator.class)
+@Documented
+public @interface ValidRuleConfigurationTypeFixture {
+
+ /**
+ * Get message.
+ *
+ * @return message
+ */
+ String message() default "contains invalid type configuration";
+
+ /**
+ * Get groups.
+ *
+ * @return groups
+ */
+ Class<?>[] groups() default {};
+
+ /**
+ * Get payload.
+ *
+ * @return payload
+ */
+ Class<? extends Payload>[] payload() default {};
+
+ /**
+ * Valid rule configuration type fixture validator.
+ */
+ final class Validator implements ConstraintValidator<ValidRuleConfigurationTypeFixture, Object> {
+
+ @Override
+ public boolean isValid(final Object value, final ConstraintValidatorContext context) {
+ return false;
+ }
+ }
+}
diff --git a/kernel/time-service/api/src/main/java/org/apache/shardingsphere/timeservice/config/TimestampServiceRuleConfiguration.java b/kernel/time-service/api/src/main/java/org/apache/shardingsphere/timeservice/config/TimestampServiceRuleConfiguration.java
index 868826f8612..23bf95e0dc3 100644
--- a/kernel/time-service/api/src/main/java/org/apache/shardingsphere/timeservice/config/TimestampServiceRuleConfiguration.java
+++ b/kernel/time-service/api/src/main/java/org/apache/shardingsphere/timeservice/config/TimestampServiceRuleConfiguration.java
@@ -20,6 +20,7 @@ package org.apache.shardingsphere.timeservice.config;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import org.apache.shardingsphere.infra.config.rule.scope.GlobalRuleConfiguration;
+import org.apache.shardingsphere.infra.config.rule.validator.constraint.spi.SPITypeExists;
import javax.validation.constraints.NotBlank;
import java.util.Properties;
@@ -32,6 +33,7 @@ import java.util.Properties;
public final class TimestampServiceRuleConfiguration implements GlobalRuleConfiguration {
@NotBlank
+ @SPITypeExists(spiClassName = "org.apache.shardingsphere.timeservice.spi.TimestampService")
private final String type;
private final Properties props;
diff --git a/kernel/time-service/api/src/test/java/org/apache/shardingsphere/timeservice/config/TimestampServiceRuleConfigurationTest.java b/kernel/time-service/api/src/test/java/org/apache/shardingsphere/timeservice/config/TimestampServiceRuleConfigurationTest.java
index a40c6f261c2..db59b11b743 100644
--- a/kernel/time-service/api/src/test/java/org/apache/shardingsphere/timeservice/config/TimestampServiceRuleConfigurationTest.java
+++ b/kernel/time-service/api/src/test/java/org/apache/shardingsphere/timeservice/config/TimestampServiceRuleConfigurationTest.java
@@ -39,8 +39,8 @@ class TimestampServiceRuleConfigurationTest {
private static Stream<Arguments> validRuleConfigurationArguments() {
return Stream.of(
- Arguments.of("Null properties", new TimestampServiceRuleConfiguration("System", null)),
- Arguments.of("Empty properties", new TimestampServiceRuleConfiguration("System", new Properties())));
+ Arguments.of("Null properties", new TimestampServiceRuleConfiguration("FIXTURE", null)),
+ Arguments.of("Empty properties", new TimestampServiceRuleConfiguration("FIXTURE", new Properties())));
}
@ParameterizedTest(name = "{0}")
@@ -53,6 +53,7 @@ class TimestampServiceRuleConfigurationTest {
return Stream.of(
Arguments.of("Null type", new TimestampServiceRuleConfiguration(null, null)),
Arguments.of("Empty type", new TimestampServiceRuleConfiguration("", null)),
- Arguments.of("Blank type", new TimestampServiceRuleConfiguration(" ", null)));
+ Arguments.of("Blank type", new TimestampServiceRuleConfiguration(" ", null)),
+ Arguments.of("Missing type", new TimestampServiceRuleConfiguration("MISSING", null)));
}
}
diff --git a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/exception/metadata/ShadowDataSourceMappingNotFoundException.java b/kernel/time-service/api/src/test/java/org/apache/shardingsphere/timeservice/config/fixture/TimestampServiceFixture.java
similarity index 56%
rename from features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/exception/metadata/ShadowDataSourceMappingNotFoundException.java
rename to kernel/time-service/api/src/test/java/org/apache/shardingsphere/timeservice/config/fixture/TimestampServiceFixture.java
index 31a73f9f9dd..8190c2a8f6a 100644
--- a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/exception/metadata/ShadowDataSourceMappingNotFoundException.java
+++ b/kernel/time-service/api/src/test/java/org/apache/shardingsphere/timeservice/config/fixture/TimestampServiceFixture.java
@@ -15,19 +15,24 @@
* limitations under the License.
*/
-package org.apache.shardingsphere.shadow.exception.metadata;
+package org.apache.shardingsphere.timeservice.config.fixture;
-import org.apache.shardingsphere.infra.exception.external.sql.sqlstate.XOpenSQLState;
-import org.apache.shardingsphere.shadow.exception.ShadowSQLException;
+import org.apache.shardingsphere.timeservice.spi.TimestampService;
+
+import java.sql.Timestamp;
/**
- * Shadow data source mapping not found exception.
+ * Timestamp service fixture.
*/
-public final class ShadowDataSourceMappingNotFoundException extends ShadowSQLException {
+public final class TimestampServiceFixture implements TimestampService {
- private static final long serialVersionUID = 4141501883104032467L;
+ @Override
+ public Timestamp getTimestamp() {
+ return new Timestamp(0L);
+ }
- public ShadowDataSourceMappingNotFoundException(final String tableName) {
- super(XOpenSQLState.NOT_FOUND, 2, "No available shadow data sources mappings in shadow table '%s'.", tableName);
+ @Override
+ public String getType() {
+ return "FIXTURE";
}
}
diff --git a/kernel/time-service/api/src/test/resources/META-INF/services/org.apache.shardingsphere.timeservice.spi.TimestampService b/kernel/time-service/api/src/test/resources/META-INF/services/org.apache.shardingsphere.timeservice.spi.TimestampService
new file mode 100644
index 00000000000..30e25fe2dc6
--- /dev/null
+++ b/kernel/time-service/api/src/test/resources/META-INF/services/org.apache.shardingsphere.timeservice.spi.TimestampService
@@ -0,0 +1,18 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+org.apache.shardingsphere.timeservice.config.fixture.TimestampServiceFixture
diff --git a/kernel/transaction/api/src/main/java/org/apache/shardingsphere/transaction/config/TransactionRuleConfiguration.java b/kernel/transaction/api/src/main/java/org/apache/shardingsphere/transaction/config/TransactionRuleConfiguration.java
index 5392e36289d..c88a97f2396 100644
--- a/kernel/transaction/api/src/main/java/org/apache/shardingsphere/transaction/config/TransactionRuleConfiguration.java
+++ b/kernel/transaction/api/src/main/java/org/apache/shardingsphere/transaction/config/TransactionRuleConfiguration.java
@@ -21,6 +21,7 @@ import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import org.apache.shardingsphere.infra.config.rule.scope.GlobalRuleConfiguration;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
import org.apache.shardingsphere.transaction.config.validator.ValidTransactionProviderType;
import javax.validation.constraints.NotBlank;
@@ -30,7 +31,7 @@ import java.util.Properties;
/**
* Transaction rule configuration.
*/
-@ValidTransactionProviderType
+@ValidTransactionProviderType(groups = RuleConfigurationTypeValidationGroup.class)
@RequiredArgsConstructor
@Getter
@EqualsAndHashCode
diff --git a/kernel/transaction/api/src/main/java/org/apache/shardingsphere/transaction/config/validator/TransactionProviderTypeValidator.java b/kernel/transaction/api/src/main/java/org/apache/shardingsphere/transaction/config/validator/TransactionProviderTypeValidator.java
index 1accb35fd9a..62b6abd1be3 100644
--- a/kernel/transaction/api/src/main/java/org/apache/shardingsphere/transaction/config/validator/TransactionProviderTypeValidator.java
+++ b/kernel/transaction/api/src/main/java/org/apache/shardingsphere/transaction/config/validator/TransactionProviderTypeValidator.java
@@ -32,7 +32,7 @@ public final class TransactionProviderTypeValidator implements ConstraintValidat
@Override
public boolean isValid(final TransactionRuleConfiguration value, final ConstraintValidatorContext context) {
- if (null == value || !TransactionType.XA.name().equalsIgnoreCase(value.getDefaultType())) {
+ if (!TransactionType.XA.name().equalsIgnoreCase(value.getDefaultType())) {
return true;
}
if (containsProviderType(value.getProviderType())) {
diff --git a/kernel/transaction/type/xa/core/src/test/java/org/apache/shardingsphere/transaction/config/TransactionRuleConfigurationTest.java b/kernel/transaction/type/xa/core/src/test/java/org/apache/shardingsphere/transaction/config/TransactionRuleConfigurationTest.java
index 73500078aef..98f41d2f550 100644
--- a/kernel/transaction/type/xa/core/src/test/java/org/apache/shardingsphere/transaction/config/TransactionRuleConfigurationTest.java
+++ b/kernel/transaction/type/xa/core/src/test/java/org/apache/shardingsphere/transaction/config/TransactionRuleConfigurationTest.java
@@ -19,6 +19,7 @@ package org.apache.shardingsphere.transaction.config;
import org.apache.bval.jsr.ApacheValidationProvider;
import org.apache.shardingsphere.infra.config.rule.validator.RuleConfigurationValidator;
+import org.apache.shardingsphere.infra.config.rule.validator.group.RuleConfigurationTypeValidationGroup;
import org.apache.shardingsphere.infra.exception.kernel.metadata.rule.InvalidRuleConfigurationException;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
@@ -65,7 +66,8 @@ class TransactionRuleConfigurationTest {
@Test
void assertInvalidProviderTypePropertyPath() {
- Collection<ConstraintViolation<TransactionRuleConfiguration>> actual = VALIDATOR.validate(new TransactionRuleConfiguration("XA", "MISSING", null));
+ Collection<ConstraintViolation<TransactionRuleConfiguration>> actual = VALIDATOR.validate(
+ new TransactionRuleConfiguration("XA", "MISSING", null), RuleConfigurationTypeValidationGroup.class);
assertThat(actual.iterator().next().getPropertyPath().toString(), is("providerType"));
}
}
diff --git a/mcp/bootstrap/src/main/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/validator/MCPLaunchConfigurationValidator.java b/mcp/bootstrap/src/main/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/validator/MCPLaunchConfigurationValidator.java
index 73c88a04a1d..7507140c8c9 100644
--- a/mcp/bootstrap/src/main/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/validator/MCPLaunchConfigurationValidator.java
+++ b/mcp/bootstrap/src/main/java/org/apache/shardingsphere/mcp/bootstrap/config/yaml/validator/MCPLaunchConfigurationValidator.java
@@ -31,10 +31,7 @@ public final class MCPLaunchConfigurationValidator implements ConstraintValidato
@Override
public boolean isValid(final YamlMCPLaunchConfiguration value, final ConstraintValidatorContext context) {
- if (null == value || null == value.getTransport()) {
- return true;
- }
- return isValid(value.getTransport(), context);
+ return null == value || null == value.getTransport() || isValid(value.getTransport(), context);
}
private boolean isValid(final YamlMCPTransportConfiguration value, final ConstraintValidatorContext context) {
diff --git a/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/descriptor/yaml/validator/UniqueMCPPromptArgumentNamesValidator.java b/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/descriptor/yaml/validator/UniqueMCPPromptArgumentNamesValidator.java
index 4217242e5aa..b53bc93a28f 100644
--- a/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/descriptor/yaml/validator/UniqueMCPPromptArgumentNamesValidator.java
+++ b/mcp/support/src/main/java/org/apache/shardingsphere/mcp/support/descriptor/yaml/validator/UniqueMCPPromptArgumentNamesValidator.java
@@ -36,12 +36,7 @@ public final class UniqueMCPPromptArgumentNamesValidator implements ConstraintVa
return true;
}
Set<String> names = new HashSet<>(value.size(), 1F);
- for (Object each : value) {
- YamlMCPPromptArgumentDescriptor argument = (YamlMCPPromptArgumentDescriptor) each;
- if (null != argument && null != argument.getName() && !argument.getName().isBlank() && !names.add(argument.getName())) {
- return false;
- }
- }
- return true;
+ return value.stream().map(each -> (YamlMCPPromptArgumentDescriptor) each)
+ .noneMatch(argument -> null != argument && null != argument.getName() && !argument.getName().isBlank() && !names.add(argument.getName()));
}
}