package com.xiaostudy.gateway.sentinel;

import com.alibaba.csp.sentinel.init.InitFunc;

import com.alibaba.csp.sentinel.slots.block.RuleConstant;

import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;

import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;

import java.util.ArrayList;

import java.util.List;

@Configuration

public class SentinelConfig implements InitFunc {

    @Value("${web.application.name}")

    private String webName;

    /**

     * 网关规则

     */

    @PostConstruct

    @Override

    public void init() {

        initDegradeRule();

    }

    // 自定义熔断规则

    private void initDegradeRule() {

        List<DegradeRule> rules = new ArrayList<>();

        DegradeRule rule = new DegradeRule();

        rule.setResource(webName);

        // set threshold rt, 500 ms

        rule.setCount(500);

        // 设置降级规则RT, 平均响应时间

        rule.setGrade(RuleConstant.DEGRADE_GRADE_RT);

        // 设置时间窗口

        rule.setTimeWindow(10);

        rules.add(rule);

        DegradeRuleManager.loadRules(rules);

    }

}

server:

  port: '@gateway.port@'

eureka:

  port: '@eureka.port@'

  ip: '@eureka.ip@'

  url-name: '@eureka.url.name@'

  instance:

    # 把本机IP注册到eureka而不是本机机器名

    preferIpAddress: true

    # 把本机IP注册到eureka，由下面参数组成

    instance-id: ${spring.cloud.client.ip-address}:${server.port}

  client:

    serviceUrl:

      defaultZone: http://@eureka.user.name@:@eureka.user.password@@${eureka.ip}:${eureka.port}/${eureka.url-name}/

