修复bug，优化代码， 拆分插件

Author: saleson

spring-cloud-gray-client-netflix/src/main/java/cn/springcloud/gray/client/netflix/RibbonServerChooser.java

@@ -0,0 +1,102 @@
+package cn.springcloud.gray.client.netflix;
+
+import cn.springcloud.gray.GrayManager;
+import cn.springcloud.gray.ServerChooser;
+import cn.springcloud.gray.ServerListResult;
+import cn.springcloud.gray.choose.GrayPredicate;
+import cn.springcloud.gray.model.GrayService;
+import cn.springcloud.gray.request.GrayRequest;
+import cn.springcloud.gray.request.RequestLocalStorage;
+import cn.springcloud.gray.servernode.ServerExplainer;
+import cn.springcloud.gray.servernode.ServerListProcessor;
+import cn.springcloud.gray.servernode.ServerSpec;
+import com.netflix.loadbalancer.Server;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class RibbonServerChooser implements ServerChooser<Server> {
+
+    private GrayManager grayManager;
+
+    private RequestLocalStorage requestLocalStorage;
+
+    private GrayPredicate grayPredicate;
+
+    private ServerExplainer<Server> serverExplainer;
+
+    protected ServerListProcessor serverListProcessor;
+
+
+    public RibbonServerChooser(
+            GrayManager grayManager,
+            RequestLocalStorage requestLocalStorage,
+            GrayPredicate grayPredicate,
+            ServerExplainer<Server> serverExplainer,
+            ServerListProcessor serverListProcessor) {
+        this.grayManager = grayManager;
+        this.requestLocalStorage = requestLocalStorage;
+        this.grayPredicate = grayPredicate;
+        this.serverExplainer = serverExplainer;
+        this.serverListProcessor = serverListProcessor;
+    }
+
+    @Override
+    public boolean matchGrayDecisions(ServerSpec serverSpec) {
+        return grayPredicate.apply(serverSpec);
+    }
+
+    @Override
+    public boolean matchGrayDecisions(Server server) {
+        return matchGrayDecisions(serverExplainer.apply(server));
+    }
+
+    @Override
+    public ServerListResult<Server> distinguishServerList(List<Server> servers) {
+        GrayRequest grayRequest = requestLocalStorage.getGrayRequest();
+        if (grayRequest == null) {
+            return null;
+        }
+
+        return distinguishServerList(grayRequest.getServiceId(), servers);
+    }
+
+
+    @Override
+    public ServerListResult<Server> distinguishAndMatchGrayServerList(List<Server> servers) {
+        ServerListResult<Server> serverListResult = distinguishServerList(servers);
+        if (serverListResult == null) {
+            return null;
+        }
+
+        serverListResult.setGrayServers(
+                serverListResult.getGrayServers().stream()
+                        .filter(this::matchGrayDecisions)
+                        .collect(Collectors.toList()));
+
+        return serverListResult;
+    }
+
+
+    private ServerListResult<Server> distinguishServerList(String serviceId, List<Server> servers) {
+        if (!grayManager.hasGray(serviceId)) {
+            return null;
+        }
+
+        GrayService grayService = grayManager.getGrayService(serviceId);
+        List<Server> serverList = serverListProcessor.process(serviceId, servers);
+        List<Server> grayServers = new ArrayList<>(grayService.getGrayInstances().size());
+        List<Server> normalServers = new ArrayList<>(Math.min(servers.size(), grayService.getGrayInstances().size()));
+
+        for (Server server : serverList) {
+            if (grayService.getGrayInstance(server.getMetaInfo().getInstanceId()) != null) {
+                grayServers.add(server);
+            } else {
+                normalServers.add(server);
+            }
+        }
+
+        return new ServerListResult<>(serviceId, grayServers, normalServers);
+    }
+}

spring-cloud-gray-client-netflix/src/main/java/cn/springcloud/gray/client/netflix/configuration/properties/GrayHystrixProperties.java

@@ -0,0 +1,17 @@
+package cn.springcloud.gray.client.netflix.configuration.properties;
+
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+@Data
+@ConfigurationProperties("gray.hystrix")
+public class GrayHystrixProperties {
+    private boolean enabled;
+
+    private ThreadTransmitStrategy threadTransmitStrategy = ThreadTransmitStrategy.WRAP_CALLABLE;
+
+    public static enum ThreadTransmitStrategy {
+        WRAP_CALLABLE, HYSTRIX_REQUEST_LOCAL_STORAGE
+    }
+}

spring-cloud-gray-client-netflix/src/main/java/cn/springcloud/gray/client/netflix/hystrix/GrayHystrixContextConcurrencyStrategy.java

