io.servicecomb.core.endpoint.AbstractEndpointsCache Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2017 Huawei Technologies Co., Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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 io.servicecomb.core.endpoint;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.springframework.util.StringUtils;

import io.servicecomb.core.Transport;
import io.servicecomb.core.transport.TransportManager;
import io.servicecomb.serviceregistry.cache.CacheEndpoint;
import io.servicecomb.serviceregistry.cache.InstanceCache;
import io.servicecomb.serviceregistry.cache.InstanceCacheManager;

/**
 * registry模块不理解core中的概念
 * 所以要将字符串的各种信息转义一下，方便运行时使用
 */
public abstract class AbstractEndpointsCache {
  protected static InstanceCacheManager instanceCacheManager;

  protected static TransportManager transportManager;

  protected List endpoints = new ArrayList<>();

  protected String transportName;

  protected InstanceCache instanceCache = null;

  public static void init(InstanceCacheManager instanceCacheManager, TransportManager transportManager) {
    AbstractEndpointsCache.instanceCacheManager = instanceCacheManager;
    AbstractEndpointsCache.transportManager = transportManager;
  }

  /**
   * transportName 可能为""，表示走任意健康的地址即可
   */
  public AbstractEndpointsCache(String appId, String microserviceName, String microserviceVersionRule,
      String transportName) {
    this.transportName = transportName;
    this.instanceCache = new InstanceCache(appId, microserviceName, microserviceVersionRule, null);
  }

  public List getLatestEndpoints() {
    InstanceCache newCache = instanceCacheManager.getOrCreate(instanceCache.getAppId(),
        instanceCache.getMicroserviceName(),
        instanceCache.getMicroserviceVersionRule());
    if (!instanceCache.cacheChanged(newCache)) {
      return endpoints;
    }

    // 走到这里，肯定已经是存在"有效"地址了(可能是个空列表，表示没有存活的实例)
    // 先创建，成功了，再走下面的更新逻辑
    List tmpEndpoints = createEndpints(newCache);

    this.instanceCache = newCache;
    this.endpoints = tmpEndpoints;
    return endpoints;
  }

  protected List createEndpints(InstanceCache newCache) {
    Map> transportMap = getOrCreateTransportMap(newCache);

    return createEndpoints(transportMap);
  }

  protected List createEndpoints(Map> transportMap) {
    List tmpEndpoints = new ArrayList<>();
    for (Entry> entry : transportMap.entrySet()) {
      Transport transport = transportManager.findTransport(entry.getKey());
      if (transport == null) {
        continue;
      }

      List endpointList = entry.getValue();
      if (endpointList == null) {
        continue;
      }

      for (CacheEndpoint cacheEndpont : endpointList) {
        ENDPOINT endpoint = createEndpoint(transport, cacheEndpont);
        tmpEndpoints.add(endpoint);
      }
    }
    return tmpEndpoints;
  }

  private Map> getOrCreateTransportMap(InstanceCache newCache) {
    Map> allTransportMap = newCache.getOrCreateTransportMap();
    if (StringUtils.isEmpty(transportName)) {
      // 未指定tranport，将所有transport全取出来
      return allTransportMap;
    }

    Map> transportMap = new HashMap<>();
    transportMap.put(transportName, allTransportMap.get(transportName));
    return transportMap;
  }

  protected abstract ENDPOINT createEndpoint(Transport transport, CacheEndpoint cacheEndpoint);
}