spring:

  application:

    name: '@gateway.application.name@'

  cloud:

    loadbalancer:

      retry:

        # 关闭重试

        enabled: false

    gateway:

      routes:

        # 路由的id,没有规定规则但要求唯一,建议配合服务名

        - id: '@producer.application.name@'

          # 匹配后提供服务的路由地址，LoadBalancer做负载均衡

          uri: lb://@producer.application.name@

          predicates:

            # 断言，路径相匹配的进行路由

            - Path=/producer/**

          filters:

            # 去掉url一级前缀，例如http://localhost:9904/producer/producerTest/getByName，等同于http://localhost:9901/producerTest/getByName

            - StripPrefix=1

        - id: '@web.application.name@'

          uri: lb://@web.application.name@

          predicates:

            - Path=/web/**

          filters:

            - StripPrefix=1

    sentinel:

      # 服务启动直接建立心跳连接，饿汉式

      eager: true

      filter:

        # 手动注入Sentinel的过滤器，关闭Sentinel注入CommonFilter实例

        enabled: false

  redis:

    host: localhost

    port: 6379

    # 默认0

    database: 1

    lettuce:

      pool:

        # 连接池最大连接数（使用负值表示没有限制），默认值：8

        max-active: 20

        # 连接池中的最大空闲连接，默认值：8

        max-idle: 10

        # 连接池中的最小空闲连接，默认值：0

        min-idle: 1

        # 连接池最大阻塞等待时间（使用负值表示没有限制），默认值：-1，单位：毫秒

        max-wait: 2000

  profiles:

    # 使用的配置文件后缀application-security.yml。一个或多个，中间英文逗号分开

    active: security

web:

  application:

    name: '@web.application.name@'

package com.xiaostudy.gateway.loadbalancer;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.ObjectProvider;

import org.springframework.cloud.client.ServiceInstance;

import org.springframework.cloud.client.loadbalancer.DefaultResponse;

import org.springframework.cloud.client.loadbalancer.EmptyResponse;

import org.springframework.cloud.client.loadbalancer.Request;

import org.springframework.cloud.client.loadbalancer.Response;

import org.springframework.cloud.loadbalancer.core.NoopServiceInstanceListSupplier;

import org.springframework.cloud.loadbalancer.core.ReactorServiceInstanceLoadBalancer;

import org.springframework.cloud.loadbalancer.core.SelectedInstanceCallback;

import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;

import reactor.core.publisher.Mono;

import java.util.List;

import java.util.Random;

import java.util.concurrent.atomic.AtomicInteger;

// 自定义轮询

public class MyRoundRobinLoadBalancer implements ReactorServiceInstanceLoadBalancer {

    private static final Logger log = LoggerFactory.getLogger(MyRoundRobinLoadBalancer.class);

    final AtomicInteger position;

    final String serviceId;

    ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider;

    /**

     * @param serviceInstanceListSupplierProvider a provider of

     *                                            {@link ServiceInstanceListSupplier} that will be used to get available instances

     * @param serviceId                           id of the service for which to choose an instance

     */

    public MyRoundRobinLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider,

                                    String serviceId) {

        this(serviceInstanceListSupplierProvider, serviceId, new Random().nextInt(1000));

    }

    /**

     * @param serviceInstanceListSupplierProvider a provider of

     *                                            {@link ServiceInstanceListSupplier} that will be used to get available instances

     * @param serviceId                           id of the service for which to choose an instance

     * @param seedPosition                        Round Robin element position marker

     */

    public MyRoundRobinLoadBalancer(ObjectProvider<ServiceInstanceListSupplier> serviceInstanceListSupplierProvider,

                                    String serviceId, int seedPosition) {

        this.serviceId = serviceId;

        this.serviceInstanceListSupplierProvider = serviceInstanceListSupplierProvider;

        this.position = new AtomicInteger(seedPosition);

    }

    @SuppressWarnings("rawtypes")

    @Override

    // see original

    // https://github.com/Netflix/ocelli/blob/master/ocelli-core/

    // src/main/java/netflix/ocelli/loadbalancer/RoundRobinLoadBalancer.java

    public Mono<Response<ServiceInstance>> choose(Request request) {

        ServiceInstanceListSupplier supplier = serviceInstanceListSupplierProvider

                .getIfAvailable(NoopServiceInstanceListSupplier::new);

        return supplier.get(request).next()

                .map(serviceInstances -> processInstanceResponse(supplier, serviceInstances));

    }

    private Response<ServiceInstance> processInstanceResponse(ServiceInstanceListSupplier supplier,

                                                              List<ServiceInstance> serviceInstances) {

        Response<ServiceInstance> serviceInstanceResponse = getInstanceResponse(serviceInstances);

        if (supplier instanceof SelectedInstanceCallback && serviceInstanceResponse.hasServer()) {

            ((SelectedInstanceCallback) supplier).selectedServiceInstance(serviceInstanceResponse.getServer());

        }

        return serviceInstanceResponse;

    }

    private Response<ServiceInstance> getInstanceResponse(List<ServiceInstance> instances) {

        if (instances.isEmpty()) {

            if (log.isWarnEnabled()) {

                log.warn("No servers available for service: " + serviceId);

            }

            return new EmptyResponse();

        }

        // Ignore the sign bit, this allows pos to loop sequentially from 0 to

        // Integer.MAX_VALUE

        int pos = this.position.incrementAndGet() & Integer.MAX_VALUE;

        // TODO 原来的算法

//        int i = pos % instances.size();

        // instances是指某个资源有几个服务，也就是集群数。pos是记录某个资源被访问次数

//        ServiceInstance instance = instances.get(i);

        // TODO 自定义算法，比如指定服务器多处理一次循环

        int i = pos % (instances.size() + 1);

        ServiceInstance instance = null;

        if (i == instances.size()) {

            for (ServiceInstance serviceInstance : instances) {

                if (serviceInstance.getHost().equals("192.168.1.6") && "9906".equals(serviceInstance.getPort())) {

                    instance = serviceInstance;

                }

            }

            if (null == instance) {

                instance = instances.get(i - 1);

            }

        } else {

            // instances是指某个资源有几个服务，也就是集群数。pos是记录某个资源被访问次数

            instance = instances.get(i);

        }

        return new DefaultResponse(instance);

    }

}

package com.xiaostudy.gateway.loadbalancer;

import org.springframework.cloud.client.ServiceInstance;

import org.springframework.cloud.loadbalancer.core.ReactorLoadBalancer;

import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;

import org.springframework.cloud.loadbalancer.support.LoadBalancerClientFactory;

import org.springframework.context.annotation.Bean;

import org.springframework.core.env.Environment;

// 自定义负载策略

public class MyLoadBalancerConfiguration {

    @Bean

    ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment environment,

                                                            LoadBalancerClientFactory loadBalancerClientFactory) {

        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);

//        return new RoundRobinLoadBalancer(loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);

        return new MyRoundRobinLoadBalancer(loadBalancerClientFactory.getLazyProvider(name, ServiceInstanceListSupplier.class), name);

    }

}