@@ -0,0 +1,75 @@
+package cn.springcloud.gray.client.netflix.hystrix;
+
+
+import cn.springcloud.gray.concurrent.GrayCallable;
+import cn.springcloud.gray.concurrent.GrayConcurrentHelper;
+import com.netflix.hystrix.HystrixThreadPoolKey;
+import com.netflix.hystrix.HystrixThreadPoolProperties;
+import com.netflix.hystrix.strategy.HystrixPlugins;
+import com.netflix.hystrix.strategy.concurrency.HystrixConcurrencyStrategy;
+import com.netflix.hystrix.strategy.concurrency.HystrixRequestVariable;
+import com.netflix.hystrix.strategy.concurrency.HystrixRequestVariableLifecycle;
+import com.netflix.hystrix.strategy.eventnotifier.HystrixEventNotifier;
+import com.netflix.hystrix.strategy.executionhook.HystrixCommandExecutionHook;
+import com.netflix.hystrix.strategy.metrics.HystrixMetricsPublisher;
+import com.netflix.hystrix.strategy.properties.HystrixPropertiesStrategy;
+import com.netflix.hystrix.strategy.properties.HystrixProperty;
+
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+public class GrayHystrixContextConcurrencyStrategy extends HystrixConcurrencyStrategy {
+    private HystrixConcurrencyStrategy delegate;
+
+    public GrayHystrixContextConcurrencyStrategy() {
+        this.delegate = HystrixPlugins.getInstance().getConcurrencyStrategy();
+        if (this.delegate instanceof GrayHystrixContextConcurrencyStrategy) {
+            return;
+        }
+        // Keeps references of existing Hystrix plugins.
+        HystrixCommandExecutionHook commandExecutionHook = HystrixPlugins.getInstance().getCommandExecutionHook();
+        HystrixEventNotifier eventNotifier = HystrixPlugins.getInstance().getEventNotifier();
+        HystrixMetricsPublisher metricsPublisher = HystrixPlugins.getInstance().getMetricsPublisher();
+        HystrixPropertiesStrategy propertiesStrategy = HystrixPlugins.getInstance().getPropertiesStrategy();
+
+        HystrixPlugins.reset();
+
+        // Registers existing plugins excepts the Concurrent Strategy plugin.
+        HystrixPlugins.getInstance().registerConcurrencyStrategy(this);
+        HystrixPlugins.getInstance().registerCommandExecutionHook(commandExecutionHook);
+        HystrixPlugins.getInstance().registerEventNotifier(eventNotifier);
+        HystrixPlugins.getInstance().registerMetricsPublisher(metricsPublisher);
+        HystrixPlugins.getInstance().registerPropertiesStrategy(propertiesStrategy);
+    }
+
+    @Override
+    public BlockingQueue<Runnable> getBlockingQueue(int maxQueueSize) {
+        return delegate.getBlockingQueue(maxQueueSize);
+    }
+
+    @Override
+    public <T> HystrixRequestVariable<T> getRequestVariable(HystrixRequestVariableLifecycle<T> rv) {
+        return delegate.getRequestVariable(rv);
+    }
+
+    @Override
+    public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey, HystrixProperty<Integer> corePoolSize, HystrixProperty<Integer> maximumPoolSize, HystrixProperty<Integer> keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
+        return delegate.getThreadPool(threadPoolKey, corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
+    }
+
+    @Override
+    public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey, HystrixThreadPoolProperties threadPoolProperties) {
+        return delegate.getThreadPool(threadPoolKey, threadPoolProperties);
+    }
+
+    @Override
+    public <T> Callable<T> wrapCallable(Callable<T> callable) {
+        Callable<T> delegateWrapCallable = delegate.wrapCallable(callable);
+        if(delegateWrapCallable instanceof GrayCallable){
+            return delegateWrapCallable;
+        }
+        return GrayConcurrentHelper.createDelegateCallable(delegateWrapCallable);
+    }
+}

spring-cloud-gray-client-netflix/src/main/java/cn/springcloud/gray/client/netflix/ribbon/GrayChooserRule.java

@@ -0,0 +1,28 @@
+package cn.springcloud.gray.client.netflix.ribbon;
+
+import cn.springcloud.gray.GrayClientHolder;
+import cn.springcloud.gray.ServerChooser;
+import com.google.common.base.Optional;
+import com.netflix.loadbalancer.Server;
+import com.netflix.loadbalancer.ZoneAvoidanceRule;
+
+public class GrayChooserRule extends ZoneAvoidanceRule {
+
+    private ServerChooser<Server> serverChooser;
+
+    public GrayChooserRule() {
+        serverChooser = GrayClientHolder.getServerChooser();
+    }
+
+    @Override
+    public Server choose(Object key) {
+        return serverChooser.chooseServer(getLoadBalancer().getAllServers(), servers -> {
+            Optional<Server> server = getPredicate().chooseRoundRobinAfterFiltering(servers, key);
+            if (server.isPresent()) {
+                return server.get();
+            } else {
+                return null;
+            }
+        });
+    }
+}

