Skip to content

Commit

Permalink
Revise #23086, optimize some parameters and method naming. (#23096)
Browse files Browse the repository at this point in the history 
* Revise #23086, optimize some parameters and method naming.

* Change getIdentical to getDuplicated.

* Change require to required

* Change resources to dataSources

* Change resources to dataSources
  • Loading branch information
@RaigorJiang
RaigorJiang authored Dec 26, 2022
1 parent aa39210 commit 01f4968
Show file tree
Hide file tree
Showing 13 changed files with 155 additions and 225 deletions.
50 changes: 25 additions & 25 deletions ...re/readwritesplitting/distsql/handler/checker/ReadwriteSplittingRuleStatementChecker.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -59,8 +59,8 @@ public final class ReadwriteSplittingRuleStatementChecker {
public static void checkCreation(final ShardingSphereDatabase database, final Collection<ReadwriteSplittingRuleSegment> segments, final ReadwriteSplittingRuleConfiguration currentRuleConfig) {
String databaseName = database.getName();
checkDuplicateRuleNames(databaseName, segments, currentRuleConfig, database.getResourceMetaData());
checkResourcesExist(databaseName, segments, database);
checkDuplicateResourceNames(databaseName, segments, currentRuleConfig, true);
checkDataSourcesExist(databaseName, segments, database);
checkDuplicatedDataSourceNames(databaseName, segments, currentRuleConfig, true);
checkLoadBalancers(segments);
}

Expand All @@ -76,8 +76,8 @@ public static void checkAlteration(final ShardingSphereDatabase database, final
checkRuleConfigurationExist(database, currentRuleConfig);
checkDuplicateRuleNamesWithSelf(databaseName, segments);
checkRuleNamesExist(segments, currentRuleConfig, databaseName);
checkResourcesExist(databaseName, segments, database);
checkDuplicateResourceNames(databaseName, segments, currentRuleConfig, false);
checkDataSourcesExist(databaseName, segments, database);
checkDuplicatedDataSourceNames(databaseName, segments, currentRuleConfig, false);
checkLoadBalancers(segments);
}

Expand Down Expand Up @@ -136,39 +136,39 @@ private static void checkDuplicateRuleNamesWithRuleConfiguration(final String da
ShardingSpherePreconditions.checkState(duplicateRuleNames.isEmpty(), () -> new DuplicateRuleException("Readwrite splitting", databaseName, duplicateRuleNames));
}

private static void checkResourcesExist(final String databaseName, final Collection<ReadwriteSplittingRuleSegment> segments, final ShardingSphereDatabase database) {
Collection<String> requireResources = new LinkedHashSet<>();
Collection<String> requireDiscoverableResources = new LinkedHashSet<>();
private static void checkDataSourcesExist(final String databaseName, final Collection<ReadwriteSplittingRuleSegment> segments, final ShardingSphereDatabase database) {
Collection<String> requiredDataSources = new LinkedHashSet<>();
Collection<String> requiredLogicalDataSources = new LinkedHashSet<>();
segments.forEach(each -> {
if (Strings.isNullOrEmpty(each.getAutoAwareResource())) {
requireResources.add(each.getWriteDataSource());
requireResources.addAll(each.getReadDataSources());
requiredDataSources.add(each.getWriteDataSource());
requiredDataSources.addAll(each.getReadDataSources());
} else {
requireDiscoverableResources.add(each.getAutoAwareResource());
requiredLogicalDataSources.add(each.getAutoAwareResource());
}
});
Collection<String> notExistResources = database.getResourceMetaData().getNotExistedResources(requireResources);
ShardingSpherePreconditions.checkState(notExistResources.isEmpty(), () -> new MissingRequiredResourcesException(databaseName, notExistResources));
Collection<String> logicResources = getLogicResources(database);
Collection<String> notExistLogicResources = requireDiscoverableResources.stream().filter(each -> !logicResources.contains(each)).collect(Collectors.toSet());
ShardingSpherePreconditions.checkState(notExistLogicResources.isEmpty(), () -> new MissingRequiredResourcesException(databaseName, notExistLogicResources));
Collection<String> notExistedDataSources = database.getResourceMetaData().getNotExistedResources(requiredDataSources);
ShardingSpherePreconditions.checkState(notExistedDataSources.isEmpty(), () -> new MissingRequiredResourcesException(databaseName, notExistedDataSources));
Collection<String> logicalDataSources = getLogicDataSources(database);
Collection<String> notExistedLogicalDataSources = requiredLogicalDataSources.stream().filter(each -> !logicalDataSources.contains(each)).collect(Collectors.toSet());
ShardingSpherePreconditions.checkState(notExistedLogicalDataSources.isEmpty(), () -> new MissingRequiredResourcesException(databaseName, notExistedLogicalDataSources));
}

@SuppressWarnings("unchecked")
private static Collection<String> getLogicResources(final ShardingSphereDatabase database) {
private static Collection<String> getLogicDataSources(final ShardingSphereDatabase database) {
Collection<String> result = new LinkedHashSet<>();
Optional<ExportableRule> exportableRule = database.getRuleMetaData().findRules(ExportableRule.class).stream()
.filter(each -> new RuleExportEngine(each).containExportableKey(Collections.singletonList(ExportableConstants.EXPORT_DB_DISCOVERY_PRIMARY_DATA_SOURCES))).findAny();
exportableRule.ifPresent(optional -> {
Map<String, Object> exportData = new RuleExportEngine(optional).export(Collections.singletonList(ExportableConstants.EXPORT_DB_DISCOVERY_PRIMARY_DATA_SOURCES));
Collection<String> logicResources = ((Map<String, String>) exportData.getOrDefault(ExportableConstants.EXPORT_DB_DISCOVERY_PRIMARY_DATA_SOURCES, Collections.emptyMap())).keySet();
result.addAll(logicResources);
Collection<String> logicalDataSources = ((Map<String, String>) exportData.getOrDefault(ExportableConstants.EXPORT_DB_DISCOVERY_PRIMARY_DATA_SOURCES, Collections.emptyMap())).keySet();
result.addAll(logicalDataSources);
});
return result;
}

private static void checkDuplicateResourceNames(final String databaseName, final Collection<ReadwriteSplittingRuleSegment> segments,
final ReadwriteSplittingRuleConfiguration currentRuleConfig, final boolean isCreating) {
private static void checkDuplicatedDataSourceNames(final String databaseName, final Collection<ReadwriteSplittingRuleSegment> segments,
final ReadwriteSplittingRuleConfiguration currentRuleConfig, final boolean isCreating) {
Collection<String> existedWriteDataSourceNames = new HashSet<>();
Collection<String> existedReadDataSourceNames = new HashSet<>();
if (null != currentRuleConfig) {
Expand All @@ -180,15 +180,15 @@ private static void checkDuplicateResourceNames(final String databaseName, final
}
}
}
checkDuplicateWriteResourceNames(databaseName, segments, existedWriteDataSourceNames);
checkDuplicateReadResourceNames(databaseName, segments, existedReadDataSourceNames);
checkDuplicateWriteDataSourceNames(databaseName, segments, existedWriteDataSourceNames);
checkDuplicateReadDataSourceNames(databaseName, segments, existedReadDataSourceNames);
}

private static Collection<String> getToBeAlteredRuleNames(final Collection<ReadwriteSplittingRuleSegment> segments) {
return segments.stream().map(ReadwriteSplittingRuleSegment::getName).collect(Collectors.toSet());
}

private static void checkDuplicateWriteResourceNames(final String databaseName, final Collection<ReadwriteSplittingRuleSegment> segments, final Collection<String> writeDataSourceNames) {
private static void checkDuplicateWriteDataSourceNames(final String databaseName, final Collection<ReadwriteSplittingRuleSegment> segments, final Collection<String> writeDataSourceNames) {
for (final ReadwriteSplittingRuleSegment each : segments) {
if (!Strings.isNullOrEmpty(each.getWriteDataSource())) {
String writeDataSource = each.getWriteDataSource();
Expand All @@ -198,8 +198,8 @@ private static void checkDuplicateWriteResourceNames(final String databaseName,
}
}

private static void checkDuplicateReadResourceNames(final String databaseName, final Collection<ReadwriteSplittingRuleSegment> segments,
final Collection<String> readDataSourceNames) {
private static void checkDuplicateReadDataSourceNames(final String databaseName, final Collection<ReadwriteSplittingRuleSegment> segments,
final Collection<String> readDataSourceNames) {
for (ReadwriteSplittingRuleSegment each : segments) {
if (null != each.getReadDataSources()) {
for (String readDataSource : each.getReadDataSources()) {
Expand Down
100 changes: 36 additions & 64 deletions .../org/apache/shardingsphere/shadow/distsql/handler/checker/ShadowRuleStatementChecker.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,13 +17,13 @@

package org.apache.shardingsphere.shadow.distsql.handler.checker;

import org.apache.shardingsphere.infra.config.rule.scope.DatabaseRuleConfiguration;
import org.apache.shardingsphere.distsql.handler.exception.DistSQLException;
import org.apache.shardingsphere.distsql.handler.exception.resource.MissingRequiredResourcesException;
import org.apache.shardingsphere.distsql.handler.exception.algorithm.InvalidAlgorithmConfigurationException;
import org.apache.shardingsphere.distsql.handler.exception.resource.MissingRequiredResourcesException;
import org.apache.shardingsphere.distsql.handler.exception.rule.MissingRequiredRuleException;
import org.apache.shardingsphere.infra.metadata.database.ShardingSphereDatabase;
import org.apache.shardingsphere.infra.util.exception.ShardingSpherePreconditions;
import org.apache.shardingsphere.shadow.api.config.ShadowRuleConfiguration;
import org.apache.shardingsphere.shadow.distsql.parser.segment.ShadowAlgorithmSegment;

import java.util.Collection;
Expand All @@ -37,110 +37,82 @@
*/
public class ShadowRuleStatementChecker {

public static final String SHADOW = "shadow";

/**
* Check if the configuration exists.
* Check if the rule configuration exists.
*
* @param databaseName database name
* @param config configuration
* @param ruleConfig rule configuration
*/
public static void checkConfigurationExist(final String databaseName, final DatabaseRuleConfiguration config) {
ShardingSpherePreconditions.checkNotNull(config, () -> new MissingRequiredRuleException(SHADOW, databaseName));
public static void checkRuleConfigurationExists(final String databaseName, final ShadowRuleConfiguration ruleConfig) {
ShardingSpherePreconditions.checkNotNull(ruleConfig, () -> new MissingRequiredRuleException("shadow", databaseName));
}

/**
* Check if resources exist in meta data.
* Check if storage units exist in meta data.
*
* @param resources resource being checked
* @param requiredStorageUnits required storage units
* @param database database
*/
public static void checkResourceExist(final Collection<String> resources, final ShardingSphereDatabase database) {
Collection<String> notExistedResources = database.getResourceMetaData().getNotExistedResources(resources);
ShardingSpherePreconditions.checkState(notExistedResources.isEmpty(), () -> new MissingRequiredResourcesException(database.getName(), notExistedResources));
public static void checkStorageUnitsExist(final Collection<String> requiredStorageUnits, final ShardingSphereDatabase database) {
Collection<String> notExistedStorageUnits = database.getResourceMetaData().getNotExistedResources(requiredStorageUnits);
ShardingSpherePreconditions.checkState(notExistedStorageUnits.isEmpty(), () -> new MissingRequiredResourcesException(database.getName(), notExistedStorageUnits));
}

/**
* Check the completeness of the algorithm.
* Check the completeness of the algorithms.
*
* @param algorithmSegments algorithmSegments to be checked
* @param algorithmSegments to be checked segments
*/
public static void checkAlgorithmCompleteness(final Collection<ShadowAlgorithmSegment> algorithmSegments) {
Set<ShadowAlgorithmSegment> incompleteAlgorithms = algorithmSegments.stream().filter(each -> !each.isComplete()).collect(Collectors.toSet());
ShardingSpherePreconditions.checkState(incompleteAlgorithms.isEmpty(), () -> new InvalidAlgorithmConfigurationException(SHADOW));
}

/**
* Check if the rules exist.
*
* @param requireRules require rules
* @param currentRules current rules
* @param thrower thrower
*/
public static void checkRulesExist(final Collection<String> requireRules,
final Collection<String> currentRules, final Function<Collection<String>, DistSQLException> thrower) {
ShadowRuleStatementChecker.checkAnyDifferent(requireRules, currentRules, thrower);
}

/**
* Check if the algorithms exist.
*
* @param requireAlgorithms require algorithms
* @param currentAlgorithms current algorithms
* @param thrower thrower
*/
public static void checkAlgorithmExist(final Collection<String> requireAlgorithms,
final Collection<String> currentAlgorithms, final Function<Collection<String>, DistSQLException> thrower) {
ShadowRuleStatementChecker.checkAnyDifferent(requireAlgorithms, currentAlgorithms, thrower);
ShardingSpherePreconditions.checkState(incompleteAlgorithms.isEmpty(), () -> new InvalidAlgorithmConfigurationException("shadow"));
}

/**
* Check for any duplicate data in the rules, and throw the specified exception.
* Check if there are duplicated rules.
*
* @param rules rules to be checked
* @param thrower exception thrower
*/
public static void checkAnyDuplicate(final Collection<String> rules, final Function<Collection<String>, DistSQLException> thrower) {
Collection<String> duplicateRequire = getDuplicate(rules);
ShardingSpherePreconditions.checkState(duplicateRequire.isEmpty(), () -> thrower.apply(duplicateRequire));
public static void checkDuplicated(final Collection<String> rules, final Function<Collection<String>, DistSQLException> thrower) {
Collection<String> duplicated = getDuplicated(rules);
ShardingSpherePreconditions.checkState(duplicated.isEmpty(), () -> thrower.apply(duplicated));
}

/**
* Check if there are duplicates in the rules, and throw the specified exception.
* Check if there are duplicated rules.
*
* @param requireRules rules to be checked
* @param currentRules rules to be checked
* @param requiredRules required rules
* @param currentRules current rules
* @param thrower exception thrower
*/
public static void checkAnyDuplicate(final Collection<String> requireRules,
final Collection<String> currentRules, final Function<Collection<String>, DistSQLException> thrower) {
Collection<String> identical = getIdentical(requireRules, currentRules);
ShardingSpherePreconditions.checkState(identical.isEmpty(), () -> thrower.apply(identical));
public static void checkDuplicated(final Collection<String> requiredRules, final Collection<String> currentRules, final Function<Collection<String>, DistSQLException> thrower) {
Collection<String> duplicated = getDuplicated(requiredRules, currentRules);
ShardingSpherePreconditions.checkState(duplicated.isEmpty(), () -> thrower.apply(duplicated));
}

/**
* Check for any different data in the rules, and throw the specified exception.
* Check the required rules existed.
*
* @param requireRules rules to be checked
* @param currentRules rules to be checked
* @param requiredRules required rules
* @param currentRules current rules
* @param thrower exception thrower
*/
public static void checkAnyDifferent(final Collection<String> requireRules,
final Collection<String> currentRules, final Function<Collection<String>, DistSQLException> thrower) {
Collection<String> different = getDifferent(requireRules, currentRules);
ShardingSpherePreconditions.checkState(different.isEmpty(), () -> thrower.apply(different));
public static void checkExisted(final Collection<String> requiredRules, final Collection<String> currentRules, final Function<Collection<String>, DistSQLException> thrower) {
Collection<String> notExisted = getNotExisted(requiredRules, currentRules);
ShardingSpherePreconditions.checkState(notExisted.isEmpty(), () -> thrower.apply(notExisted));
}

private static Collection<String> getDuplicate(final Collection<String> require) {
return require.stream().collect(Collectors.groupingBy(each -> each, Collectors.counting())).entrySet().stream()
private static Collection<String> getDuplicated(final Collection<String> names) {
return names.stream().collect(Collectors.groupingBy(each -> each, Collectors.counting())).entrySet().stream()
.filter(each -> each.getValue() > 1).map(Map.Entry::getKey).collect(Collectors.toSet());
}

private static Collection<String> getDifferent(final Collection<String> require, final Collection<String> current) {
return require.stream().filter(each -> !current.contains(each)).collect(Collectors.toSet());
private static Collection<String> getDuplicated(final Collection<String> required, final Collection<String> current) {
return required.stream().filter(current::contains).collect(Collectors.toSet());
}

private static Collection<String> getIdentical(final Collection<String> require, final Collection<String> current) {
return require.stream().filter(current::contains).collect(Collectors.toSet());
private static Collection<String> getNotExisted(final Collection<String> required, final Collection<String> current) {
return required.stream().filter(each -> !current.contains(each)).collect(Collectors.toSet());
}
}
Loading

0 comments on commit 01f4968

Please sign in to comment.