/**
 * 通過(guò)GrayLoadBalancer過(guò)濾實(shí)例
 */
@Component
@Slf4j
public class GrayLoadBalancerClientFilter implements GlobalFilter, Ordered {
    @Resource
    private LoadBalancerClientFactory clientFactory;
    @Resource
    private CustomProperty customProperty;
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        URI url = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
        ServerWebExchangeUtils.addOriginalRequestUrl(exchange, url);
        if (url == null || BizConstant.HTTP.equalsIgnoreCase(url.getScheme())) {
            return chain.filter(exchange);
        }
        return doFilter(exchange, chain, url);
    }
    private Mono<Void> doFilter(ServerWebExchange exchange, GatewayFilterChain chain, URI url) {
        return this.choose(exchange).doOnNext(res -> {
            if (!res.hasServer()) {
                throw NotFoundException.create(true, "Unable to find instance for ".concat(url.getHost()));
            }
            URI uri = exchange.getRequest().getURI();
            String overrideScheme = null;
            DelegatingServiceInstance delegatingServiceInstance = new DelegatingServiceInstance(res.getServer(), overrideScheme);
            URI reqUrl = this.reconstructURI(delegatingServiceInstance, uri);
            if (log.isDebugEnabled()) {
                log.debug("GrayLoadBalancerClientFilter url chosen: {}", reqUrl.toString());
            }
            exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR, reqUrl);
        }).then(chain.filter(exchange));
    }
    private URI reconstructURI(DelegatingServiceInstance delegatingServiceInstance, URI originalUri) {
        return LoadBalancerUriTools.reconstructURI(delegatingServiceInstance, originalUri);
    }
    private Mono<Response<ServiceInstance>> choose(ServerWebExchange exchange) {
        URI uri = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
        if (uri == null) {
            throw new MMException("{} is null", ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR);
        }
        GrayLoadBalancer loadBalancer = new GrayLoadBalancer(clientFactory.getLazyProvider(uri.getHost(), ServiceInstanceListSupplier.class), uri.getHost(), customProperty);
        return loadBalancer.choose(this.createRequest(exchange));
    }
    private Request createRequest(ServerWebExchange exchange) {
        return new DefaultRequest(exchange.getRequest().getHeaders());
    }
    @Override
    public int getOrder() {
        return FILTER_ORDER_GRAY;
    }
}

/**
 * 灰度發(fā)布負(fù)載均衡策略
 */