spring-cloud-gray-client/src/main/java/cn/springcloud/gray/ServerChooser.java

@@ -0,0 +1,49 @@
+package cn.springcloud.gray;
+
+import cn.springcloud.gray.choose.ListChooser;
+import cn.springcloud.gray.servernode.ServerSpec;
+import org.apache.commons.collections.CollectionUtils;
+
+import java.util.List;
+
+public interface ServerChooser <Server> {
+
+    boolean matchGrayDecisions(ServerSpec serverSpec);
+
+    boolean matchGrayDecisions(Server server);
+
+    /**
+     * 区分灰度实例和正常实例
+     * @param servers
+     * @return 返回区分后的结果，如果关闭灰度开关，将会返回null
+     */
+    ServerListResult<Server> distinguishServerList(List<Server> servers);
+
+
+
+    /**
+     * 区分灰度实例和正常实例,并比对灰度实例的灰度决策
+     * @param servers
+     * @return 返回区分及比对后的结果，如果关闭灰度开关，将会返回null
+     */
+    ServerListResult<Server> distinguishAndMatchGrayServerList(List<Server> servers);
+
+
+
+    default Server chooseServer(List<Server> servers, ListChooser<Server> chooser){
+        ServerListResult<Server> serverListResult = distinguishAndMatchGrayServerList(servers);
+        if(serverListResult==null){
+            return chooser.choose(servers);
+        }
+
+        if(CollectionUtils.isNotEmpty(serverListResult.getGrayServers())){
+            Server server = chooser.choose(serverListResult.getGrayServers());
+            if(server!=null){
+                return server;
+            }
+        }
+
+        return chooser.choose(serverListResult.getNormalServers());
+    }
+
+}

spring-cloud-gray-client/src/main/java/cn/springcloud/gray/ServerListResult.java

@@ -0,0 +1,18 @@
+package cn.springcloud.gray;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class ServerListResult<Server> {
+
+    private String serviceId;
+
+    private List<Server> grayServers;
+    private List<Server> normalServers;
+}

spring-cloud-gray-client/src/main/java/cn/springcloud/gray/choose/DefaultGrayPredicate.java

@@ -0,0 +1,51 @@
+package cn.springcloud.gray.choose;
+
+import cn.springcloud.gray.GrayManager;
+import cn.springcloud.gray.decision.GrayDecision;
+import cn.springcloud.gray.decision.GrayDecisionInputArgs;
+import cn.springcloud.gray.request.GrayRequest;
+import cn.springcloud.gray.request.RequestLocalStorage;
+import cn.springcloud.gray.servernode.ServerSpec;
+
+import java.util.List;
+
+public class DefaultGrayPredicate implements GrayPredicate {
+
+    private RequestLocalStorage requestLocalStorage;
+    private GrayManager grayManager;
+
+
+    public DefaultGrayPredicate(RequestLocalStorage requestLocalStorage, GrayManager grayManager) {
+        this.requestLocalStorage = requestLocalStorage;
+        this.grayManager = grayManager;
+    }
+
+    @Override
+    public boolean apply(ServerSpec serverSpec) {
+        GrayDecisionInputArgs decisionInputArgs = GrayDecisionInputArgs
+                .builder().grayRequest(requestLocalStorage.getGrayRequest()).server(serverSpec).build();
+        return apply(decisionInputArgs);
+    }
+
+    @Override
+    public boolean apply(GrayDecisionInputArgs decisionInputArgs) {
+        GrayRequest grayRequest = decisionInputArgs.getGrayRequest();
+        if(grayRequest==null){
+            return false;
+        }
+        ServerSpec serverSpec = decisionInputArgs.getServer();
+        if(serverSpec==null){
+            return false;
+        }
+
+        List<GrayDecision> grayDecisions =
+                grayManager.getGrayDecision(serverSpec.getServiceId(), serverSpec.getInstanceId());
+
+        for (GrayDecision grayDecision : grayDecisions) {
+            if (grayDecision.test(decisionInputArgs)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

spring-cloud-gray-client/src/main/java/cn/springcloud/gray/choose/GrayPredicate.java

@@ -0,0 +1,12 @@
+package cn.springcloud.gray.choose;
+
+import cn.springcloud.gray.decision.GrayDecisionInputArgs;
+import cn.springcloud.gray.servernode.ServerSpec;
+
+public interface GrayPredicate {
+
+    boolean apply(ServerSpec serverSpec);
+
+    boolean apply(GrayDecisionInputArgs decisionInputArgs);
+
+}

spring-cloud-gray-client/src/main/java/cn/springcloud/gray/choose/ListChooser.java

@@ -0,0 +1,8 @@
+package cn.springcloud.gray.choose;
+
+import java.util.List;
+
+public interface ListChooser<Server> {
+
+    Server choose(List<Server> servers);
+}