You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@shardingsphere.apache.org by ji...@apache.org on 2021/12/09 08:51:16 UTC

[shardingsphere] branch master updated: [DistSQL] Refactor the show readwrite_splitting read resources statement to be compatible with MGR (#14011)

This is an automated email from the ASF dual-hosted git repository.

jianglongtao 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 95e2a98  [DistSQL] Refactor the show readwrite_splitting read resources statement to be compatible with MGR (#14011)
95e2a98 is described below

commit 95e2a98b078be7629c09d0aa6f44436b436313bc
Author: lanchengx <52...@users.noreply.github.com>
AuthorDate: Thu Dec 9 16:50:28 2021 +0800

    [DistSQL] Refactor the show readwrite_splitting read resources statement to be compatible with MGR (#14011)
    
    * Refactor the `show readwrite_splitting read resources` statement to be compatible with MGR.
    
    * `getAutoAwareDataSources` adds the judgment of whether the `autoAwareDataSourceName` exists.
---
 .../rule/ReadwriteSplittingDataSourceRule.java     |  2 +-
 ...howReadwriteSplittingReadResourcesExecutor.java | 87 ++++++++++++++++------
 2 files changed, 65 insertions(+), 24 deletions(-)

diff --git a/shardingsphere-features/shardingsphere-readwrite-splitting/shardingsphere-readwrite-splitting-core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceRule.java b/shardingsphere-features/shardingsphere-readwrite-splitting/shardingsphere-readwrite-splitting-core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceRule.java
index ebc23d8..f1236e8 100644
--- a/shardingsphere-features/shardingsphere-readwrite-splitting/shardingsphere-readwrite-splitting-core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceRule.java
+++ b/shardingsphere-features/shardingsphere-readwrite-splitting/shardingsphere-readwrite-splitting-core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingDataSourceRule.java
@@ -125,7 +125,7 @@ public final class ReadwriteSplittingDataSourceRule {
      */
     public Map<String, String> getAutoAwareDataSources() {
         Optional<DataSourceNameAware> dataSourceNameAware = DataSourceNameAwareFactory.getInstance().getDataSourceNameAware();
-        if (dataSourceNameAware.isPresent() && dataSourceNameAware.get().getRule().isPresent()) {
+        if (!Strings.isNullOrEmpty(autoAwareDataSourceName) && dataSourceNameAware.isPresent() && dataSourceNameAware.get().getRule().isPresent()) {
             Map<String, String> result = new HashMap<>(2, 1);
             result.put(ReadwriteSplittingRuleConstants.PRIMARY_DATA_SOURCE_NAME, dataSourceNameAware.get().getPrimaryDataSourceName(autoAwareDataSourceName));
             result.put(ReadwriteSplittingRuleConstants.REPLICA_DATA_SOURCE_NAMES, String.join(",", dataSourceNameAware.get().getReplicaDataSourceNames(autoAwareDataSourceName)));
diff --git a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/ral/common/show/executor/ShowReadwriteSplittingReadResourcesExecutor.java b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/ral/common/show/executor/ShowReadwriteSplittingReadResourcesExecutor.java
index 7b3cf424..c6b7843 100644
--- a/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/ral/common/show/executor/ShowReadwriteSplittingReadResourcesExecutor.java
+++ b/shardingsphere-proxy/shardingsphere-proxy-backend/src/main/java/org/apache/shardingsphere/proxy/backend/text/distsql/ral/common/show/executor/ShowReadwriteSplittingReadResourcesExecutor.java
@@ -21,8 +21,10 @@ import lombok.RequiredArgsConstructor;
 import org.apache.shardingsphere.infra.exception.SchemaNotExistedException;
 import org.apache.shardingsphere.infra.merge.result.MergedResult;
 import org.apache.shardingsphere.infra.metadata.ShardingSphereMetaData;
+import org.apache.shardingsphere.infra.rule.identifier.type.ExportableRule;
 import org.apache.shardingsphere.mode.manager.cluster.coordinator.registry.status.storage.StorageNodeStatus;
 import org.apache.shardingsphere.mode.manager.cluster.coordinator.registry.status.storage.node.StorageStatusNode;
+import org.apache.shardingsphere.mode.metadata.MetaDataContexts;
 import org.apache.shardingsphere.mode.metadata.persist.MetaDataPersistService;
 import org.apache.shardingsphere.proxy.backend.context.ProxyContext;
 import org.apache.shardingsphere.proxy.backend.exception.NoDatabaseSelectedException;
@@ -30,6 +32,7 @@ import org.apache.shardingsphere.proxy.backend.response.header.query.impl.QueryH
 import org.apache.shardingsphere.proxy.backend.session.ConnectionSession;
 import org.apache.shardingsphere.readwritesplitting.api.ReadwriteSplittingRuleConfiguration;
 import org.apache.shardingsphere.readwritesplitting.api.rule.ReadwriteSplittingDataSourceRuleConfiguration;
+import org.apache.shardingsphere.readwritesplitting.constant.ReadwriteSplittingRuleConstants;
 import org.apache.shardingsphere.readwritesplitting.distsql.parser.statement.ShowReadwriteSplittingReadResourcesStatement;
 import org.apache.shardingsphere.sharding.merge.dal.common.MultipleLocalDataMergedResult;
 
@@ -40,9 +43,12 @@ import java.util.Collections;
 import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * Show readwrite-splitting read resources executor.
@@ -52,6 +58,8 @@ public final class ShowReadwriteSplittingReadResourcesExecutor extends AbstractS
     
     private static final String DELIMITER = "\\.";
     
+    private static final String SCHEMA_NAME = "schema_name";
+    
     private static final String RESOURCE = "resource";
     
     private static final String STATUS = "status";
@@ -67,6 +75,7 @@ public final class ShowReadwriteSplittingReadResourcesExecutor extends AbstractS
     @Override
     protected List<QueryHeader> createQueryHeaders() {
         return Arrays.asList(
+                new QueryHeader("", "", SCHEMA_NAME, SCHEMA_NAME, Types.VARCHAR, "VARCHAR", 64, 0, false, false, false, false),
                 new QueryHeader("", "", RESOURCE, RESOURCE, Types.VARCHAR, "VARCHAR", 64, 0, false, false, false, false),
                 new QueryHeader("", "", STATUS, STATUS, Types.VARCHAR, "VARCHAR", 64, 0, false, false, false, false));
     }
@@ -80,44 +89,76 @@ public final class ShowReadwriteSplittingReadResourcesExecutor extends AbstractS
         if (!ProxyContext.getInstance().getAllSchemaNames().contains(schemaName)) {
             throw new SchemaNotExistedException(schemaName);
         }
-        ShardingSphereMetaData metaData = ProxyContext.getInstance().getContextManager().getMetaDataContexts().getMetaData(schemaName);
-        Collection<List<Object>> rows = buildResourceRows(metaData, ENABLE);
-        MetaDataPersistService persistService = ProxyContext.getInstance().getContextManager().getMetaDataContexts().getMetaDataPersistService().orElse(null);
-        if (null == persistService || null == persistService.getRepository()) {
-            return new MultipleLocalDataMergedResult(rows);
-        }
-        Collection<List<Object>> disabledResourceRows = buildResourceRows(persistService, DISABLE);
-        return new MultipleLocalDataMergedResult(mergeRows(rows, disabledResourceRows));
+        MetaDataContexts metaDataContexts = ProxyContext.getInstance().getContextManager().getMetaDataContexts();
+        ShardingSphereMetaData metaData = metaDataContexts.getMetaData(schemaName);
+        Collection<Object> notShownResourceRows = new LinkedHashSet<>();
+        Collection<List<Object>> enableResourceRows = buildEnableResourceRows(schemaName, metaData, notShownResourceRows);
+        Collection<List<Object>> disabledResourceRows = buildDisableResourceRows(schemaName, metaDataContexts.getMetaDataPersistService().orElse(null), notShownResourceRows);
+        return new MultipleLocalDataMergedResult(mergeRows(enableResourceRows, disabledResourceRows, notShownResourceRows));
+    }
+    
+    private Collection<List<Object>> buildEnableResourceRows(final String schemaName, final ShardingSphereMetaData metaData, final Collection<Object> notShownResourceRows) {
+        LinkedList<String> configuredResourceRows = getConfiguredResourceRows(metaData);
+        Collection<String> autoAwareResourceRows = getAutoAwareResourceRows(metaData, notShownResourceRows);
+        return Stream.of(configuredResourceRows, autoAwareResourceRows).flatMap(Collection::stream).distinct()
+                .map(each -> buildRow(schemaName, each, ENABLE)).collect(Collectors.toCollection(LinkedList::new));
     }
     
-    private Collection<List<Object>> buildResourceRows(final ShardingSphereMetaData metaData, final String status) {
+    private LinkedList<String> getConfiguredResourceRows(final ShardingSphereMetaData metaData) {
         Collection<ReadwriteSplittingRuleConfiguration> ruleConfiguration = metaData.getRuleMetaData().findRuleConfiguration(ReadwriteSplittingRuleConfiguration.class);
-        Set<String> allResources = ruleConfiguration.stream().map(ReadwriteSplittingRuleConfiguration::getDataSources).flatMap(Collection::stream)
-                .map(ReadwriteSplittingDataSourceRuleConfiguration::getReadDataSourceNames).flatMap(Collection::stream).collect(Collectors.toCollection(LinkedHashSet::new));
-        return allResources.stream().map(each -> buildRow(each, status)).collect(Collectors.toCollection(LinkedList::new));
+        return ruleConfiguration.stream().map(ReadwriteSplittingRuleConfiguration::getDataSources).flatMap(Collection::stream).filter(Objects::nonNull)
+                .map(ReadwriteSplittingDataSourceRuleConfiguration::getReadDataSourceNames)
+                .flatMap(Collection::stream).collect(Collectors.toCollection(LinkedList::new));
+    }
+    
+    private Collection<String> getAutoAwareResourceRows(final ShardingSphereMetaData metaData, final Collection<Object> notShownResourceRows) {
+        Map<String, Map<String, String>> autoAwareResourceData = getAutoAwareResourceData(metaData);
+        return autoAwareResourceData.entrySet().stream().peek(entry -> notShownResourceRows.add(entry.getValue().get(ReadwriteSplittingRuleConstants.PRIMARY_DATA_SOURCE_NAME)))
+                .map(entry -> entry.getValue().get(ReadwriteSplittingRuleConstants.REPLICA_DATA_SOURCE_NAMES)).filter(Objects::nonNull).map(this::deconstructString)
+                .flatMap(Collection::stream).collect(Collectors.toCollection(LinkedList::new));
+    }
+    
+    private Map<String, Map<String, String>> getAutoAwareResourceData(final ShardingSphereMetaData metaData) {
+        return metaData.getRuleMetaData().getRules().stream().filter(each -> each instanceof ExportableRule)
+                .map(each -> ((ExportableRule) each).export().get(ReadwriteSplittingRuleConstants.AUTO_AWARE_DATA_SOURCE_KEY))
+                .filter(Objects::nonNull).map(each -> (Map<String, Map<String, String>>) each)
+                .map(Map::entrySet).flatMap(Collection::stream).filter(entry -> !entry.getValue().isEmpty()).collect(Collectors.toMap(Entry::getKey, Entry::getValue));
     }
     
-    private Collection<List<Object>> buildResourceRows(final MetaDataPersistService persistService, final String status) {
-        List<String> instanceIds = persistService.getRepository().getChildrenKeys(StorageStatusNode.getStatusPath(status.equals(DISABLE) ? StorageNodeStatus.DISABLE : StorageNodeStatus.PRIMARY));
+    private Collection<List<Object>> buildDisableResourceRows(final String schemaName, final MetaDataPersistService persistService, final Collection<Object> notShownResourceRows) {
+        if (null == persistService || null == persistService.getRepository()) {
+            return Collections.emptyList();
+        }
+        Collection<List<Object>> result = Collections.emptyList();
+        List<String> instanceIds = persistService.getRepository().getChildrenKeys(StorageStatusNode.getStatusPath(StorageNodeStatus.DISABLE));
         if (!instanceIds.isEmpty()) {
-            return instanceIds.stream().filter(Objects::nonNull).map(each -> each.split(DELIMITER)[1]).map(each -> buildRow(each, status)).collect(Collectors.toCollection(LinkedList::new));
+            return instanceIds.stream().filter(Objects::nonNull).filter(each -> schemaName.equals(each.split(DELIMITER)[0])).map(each -> each.split(DELIMITER)[1])
+                    .map(each -> buildRow(schemaName, each, DISABLE)).collect(Collectors.toCollection(LinkedList::new));
         }
-        return Collections.emptyList();
+        return result;
     }
     
-    private Collection<List<Object>> mergeRows(final Collection<List<Object>> rows, final Collection<List<Object>> disabledResourceRows) {
-        Collection<List<Object>> result;
-        Set<Object> disabledResourceNames = disabledResourceRows.stream().map(each -> getResourceName(each)).collect(Collectors.toSet());
-        result = rows.stream().filter(each -> !disabledResourceNames.contains(getResourceName(each))).collect(Collectors.toCollection(LinkedList::new));
+    private Collection<List<Object>> mergeRows(final Collection<List<Object>> enableResourceRows, final Collection<List<Object>> disabledResourceRows, final Collection<Object> notShownResourceRows) {
+        Collection<List<Object>> result = replaceDisableResourceRows(enableResourceRows, disabledResourceRows);
+        return result.stream().filter(each -> !notShownResourceRows.contains(getResourceName(each))).collect(Collectors.toCollection(LinkedList::new));
+    }
+    
+    private Collection<List<Object>> replaceDisableResourceRows(final Collection<List<Object>> enableResourceRows, final Collection<List<Object>> disabledResourceRows) {
+        Set<Object> disableResourceNames = disabledResourceRows.stream().map(this::getResourceName).collect(Collectors.toSet());
+        Collection<List<Object>> result = enableResourceRows.stream().filter(each -> !disableResourceNames.contains(getResourceName(each))).collect(Collectors.toCollection(LinkedList::new));
         result.addAll(disabledResourceRows);
         return result;
     }
     
-    private List<Object> buildRow(final String resource, final String status) {
-        return Arrays.asList(resource, status);
+    private LinkedList<String> deconstructString(final String str) {
+        return new LinkedList<>(Arrays.asList(str.split(",")));
+    }
+    
+    private List<Object> buildRow(final String schemaName, final String resource, final String status) {
+        return Arrays.asList(schemaName, resource, status);
     }
     
     private Object getResourceName(final List<Object> row) {
-        return row.get(0);
+        return row.get(1);
     }
 }