@Slf4j
public class GrayLoadBalancer implements ReactorServiceInstanceLoadBalancer {
    private ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;
    private String serviceId;
    private CustomProperty customProperty;
    public GrayLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider, String serviceId, CustomProperty customProperty) {
        this.serviceId = serviceId;
        this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;
        this.customProperty = customProperty;
    }
    @Override
    public Mono<Response<ServiceInstance>> choose(Request request) {
        HttpHeaders headers = (HttpHeaders) request.getContext();
        if (this.serviceInstanceListSupplierProvider != null) {
            ServiceInstanceListSupplier supplier = this.serviceInstanceListSupplierProvider.getIfAvailable(NoopServiceInstanceListSupplier::new);
            return supplier.get().next().map(item -> getInstanceResponse(item, headers));
        }
        return null;
    }
    private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> instances, HttpHeaders headers) {
        if (instances.isEmpty()) {
            return getServiceInstanceEmptyResponse();
        }
        return getServiceInstanceResponseByUidsOrGrayTag(instances, headers);
    }
    /**
     * 從nacos獲取服務(wù)實(shí)例列表，并根據(jù)策略返回灰度服務(wù)的實(shí)例還是正常服務(wù)的實(shí)例
     */
    private Response<ServiceInstance> getServiceInstanceResponseByUidsOrGrayTag(List<ServiceInstance> instances, HttpHeaders headers) {
        List<ServiceInstance> grayInstances = new ArrayList<>();
        List<ServiceInstance> normalInstances = new ArrayList<>();
        for (ServiceInstance instance : instances) {
            Map<String, String> metadata = instance.getMetadata();
            // nacos元數(shù)據(jù)包含“gray-tag”的key值,且value="true"，則判定為灰度實(shí)例
            String isGrayInstance = metadata.get(BizConstant.GRAY_TAG);
            if (BizConstant.TRUE.equals(isGrayInstance)) {
                grayInstances.add(instance);
            } else {
                normalInstances.add(instance);
            }
        }
        //沒(méi)有灰度服務(wù)，直接返回
        if (grayInstances.isEmpty()) {
            return new DefaultResponse(chooseOneInstance(normalInstances));
        }
        //有灰度服務(wù)，判斷是否需要灰度
        if (checkIfNeedGray(headers)) {
            log.info("gray service of {} will be called", this.serviceId);
            return new DefaultResponse(chooseOneInstance(grayInstances));
        }
        return new DefaultResponse(chooseOneInstance(normalInstances));
    }
    /**
     * 從實(shí)例列表中獲取其中一個(gè)實(shí)例的策略實(shí)現(xiàn)，這里采用的是隨機(jī)挑選
     * pick strategy 可以根據(jù)業(yè)務(wù)需要，在這個(gè)方法里改寫(xiě)
     */
    private ServiceInstance chooseOneInstance(List<ServiceInstance> serviceInstances) {
        // strategy 1：可用的里面隨機(jī)選擇一個(gè)
        int size = serviceInstances.size();
        if (size == 1) {
            return serviceInstances.get(0);
        }
        Random rand = new Random();
        int random = rand.nextInt(size);
        return serviceInstances.get(random);
    }
    /**
     * 灰度判斷邏輯：
     * 1. 判斷請(qǐng)求header里是否用灰度標(biāo)識(shí)的 kv，有則走灰度服務(wù)
     * 2. 如果 1 不滿足，則判斷請(qǐng)求的用戶 id 是否在灰度用戶池中，有則走灰度服務(wù)
     * 3. 1 和 2 都不滿足，走正常服務(wù)
     */
    private boolean checkIfNeedGray(HttpHeaders headers) {
        String grayTag = headers.getFirst(BizConstant.GRAY_TAG);
        if (grayTag != null) {
            if (BizConstant.TRUE.equalsIgnoreCase(grayTag)) {
                // todo 可擴(kuò)展點(diǎn)：目前是只判斷header里是否有BizConstant.GRAY_TAG的kv不為空且v="true"，后面v可以改為版本號(hào)
                return true;
            }
        }
        String uid = headers.getFirst(BizConstant.UID);
        if (uid != null && customProperty.getGraySetting().getGrayUids().contains(uid)) {
            return true;
        }
        return false;
    }
    private Response<ServiceInstance> getServiceInstanceEmptyResponse() {
        log.warn("No servers available for service: " + this.serviceId);
        return new EmptyResponse();
    }
}

/**
 * https scheme to http
 */
@Component
@Slf4j
public class Https2HttpFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        URI originalUri = request.getURI();
        ServerHttpRequest.Builder mutate = request.mutate();
        String forwardUri = request.getURI().toString();
        if (forwardUri != null && forwardUri.startsWith(BizConstant.HTTPS)) {
            try {
                URI mutatedUri = new URI(BizConstant.HTTP,
                        originalUri.getUserInfo(),
                        originalUri.getHost(),
                        originalUri.getPort(),
                        originalUri.getPath(),
                        originalUri.getQuery(),
                        originalUri.getFragment());
                mutate.uri(mutatedUri);
            } catch (Exception e) {
                log.error(e.getMessage());
                throw new MMException("Https related error");
            }
        }
        ServerHttpRequest build = mutate.build();
        return chain.filter(exchange.mutate().request(build).build());
    }
    @Override
    public int getOrder() {
        return FILTER_ORDER_HTTPS_2_HTTP;
    }
}

spring:
  cloud:
    nacos:
      discovery:
        metadata:
          # 如果${gray}變量不存在，則gray-tag=false
          gray-tag: ${gray:false} 

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ccc-deploy
  namespace: ccc
spec:
  template:
    spec:
      containers: 
      - env:
          - name: gray
            value: "gray-tag" # 這里的gray-tag值 將會(huì)在在.gitlab-ci.yml的腳本中被替換

...
stages:
  - k8s-deploy
k8s-deploy-gray-service:
  stage: k8s-deploy
  script:
    - echo "=============== 開(kāi)始 k8s 部署任務(wù) ==============="
    - sed -i "s/gray-tag/true/g" kube_deploy.yml # 這
    - kubectl apply -f kube_deploy.yml
  only:
    - /^tag_gray_.*$/
k8s-deploy-normal-service:
  stage: k8s-deploy
  script:
    - echo "=============== 開(kāi)始 k8s 部署任務(wù) ==============="
    - sed -i "s/gray-tag/false/g" kube_deploy.yml # 這里替換 gray-tag 為 false
    - kubectl apply -f kube_deploy.yml
  only:
    - /^tag_normal_.*$/
 ...