@Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { String expectTransportName = findTransportName(context, parent); return parent.children() .computeIfAbsent(expectTransportName, etn -> createDiscoveryTreeNode(expectTransportName, context, parent)); }
public DiscoveryTreeNode discovery(DiscoveryContext context, VersionedCache inputCache) { DiscoveryTreeNode tmpRoot = getOrCreateRoot(inputCache); DiscoveryTreeNode parent = tmpRoot.children() .computeIfAbsent(inputCache.name(), name -> new DiscoveryTreeNode().fromCache(inputCache)); return doDiscovery(context, parent); }
public SimpleLoadBalanceHandler() { discoveryTree.loadFromSPI(DiscoveryFilter.class); discoveryTree.addFilter(new EndpointDiscoveryFilter()); discoveryTree.sort(); }
@Override public List<Server> getInitialListOfServers() { DiscoveryContext context = new DiscoveryContext(); context.setInputParameters(serviceId); VersionedCache serversVersionedCache = discoveryTree.discovery(context, RegistryUtils.getAppId(), serviceId, DefinitionConst.VERSION_RULE_ALL); return serversVersionedCache.data(); }
public <T> List<T> doGetInstances(final String serviceId) { DiscoveryContext context = new DiscoveryContext(); context.setInputParameters(serviceId); DiscoveryTree discoveryTree = discoveryTrees.computeIfAbsent(serviceId, key -> { DiscoveryTree tree = new DiscoveryTree(); tree.addFilter(filter); return tree; }); VersionedCache serversVersionedCache = discoveryTree.discovery(context, RegistryUtils.getAppId(), serviceId, DefinitionConst.VERSION_RULE_ALL); return serversVersionedCache.data(); }
@Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { if (!parent.childrenInited()) { synchronized (parent) { if (!parent.childrenInited()) { init(context, parent); parent.childrenInited(true); } } } String childName = findChildName(context, parent); DiscoveryTreeNode node = parent.child(childName); if (node == null) { LOGGER.warn("discovery filter {} return null.", this.getClass().getName()); return new DiscoveryTreeNode().subName(parent, "empty").data(new HashMap<>()); } return node; }
@Override public void init(DiscoveryContext context, DiscoveryTreeNode parent) { Map<MicroserviceVersionMeta, Map<String, MicroserviceInstance>> versionMap = groupByVersion(context.getInputParameters(), parent.data()); Map<String, DiscoveryTreeNode> operationNodes = initOperationNodes(parent, versionMap); fillInstances(operationNodes, versionMap); parent.children(operationNodes); }
protected DiscoveryTreeNode getOrCreateRoot(VersionedCache inputCache) { DiscoveryTreeNode tmpRoot = root; if (isMatch(tmpRoot, inputCache)) { return tmpRoot; } synchronized (lock) { if (isExpired(root, inputCache)) { // not initialized or inputCache newer than root, create new root root = new DiscoveryTreeNode().cacheVersion(inputCache.cacheVersion()); return root; } if (root.isSameVersion(inputCache)) { // reuse root directly return root; } } // root newer than inputCache, it's a minimal probability event: // 1) thread 1, use v1 inputCache, run into getOrCreateRoot, but did not run any code yet, suspend and switch to thread 2 // 2) thread 2, use v2 inputCache, v2 > v1, create new root // 3) thread 1 go on, then root is newer than inputCache // but if create old children in new version root, it's a wrong logic // so just create a temporary root for the inputCache, DO NOT assign to root return new DiscoveryTreeNode().cacheVersion(inputCache.cacheVersion()); }
@Override public DiscoveryTreeNode discovery(DiscoveryContext context, DiscoveryTreeNode parent) { return parent.children() .computeIfAbsent(context.getInputParameters(), etn -> createDiscoveryTreeNode(context, parent)); }
protected DiscoveryTreeNode doDiscovery(DiscoveryContext context, DiscoveryTreeNode parent) { for (int idx = 0; idx < filters.size(); ) { DiscoveryFilter filter = filters.get(idx); context.setCurrentNode(parent); DiscoveryTreeNode child = filter.discovery(context, parent); if (child == null) { child.level(idx + 1); if (!filter.isGroupingFilter()) { child.name(parent.name()); if (child.isEmpty()) { DiscoveryTreeNode rerunNode = context.popRerunFilter(); if (rerunNode != null) { parent = rerunNode; idx = parent.level(); continue;
public ServiceCombServerList() { discoveryTree.addFilter(new ScbRibbonEndpointDiscoveryFilter()); }
public DiscoveryTreeNode discovery(DiscoveryContext context, String appId, String microserviceName, String versionRule) { VersionedCache instanceVersionedCache = RegistryUtils .getServiceRegistry() .getInstanceCacheManager() .getOrCreateVersionedCache(appId, microserviceName, versionRule); return discovery(context, instanceVersionedCache); }
public DiscoveryTreeNode fromCache(VersionedCache other) { this.cacheVersion = other.cacheVersion(); this.name = other.name(); this.data(other.data()); return this; } }
@Override protected String findChildName(DiscoveryContext context, DiscoveryTreeNode parent) { Invocation invocation = context.getInputParameters(); return invocation.getMicroserviceQualifiedName(); }
@Override protected String findChildName(DiscoveryContext context, DiscoveryTreeNode parent) { String key = context.getContextParameter(KEY_ZONE_AWARE_STEP); if (key == null) { key = GROUP_RegionAndAZMatch; context.pushRerunFilter(); } else if (GROUP_RegionAndAZMatch.equals(key)) { key = GROUP_instancesAZMatch; context.pushRerunFilter(); } else if (GROUP_instancesAZMatch.equals(key)) { key = GROUP_instancesNoMatch; } else { throw new ServiceCombException("not possible happen, maybe a bug."); } context.putContextParameter(KEY_ZONE_AWARE_STEP, key); return key; }
@Override public List<Server> getInitialListOfServers() { DiscoveryContext context = new DiscoveryContext(); context.setInputParameters(serviceId); VersionedCache serversVersionedCache = discoveryTree.discovery(context, RegistryUtils.getAppId(), serviceId, DefinitionConst.VERSION_RULE_ALL); return serversVersionedCache.data(); }
public LoadbalanceHandler() { preCheck(); discoveryTree.loadFromSPI(DiscoveryFilter.class); discoveryTree.addFilter(new ServerDiscoveryFilter()); discoveryTree.sort(); }
public ServiceCombServerList() { discoveryTree.addFilter(new ScbRibbonEndpointDiscoveryFilter()); }
@Override protected String findTransportName(DiscoveryContext context, DiscoveryTreeNode parent) { Invocation invocation = context.getInputParameters(); return invocation.getConfigTransportName(); }
protected LoadBalancer getOrCreateLoadBalancer(Invocation invocation) { DiscoveryContext context = new DiscoveryContext(); context.setInputParameters(invocation); VersionedCache serversVersionedCache = discoveryTree.discovery(context, invocation.getAppId(), invocation.getMicroserviceName(), invocation.getMicroserviceVersionRule()); invocation.addLocalContext(CONTEXT_KEY_SERVER_LIST, serversVersionedCache.data()); return loadBalancerMap .computeIfAbsent(serversVersionedCache.name(), name -> { return createLoadBalancer(invocation.getMicroserviceName()); }); }