merge 1.8.2-Hoxton.SR12 (#708)

pull/711/head
lepdou 2 years ago committed by GitHub
parent c7d37d6e58
commit e37de52366
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

@ -70,7 +70,7 @@ Spring Cloud Tencent 所有组件都已上传到 Maven 中央仓库,只需要
<groupId>com.tencent.cloud</groupId>
<artifactId>spring-cloud-tencent-dependencies</artifactId>
<!--version number-->
<version>1.8.1-Hoxton.SR12</version>
<version>1.8.2-Hoxton.SR12</version>
<type>pom</type>
<scope>import</scope>
</dependency>

@ -72,7 +72,7 @@ For example:
<groupId>com.tencent.cloud</groupId>
<artifactId>spring-cloud-tencent-dependencies</artifactId>
<!--version number-->
<version>1.8.1-Hoxton.SR12</version>
<version>1.8.2-Hoxton.SR12</version>
<type>pom</type>
<scope>import</scope>
</dependency>

@ -0,0 +1,6 @@
# Change Log
---
- [fix router concurrent bug&fix spring-retry circuit breaker not work bug](https://github.com/Tencent/spring-cloud-tencent/pull/679)
- [fix router unit test](https://github.com/Tencent/spring-cloud-tencent/pull/684)
- [fix weight load balancer bug](https://github.com/Tencent/spring-cloud-tencent/pull/704)

@ -20,6 +20,7 @@ package com.tencent.cloud.polaris.router;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
@ -37,6 +38,7 @@ import com.tencent.cloud.common.metadata.MetadataContext;
import com.tencent.cloud.common.pojo.PolarisServer;
import com.tencent.cloud.common.util.JacksonUtils;
import com.tencent.cloud.polaris.loadbalancer.LoadBalancerUtils;
import com.tencent.cloud.polaris.loadbalancer.PolarisLoadBalancer;
import com.tencent.cloud.polaris.loadbalancer.PolarisWeightedRule;
import com.tencent.cloud.polaris.loadbalancer.config.PolarisLoadBalancerProperties;
import com.tencent.cloud.polaris.router.spi.RouterRequestInterceptor;
@ -84,6 +86,8 @@ public class PolarisLoadBalancerCompositeRule extends AbstractLoadBalancerRule {
private final AbstractLoadBalancerRule delegateRule;
private final AtomicBoolean initializedLoadBalancerToDelegateRule = new AtomicBoolean(false);
public PolarisLoadBalancerCompositeRule(RouterAPI routerAPI,
PolarisLoadBalancerProperties polarisLoadBalancerProperties,
IClientConfig iClientConfig,
@ -111,22 +115,31 @@ public class PolarisLoadBalancerCompositeRule extends AbstractLoadBalancerRule {
@Override
public Server choose(Object key) {
// 1. get all servers
List<Server> allServers = getLoadBalancer().getReachableServers();
ILoadBalancer loadBalancer = getLoadBalancer();
if (!(loadBalancer instanceof PolarisLoadBalancer)) {
return loadBalancer.chooseServer(key);
}
// set load balancer to delegate rule
if (initializedLoadBalancerToDelegateRule.compareAndSet(false, true)) {
delegateRule.setLoadBalancer(loadBalancer);
}
PolarisLoadBalancer polarisLoadBalancer = (PolarisLoadBalancer) loadBalancer;
// 1. get all servers from polaris client
List<Server> allServers = polarisLoadBalancer.getReachableServersWithoutCache();
if (CollectionUtils.isEmpty(allServers)) {
return null;
}
ILoadBalancer loadBalancer = new SimpleLoadBalancer();
// 2. filter by router
List<Server> serversAfterRouter;
if (key instanceof PolarisRouterContext) {
// router implement for Feign and scg
PolarisRouterContext routerContext = (PolarisRouterContext) key;
List<Server> serversAfterRouter = doRouter(allServers, routerContext);
// 3. filter by load balance.
// A LoadBalancer needs to be regenerated for each request,
// because the list of servers may be different after filtered by router
loadBalancer.addServers(serversAfterRouter);
serversAfterRouter = doRouter(allServers, routerContext);
}
else if (key instanceof HttpRequest) {
// router implement for rest template
@ -135,20 +148,20 @@ public class PolarisLoadBalancerCompositeRule extends AbstractLoadBalancerRule {
String routerContextStr = request.getHeaders().getFirst(RouterConstant.HEADER_ROUTER_CONTEXT);
if (StringUtils.isEmpty(routerContextStr)) {
loadBalancer.addServers(allServers);
serversAfterRouter = allServers;
}
else {
PolarisRouterContext routerContext = JacksonUtils.deserialize(UriEncoder.decode(routerContextStr),
PolarisRouterContext.class);
List<Server> serversAfterRouter = doRouter(allServers, routerContext);
loadBalancer.addServers(serversAfterRouter);
serversAfterRouter = doRouter(allServers, routerContext);
}
}
else {
loadBalancer.addServers(allServers);
serversAfterRouter = allServers;
}
delegateRule.setLoadBalancer(loadBalancer);
// 3. put filtered servers to thread local, so delegate rule choose servers from filtered servers.
polarisLoadBalancer.addServers(serversAfterRouter);
return delegateRule.choose(key);
}

@ -1,72 +0,0 @@
/*
* Tencent is pleased to support the open source community by making Spring Cloud Tencent available.
*
* Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved.
*
* Licensed under the BSD 3-Clause License (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://opensource.org/licenses/BSD-3-Clause
*
* Unless required by applicable law or agreed to in writing, software distributed
* under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*
*/
package com.tencent.cloud.polaris.router;
import java.util.LinkedList;
import java.util.List;
import com.netflix.loadbalancer.Server;
import org.junit.Assert;
import org.junit.Test;
import org.mockito.Mockito;
/**
* test for {@link SimpleLoadBalancer}.
*
* @author lepdou 2022-05-26
*/
public class SimpleLoadBalancerTest {
@Test
public void testSetterGetter() {
List<Server> servers = new LinkedList<>();
servers.add(Mockito.mock(Server.class));
servers.add(Mockito.mock(Server.class));
servers.add(Mockito.mock(Server.class));
servers.add(Mockito.mock(Server.class));
servers.add(Mockito.mock(Server.class));
SimpleLoadBalancer simpleLoadBalancer = new SimpleLoadBalancer();
simpleLoadBalancer.addServers(servers);
List<Server> allServers = simpleLoadBalancer.getAllServers();
List<Server> reachableServers = simpleLoadBalancer.getReachableServers();
List<Server> availableServers = simpleLoadBalancer.getServerList(true);
Assert.assertEquals(servers.size(), allServers.size());
Assert.assertEquals(servers.size(), reachableServers.size());
Assert.assertEquals(servers.size(), availableServers.size());
}
@Test
public void testSetNull() {
SimpleLoadBalancer simpleLoadBalancer = new SimpleLoadBalancer();
simpleLoadBalancer.addServers(null);
List<Server> allServers = simpleLoadBalancer.getAllServers();
List<Server> reachableServers = simpleLoadBalancer.getReachableServers();
List<Server> availableServers = simpleLoadBalancer.getServerList(true);
Assert.assertEquals(0, allServers.size());
Assert.assertEquals(0, reachableServers.size());
Assert.assertEquals(0, availableServers.size());
}
}

@ -20,7 +20,6 @@ package com.tencent.cloud.polaris.router.feign;
import com.netflix.client.config.DefaultClientConfigImpl;
import com.netflix.loadbalancer.ILoadBalancer;
import com.tencent.cloud.polaris.router.SimpleLoadBalancer;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;

@ -32,7 +32,6 @@ import com.tencent.cloud.common.metadata.MetadataContextHolder;
import com.tencent.cloud.common.util.ApplicationContextAwareUtils;
import com.tencent.cloud.common.util.JacksonUtils;
import com.tencent.cloud.polaris.router.PolarisRouterContext;
import com.tencent.cloud.polaris.router.SimpleLoadBalancer;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;

@ -13,10 +13,9 @@
* under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*
*/
package com.tencent.cloud.polaris.router;
package com.tencent.cloud.polaris.router.feign;
import java.util.Collections;
import java.util.List;

@ -14,6 +14,12 @@ spring:
enabled: true
loadbalancer:
enabled: true
loadbalancer:
retry:
retry-on-all-operations: true
max-retries-on-same-service-instance: 0
max-retries-on-next-service-instance: 3
# strategy: polarisWeighted
management:
endpoints:
web:

@ -52,6 +52,7 @@ import org.springframework.util.CollectionUtils;
* @author Haotian Zhang
*/
public class PolarisLoadBalancer extends DynamicServerListLoadBalancer<Server> {
private static final ThreadLocal<List<Server>> THREAD_CACHE_SERVERS = new ThreadLocal<>();
private final ConsumerAPI consumerAPI;
@ -64,8 +65,21 @@ public class PolarisLoadBalancer extends DynamicServerListLoadBalancer<Server> {
this.polarisLoadBalancerProperties = properties;
}
@Override
public void addServers(List<Server> servers) {
THREAD_CACHE_SERVERS.set(servers);
}
@Override
public List<Server> getReachableServers() {
// Get servers first from the thread context
if (!CollectionUtils.isEmpty(THREAD_CACHE_SERVERS.get())) {
return THREAD_CACHE_SERVERS.get();
}
return getReachableServersWithoutCache();
}
public List<Server> getReachableServersWithoutCache() {
ServiceInstances serviceInstances;
if (polarisLoadBalancerProperties.getDiscoveryType().equals(ContextConstant.POLARIS)) {
serviceInstances = getPolarisDiscoveryServiceInstances();

@ -21,7 +21,10 @@ package com.tencent.cloud.polaris.loadbalancer;
import java.util.List;
import com.netflix.client.config.IClientConfig;
import com.netflix.loadbalancer.AbstractLoadBalancerRule;
import com.netflix.loadbalancer.AbstractServerPredicate;
import com.netflix.loadbalancer.AvailabilityPredicate;
import com.netflix.loadbalancer.CompositePredicate;
import com.netflix.loadbalancer.PredicateBasedRule;
import com.netflix.loadbalancer.Server;
import com.tencent.cloud.common.pojo.PolarisServer;
import com.tencent.polaris.api.config.consumer.LoadBalanceConfig;
@ -38,9 +41,10 @@ import org.springframework.util.CollectionUtils;
*
* @author lepdou 2022-05-17
*/
public class PolarisWeightedRule extends AbstractLoadBalancerRule {
public class PolarisWeightedRule extends PredicateBasedRule {
private final RouterAPI routerAPI;
private CompositePredicate compositePredicate;
public PolarisWeightedRule(RouterAPI routerAPI) {
this.routerAPI = routerAPI;
@ -48,6 +52,13 @@ public class PolarisWeightedRule extends AbstractLoadBalancerRule {
@Override
public void initWithNiwsConfig(IClientConfig clientConfig) {
AvailabilityPredicate availabilityPredicate = new AvailabilityPredicate(this, clientConfig);
compositePredicate = CompositePredicate.withPredicates(availabilityPredicate).build();
}
@Override
public AbstractServerPredicate getPredicate() {
return compositePredicate;
}
@Override
@ -57,6 +68,9 @@ public class PolarisWeightedRule extends AbstractLoadBalancerRule {
return null;
}
// filter circuit breaker servers by ribbon
servers = compositePredicate.getEligibleServers(servers);
ServiceInstances serviceInstances = LoadBalancerUtils.transferServersToServiceInstances(servers);
ProcessLoadBalanceRequest request = new ProcessLoadBalanceRequest();

@ -80,6 +80,7 @@ public class PolarisLoadBalancerTest {
//mock routerAPI for rule
when(routerAPI.processLoadBalance(any())).thenReturn(assembleProcessLoadBalanceResp());
PolarisWeightedRule rule = new PolarisWeightedRule(routerAPI);
rule.initWithNiwsConfig(new DefaultClientConfigImpl());
// clientConfig
IClientConfig config = new DefaultClientConfigImpl();
@ -111,6 +112,7 @@ public class PolarisLoadBalancerTest {
//mock routerAPI for rule
when(routerAPI.processLoadBalance(any())).thenReturn(assembleProcessLoadBalanceResp());
PolarisWeightedRule rule = new PolarisWeightedRule(routerAPI);
rule.initWithNiwsConfig(new DefaultClientConfigImpl());
// clientConfig
IClientConfig config = new DefaultClientConfigImpl();

Loading…
Cancel
Save