com.netflix.loadbalancer.PredicateKey Java Examples

/**
 * {@inheritDoc}
 */
@Override
protected boolean doApply(PredicateKey input) {
    Server server = input.getServer();
    String expected = current().get(zoneEntryKey);
    String actual = server.getZone();
    boolean accept = expected != null && expected.equals(actual);
    log.trace("Expected [{}={}] vs {}:{}[zone={}] => {}",
            zoneEntryKey,
            expected,
            server.getHostPort(),
            server.getMetaInfo().getAppName(),
            actual,
            accept);
    return accept;
}
 

@Override
public boolean apply(PredicateKey input) {

    GrayLoadBalanceRule grayRule = getIRule();
    GrayRequest grayRequest = grayRule.getRequestLocalStorage().getGrayRequest();

    Server server = input.getServer();
    String serviceId = grayRequest.getServiceId();
    String instanceId = server.getMetaInfo().getInstanceId();
    try {
        ServerSpec serverSpec = grayRule.getServerExplainer().apply(server);

        GrayDecisionInputArgs decisionInputArgs = GrayDecisionInputArgs
                .builder().grayRequest(grayRequest).server(serverSpec).build();

        List<GrayDecision> grayDecisions = grayRule.getGrayManager().getGrayDecision(serviceId, instanceId);

        for (GrayDecision grayDecision : grayDecisions) {
            if (grayDecision.test(decisionInputArgs)) {
                return true;
            }
        }
    }catch (Exception e){
        log.error("", e);
    }
    return false;
}
 

/**
 * {@inheritDoc}
 */
@Override
public boolean apply(@Nullable PredicateKey input) {
    return input != null
            && input.getServer() instanceof DiscoveryEnabledServer
            && apply((DiscoveryEnabledServer) input.getServer());
}
 

@Override
public boolean apply(PredicateKey input) {
	if(!DiscoveryEnabledServer.class.isInstance(input.getServer())){
		return false;
	}
	DiscoveryEnabledServer server = (DiscoveryEnabledServer) input.getServer();
	Map<String, String> metaData = server.getInstanceInfo().getMetadata();
	return matchMetaData(metaData);
}
 

@Override
public boolean apply(PredicateKey input) {
	if(!DiscoveryEnabledServer.class.isInstance(input.getServer())){
		return false;
	}
	DiscoveryEnabledServer server = (DiscoveryEnabledServer) input.getServer();
	Map<String, String> metaData = server.getInstanceInfo().getMetadata();
	return matchMetaData(metaData);
}
 

/**
 * {@inheritDoc}
 */
@Override
@SuppressFBWarnings("BC_UNCONFIRMED_CAST_OF_RETURN_VALUE")
protected boolean doApply(PredicateKey input) {
    return input.getServer() instanceof DiscoveryEnabledServer
            && doApply((DiscoveryEnabledServer) input.getServer());
}
 

/**
 * {@inheritDoc}
 */
@Override
protected boolean doApply(PredicateKey server) {
    boolean accept = zone.equals(server.getServer().getZone());
    log.trace("Expected zone [{}] vs {}:{}[{}] => {}",
            zone,
            server.getServer().getHostPort(),
            server.getServer().getMetaInfo().getAppName(),
            server.getServer().getZone(),
            accept);
    return accept;
}
 

@Override
public AbstractServerPredicate getPredicate() {
    return new AbstractServerPredicate() {
        @Override
        public boolean apply(PredicateKey predicateKey) {
            String targetVersion = RibbonVersionHolder.getContext();
            RibbonVersionHolder.clearContext();
            if (StrUtil.isBlank(targetVersion)) {
                log.debug("客户端未配置目标版本直接路由");
                return true;
            }

            DiscoveryEnabledServer server = (DiscoveryEnabledServer) predicateKey.getServer();
            final Map<String, String> metadata = server.getInstanceInfo().getMetadata();
            if (StrUtil.isBlank(metadata.get(SecurityConstants.VERSION))) {
                log.debug("当前微服务{} 未配置版本直接路由");
                return true;
            }

            if (metadata.get(SecurityConstants.VERSION).equals(targetVersion)) {
                return true;
            } else {
                log.debug("当前微服务{} 版本为{}，目标版本{} 匹配失败", server.getInstanceInfo().getAppName()
                        , metadata.get(SecurityConstants.VERSION), targetVersion);
                return false;
            }
        }
    };
}
 

/**
 * {@inheritDoc}
 */
@Override
public final boolean apply(@Nullable PredicateKey input) {
    return input != null && input.getServer() != null && doApply(input);
}
 

@Test
public void should_not_filter_when_null_server() throws Exception {
    when(predicate.doApply(any())).thenReturn(true);
    assertThat(predicate.apply(new PredicateKey(null)), is(false));
}
 

@Test
public void should_filter_when_delegate_filter() throws Exception {
    when(predicate.doApply(any())).thenReturn(false);
    assertThat(predicate.apply(new PredicateKey(server)), is(false));
}
 

@Test
public void should_filter_non_discovery_server() throws Exception {
    when(predicate.doApply(any(DiscoveryEnabledServer.class))).thenReturn(true);
    assertThat(predicate.apply(new PredicateKey(server)), is(false));
}
 

@Test
public void should_not_filter_when_discovery_server() throws Exception {
    when(predicate.doApply(any(DiscoveryEnabledServer.class))).thenReturn(true);
    assertThat(predicate.apply(new PredicateKey(discoveryEnabledServer)), is(true));
}
 

@Test
public void should_filter_when_discovery_server() throws Exception {
    when(predicate.doApply(any(DiscoveryEnabledServer.class))).thenReturn(false);
    assertThat(predicate.apply(new PredicateKey(discoveryEnabledServer)), is(false));
}
 

@Override
public boolean apply(@Nullable PredicateKey input) {
    return input != null
            && input.getServer() instanceof NacosServer
            && apply((NacosServer) input.getServer());
}
 

/**
 * Tests if {@link DiscoveryEnabledServer} matches this predicate.
 *
 * @param input the current server
 * @return {@code true} if the server matches the predicate otherwise {@code false}
 * @see #apply(PredicateKey)
 */
protected abstract boolean doApply(PredicateKey input);
 

PredicateKey getPredicateKey();