apiroute/apiroute-service/src/main/java/org/onap/msb/apiroute/wrapper/serviceListener/MicroServiceChangeListener.java

   1 package org.onap.msb.apiroute.wrapper.serviceListener;
   2
   3 import java.util.ArrayList;
   4 import java.util.List;
   5 import java.util.Set;
   6
   7 import org.apache.commons.lang3.StringUtils;
   8 import org.onap.msb.apiroute.api.ApiRouteInfo;
   9 import org.onap.msb.apiroute.api.CustomRouteInfo;
  10 import org.onap.msb.apiroute.api.DiscoverInfo;
  11 import org.onap.msb.apiroute.api.IuiRouteInfo;
  12 import org.onap.msb.apiroute.api.MicroServiceFullInfo;
  13 import org.onap.msb.apiroute.api.Node;
  14 import org.onap.msb.apiroute.api.PublishFullAddress;
  15 import org.onap.msb.apiroute.api.RouteServer;
  16 import org.onap.msb.apiroute.wrapper.ApiRouteServiceWrapper;
  17 import org.onap.msb.apiroute.wrapper.CustomRouteServiceWrapper;
  18 import org.onap.msb.apiroute.wrapper.IuiRouteServiceWrapper;
  19 import org.onap.msb.apiroute.wrapper.util.CommonUtil;
  20 import org.onap.msb.apiroute.wrapper.util.ConfigUtil;
  21 import org.onap.msb.apiroute.wrapper.util.HttpClientUtil;
  22 import org.onap.msb.apiroute.wrapper.util.JacksonJsonUtil;
  23 import org.onap.msb.apiroute.wrapper.util.RegExpTestUtil;
  24 import org.onap.msb.apiroute.wrapper.util.RouteUtil;
  25 import org.slf4j.Logger;
  26 import org.slf4j.LoggerFactory;
  27
  28 import com.fasterxml.jackson.core.type.TypeReference;
  29
  30 public class MicroServiceChangeListener implements IMicroServiceChangeListener {
  31
  32   private static final Logger LOGGER = LoggerFactory.getLogger(MicroServiceChangeListener.class);
  33
  34   @Override
  35   public void onDelete(MicroServiceFullInfo microServiceInfo) throws Exception {
  36
  37     String path = microServiceInfo.getPath();
  38
  39     String[] routeWay = ConfigUtil.getInstance().getRouteWay();
  40
  41     for (int i = 0; i < routeWay.length; i++) {
  42
  43       if (StringUtils.isNotBlank(path) && !"/".equals(path)) {
  44         // 1.按path优先判断类型
  45         String host = getHost(microServiceInfo);
  46         deleteServiceByUrl(path, host, microServiceInfo.getPublish_port(), routeWay[i]);
  47       } else {
  48         // 2.1 域名判断url
  49         if (RouteUtil.ROUTEWAY_DOMAIN.equals(routeWay[i]) && ifRootByDomain(microServiceInfo)) {
  50            deleteServiceByDomain4Root(microServiceInfo);
  51         } else {
  52           // 2.2 按协议优先判断类型
  53           deleteServiceByProtocol(microServiceInfo, routeWay[i]);
  54         }
  55
  56       }
  57
  58
  59     }
  60
  61   }
  62
  63
  64   @Override
  65   public void onSave(MicroServiceFullInfo microServiceInfo) throws Exception {
  66
  67     String path = microServiceInfo.getPath();
  68     String[] routeWay = ConfigUtil.getInstance().getRouteWay();
  69
  70     for (int i = 0; i < routeWay.length; i++) {
  71       // 1.按path优先判断类型
  72       if (StringUtils.isNotBlank(path) && !"/".equals(path)) {
  73         saveServiceByPath(microServiceInfo, routeWay[i]);
  74       } else {
  75      // 2.1 域名判断url
  76         if (RouteUtil.ROUTEWAY_DOMAIN.equals(routeWay[i]) && ifRootByDomain(microServiceInfo)) {
  77            saveServiceByDomain4Root(microServiceInfo);
  78         } else {
  79           // 2.2 按协议优先判断类型
  80           saveServiceByProtocol(microServiceInfo, routeWay[i]);
  81         }
  82       }
  83     }
  84
  85   }
  86
  87
  88   //判断按协议发布地址是否和注册的URL一致，如果一致发布地址保存为/，否则保存为协议类型的发布地址
  89   private boolean ifRootByDomain(MicroServiceFullInfo microServiceInfo){
  90
  91
  92     if("/".equals(microServiceInfo.getUrl())) return true;
  93
  94     String protocol = microServiceInfo.getProtocol();
  95     String routeName =
  96         RouteUtil.getRouteNameByns(microServiceInfo.getServiceName(),
  97             microServiceInfo.getNamespace());
  98     String publishUrl="";
  99     String version = "";
 100     if (StringUtils.isNotBlank(microServiceInfo.getVersion())) {
 101       version = "/" + microServiceInfo.getVersion();
 102     }
 103
 104     switch (protocol) {
 105       case RouteUtil.PROTOCOL_UI:
 106         publishUrl = "/iui/" + routeName;
 107         break;
 108       case RouteUtil.PROTOCOL_REST:
 109         publishUrl = "/api/" + routeName + version;
 110         break;
 111       case RouteUtil.PROTOCOL_HTTP:
 112         publishUrl = "/" + routeName + version;
 113         break;
 114     }
 115     return  publishUrl.equals(microServiceInfo.getUrl());
 116
 117   }
 118
 119
 120   private void saveServiceByDomain4Root(MicroServiceFullInfo microServiceInfo) throws Exception {
 121
 122     CustomRouteInfo[] customRouteInfos =
 123         this.buildCustomRouteInfo(microServiceInfo, "/", RouteUtil.ROUTEWAY_DOMAIN);
 124     for (int i = 0; i < customRouteInfos.length; i++) {
 125       customRouteInfos[i].setUrl("/");
 126       CustomRouteServiceWrapper.getInstance().saveCustomRouteInstance(customRouteInfos[i],
 127           RouteUtil.ROUTEWAY_DOMAIN);
 128     }
 129   }
 130
 131   private void deleteServiceByDomain4Root(MicroServiceFullInfo microServiceInfo) throws Exception {
 132
 133     CustomRouteServiceWrapper.getInstance().deleteCustomRoute("/", getHost(microServiceInfo),
 134         microServiceInfo.getPublish_port(),  RouteUtil.ROUTEWAY_DOMAIN);
 135   }
 136
 137   /**
 138    * @Title saveServiceByProtocol
 139    * @Description TODO(按用户注册协议保存服务)
 140    * @param microServiceInfo
 141    * @param routeWay
 142    * @return void
 143    * @throws Exception
 144    */
 145   private void saveServiceByProtocol(MicroServiceFullInfo microServiceInfo, String routeWay)
 146       throws Exception {
 147     String protocol = microServiceInfo.getProtocol();
 148     String routeName =
 149         RouteUtil.getRouteNameByns(microServiceInfo.getServiceName(),
 150             microServiceInfo.getNamespace());
 151
 152     switch (protocol) {
 153       case RouteUtil.PROTOCOL_UI:
 154         IuiRouteInfo[] iuiRouteInfos =
 155             this.buildIuiRouteInfo(microServiceInfo, routeName, routeWay);
 156         for (int i = 0; i < iuiRouteInfos.length; i++) {
 157           IuiRouteServiceWrapper.getInstance().saveIuiRouteInstance(iuiRouteInfos[i], routeWay);
 158         }
 159         break;
 160
 161       case RouteUtil.PROTOCOL_REST:
 162
 163         ApiRouteInfo[] apiRouteInfos =
 164             this.buildApiRouteInfo(microServiceInfo, routeName, microServiceInfo.getVersion(),
 165                 routeWay);
 166         for (int i = 0; i < apiRouteInfos.length; i++) {
 167           ApiRouteServiceWrapper.getInstance().saveApiRouteInstance(apiRouteInfos[i], routeWay);
 168         }
 169         break;
 170       case RouteUtil.PROTOCOL_HTTP:
 171         CustomRouteInfo[] customRouteInfos =
 172             this.buildCustomRouteInfo(microServiceInfo,
 173                 getHttpName(routeName, microServiceInfo.getVersion()), routeWay);
 174         for (int i = 0; i < customRouteInfos.length; i++) {
 175           CustomRouteServiceWrapper.getInstance().saveCustomRouteInstance(customRouteInfos[i],
 176               routeWay);
 177         }
 178         break;
 179     }
 180   }
 181
 182   /**
 183    * @Title deleteServiceByProtocol
 184    * @Description TODO(按用户注册协议删除服务)
 185    * @param microServiceInfo
 186    * @param routeWay
 187    * @return void
 188    */
 189   private void deleteServiceByProtocol(MicroServiceFullInfo microServiceInfo, String routeWay) {
 190     String protocol = microServiceInfo.getProtocol();
 191     String host = getHost(microServiceInfo);
 192     String routeName =
 193         RouteUtil.getRouteNameByns(microServiceInfo.getServiceName(),
 194             microServiceInfo.getNamespace());
 195
 196     if (RouteUtil.PROTOCOL_UI.equals(protocol)) {
 197
 198       if (RouteUtil.ROUTEWAY_IP.equals(routeWay)) {
 199         // two ports
 200         String[] publishPorts = StringUtils.split(microServiceInfo.getPublish_port(), "|");
 201         if (publishPorts.length == 2) {
 202           IuiRouteServiceWrapper.getInstance().deleteIuiRoute(routeName, host, publishPorts[0],
 203               routeWay);
 204           IuiRouteServiceWrapper.getInstance().deleteIuiRoute(routeName, host, publishPorts[1],
 205               routeWay);
 206           return;
 207         }
 208       }
 209
 210       IuiRouteServiceWrapper.getInstance().deleteIuiRoute(routeName, host,
 211           microServiceInfo.getPublish_port(), routeWay);
 212     } else if (RouteUtil.PROTOCOL_REST.equals(protocol)) {
 213
 214       if (RouteUtil.ROUTEWAY_IP.equals(routeWay)) {
 215         // two ports
 216         String[] publishPorts = StringUtils.split(microServiceInfo.getPublish_port(), "|");
 217         if (publishPorts.length == 2) {
 218           ApiRouteServiceWrapper.getInstance().deleteApiRoute(routeName,
 219               microServiceInfo.getVersion(), host, publishPorts[0], routeWay);
 220           ApiRouteServiceWrapper.getInstance().deleteApiRoute(routeName,
 221               microServiceInfo.getVersion(), host, publishPorts[1], routeWay);
 222           return;
 223         }
 224       }
 225       ApiRouteServiceWrapper.getInstance().deleteApiRoute(routeName, microServiceInfo.getVersion(),
 226           host, microServiceInfo.getPublish_port(), routeWay);
 227     } else if (RouteUtil.PROTOCOL_HTTP.equals(protocol)) {
 228
 229       if (RouteUtil.ROUTEWAY_IP.equals(routeWay)) {
 230         // two ports
 231         String[] publishPorts = StringUtils.split(microServiceInfo.getPublish_port(), "|");
 232         if (publishPorts.length == 2) {
 233           CustomRouteServiceWrapper.getInstance().deleteCustomRoute(
 234               getHttpName(routeName, microServiceInfo.getVersion()), host, publishPorts[0],
 235               routeWay);
 236           CustomRouteServiceWrapper.getInstance().deleteCustomRoute(
 237               getHttpName(routeName, microServiceInfo.getVersion()), host, publishPorts[1],
 238               routeWay);
 239           return;
 240         }
 241       }
 242       CustomRouteServiceWrapper.getInstance().deleteCustomRoute(
 243           getHttpName(routeName, microServiceInfo.getVersion()), host,
 244           microServiceInfo.getPublish_port(), routeWay);
 245     }
 246   }
 247
 248   /**
 249    * @Title saveServiceByUrl
 250    * @Description TODO(按URL地址判断服务协议并保存到路由表)
 251    * @param url
 252    * @param microServiceInfo
 253    * @param routeWay
 254    * @return void
 255    * @throws Exception
 256    */
 257   private void saveServiceByPath(MicroServiceFullInfo microServiceInfo, String routeWay)
 258       throws Exception {
 259     String redis_serviceName;
 260     String path=microServiceInfo.getPath();
 261     if (RegExpTestUtil.apiRouteUrlRegExpTest(path)) {
 262       // protocol:"REST"
 263       String[] serviceKey = RegExpTestUtil.apiServiceNameMatch4URL(path);
 264       if (serviceKey == null) {
 265         LOGGER.error("save api Service ByUrl is error:[url]" + path);
 266         return;
 267       }
 268       redis_serviceName = serviceKey[0];
 269       String redis_serviceVersion = serviceKey[1];
 270
 271       ApiRouteInfo[] apiRouteInfos =
 272           this.buildApiRouteInfo(microServiceInfo, redis_serviceName, redis_serviceVersion,
 273               routeWay);
 274       for (int i = 0; i < apiRouteInfos.length; i++) {
 275         ApiRouteServiceWrapper.getInstance().saveApiRouteInstance(apiRouteInfos[i], routeWay);
 276       }
 277     } else if (RegExpTestUtil.iuiRouteUrlRegExpTest(path)) {
 278       // protocol:"UI"
 279       // 根据url获取服务名
 280       redis_serviceName = RegExpTestUtil.iuiServiceNameMatch4URL(path);
 281       if (redis_serviceName == null) {
 282         LOGGER.error("save iui Service ByUrl is error:[url]" + path);
 283         return;
 284       }
 285       IuiRouteInfo[] iuiRouteInfos =
 286           this.buildIuiRouteInfo(microServiceInfo, redis_serviceName, routeWay);
 287       for (int i = 0; i < iuiRouteInfos.length; i++) {
 288         IuiRouteServiceWrapper.getInstance().saveIuiRouteInstance(iuiRouteInfos[i], routeWay);
 289       }
 290     } else {
 291       // protocol:"HTTP";
 292       redis_serviceName = path;
 293       CustomRouteInfo[] customRouteInfos =
 294           this.buildCustomRouteInfo(microServiceInfo, redis_serviceName, routeWay);
 295       for (int i = 0; i < customRouteInfos.length; i++) {
 296         CustomRouteServiceWrapper.getInstance().saveCustomRouteInstance(customRouteInfos[i],
 297             routeWay);
 298       }
 299     }
 300   }
 301
 302   /**
 303    * @Title deleteServiceByUrl
 304    * @Description TODO(按URL地址判断服务协议并从路由表删除)
 305    * @param url
 306    * @param host
 307    * @param publish_port
 308    * @param routeWay
 309    * @return void
 310    */
 311   private void deleteServiceByUrl(String url, String host, String publish_port, String routeWay) {
 312     // 根据Url格式判断服务类型
 313     String redis_serviceName;
 314
 315     if (RegExpTestUtil.apiRouteUrlRegExpTest(url)) {
 316       // protocol:"REST"
 317       String[] serviceKey = RegExpTestUtil.apiServiceNameMatch4URL(url);
 318       if (serviceKey == null) {
 319         LOGGER.error("delete api Service ByUrl is error:[url]" + url);
 320         return;
 321       }
 322
 323       redis_serviceName = serviceKey[0];
 324       String redis_serviceVersion = serviceKey[1];
 325
 326       if (RouteUtil.ROUTEWAY_IP.equals(routeWay)) {
 327         // two ports
 328         String[] publishPorts = StringUtils.split(publish_port, "|");
 329         if (publishPorts.length == 2) {
 330           ApiRouteServiceWrapper.getInstance().deleteApiRoute(redis_serviceName,
 331               redis_serviceVersion, host, publishPorts[0], routeWay);
 332           ApiRouteServiceWrapper.getInstance().deleteApiRoute(redis_serviceName,
 333               redis_serviceVersion, host, publishPorts[1], routeWay);
 334           return;
 335         }
 336       }
 337
 338       ApiRouteServiceWrapper.getInstance().deleteApiRoute(redis_serviceName, redis_serviceVersion,
 339           host, publish_port, routeWay);
 340
 341
 342
 343     } else if (RegExpTestUtil.iuiRouteUrlRegExpTest(url)) {
 344       // protocol:"UI"
 345       // 根据url获取服务名
 346       redis_serviceName = RegExpTestUtil.iuiServiceNameMatch4URL(url);
 347       if (redis_serviceName == null) {
 348         LOGGER.error("delete iui Service ByUrl is error:[url]" + url);
 349         return;
 350       }
 351
 352       if (RouteUtil.ROUTEWAY_IP.equals(routeWay)) {
 353         // two ports
 354         String[] publishPorts = StringUtils.split(publish_port, "|");
 355         if (publishPorts.length == 2) {
 356           IuiRouteServiceWrapper.getInstance().deleteIuiRoute(redis_serviceName, host,
 357               publishPorts[0], routeWay);
 358           IuiRouteServiceWrapper.getInstance().deleteIuiRoute(redis_serviceName, host,
 359               publishPorts[1], routeWay);
 360           return;
 361         }
 362       }
 363
 364       IuiRouteServiceWrapper.getInstance().deleteIuiRoute(redis_serviceName, host, publish_port,
 365           routeWay);
 366
 367
 368     } else {
 369       // protocol:"HTTP";
 370       redis_serviceName = url;
 371
 372       if (RouteUtil.ROUTEWAY_IP.equals(routeWay)) {
 373         // two ports
 374         String[] publishPorts = StringUtils.split(publish_port, "|");
 375         if (publishPorts.length == 2) {
 376           CustomRouteServiceWrapper.getInstance().deleteCustomRoute(redis_serviceName, host,
 377               publishPorts[0], routeWay);
 378           CustomRouteServiceWrapper.getInstance().deleteCustomRoute(redis_serviceName, host,
 379               publishPorts[1], routeWay);
 380           return;
 381         }
 382       }
 383
 384       CustomRouteServiceWrapper.getInstance().deleteCustomRoute(redis_serviceName, host,
 385           publish_port, routeWay);
 386     }
 387
 388   }
 389
 390
 391
 392   /**
 393    * @Title getCustomName
 394    * @Description TODO(获取HTTP服务路由名)
 395    * @param routeName
 396    * @param version
 397    * @return
 398    * @return String
 399    */
 400   private String getHttpName(String routeName, String version) {
 401     if (!routeName.startsWith("/")) {
 402       routeName = "/" + routeName;
 403     }
 404
 405     if (StringUtils.isNotBlank(version)) {
 406       routeName += "/" + version;
 407     }
 408     return routeName;
 409   }
 410
 411
 412   private String getHost(MicroServiceFullInfo microServiceInfo) {
 413     String host;
 414     if (StringUtils.isNotBlank(microServiceInfo.getHost())) {
 415       host = microServiceInfo.getHost().toLowerCase();
 416     } else {
 417       // host为空，取默认规则 服务名-ns
 418       host = microServiceInfo.getServiceName().toLowerCase();
 419     }
 420
 421     return host;
 422   }
 423
 424
 425
 426   @Override
 427   public void onChange(String serviceName, String version, MicroServiceFullInfo microServiceInfo)
 428       throws Exception {
 429     // TODO Auto-generated method stub
 430
 431     if (RouteUtil.PROTOCOL_UI.equals(microServiceInfo.getProtocol())) {
 432       IuiRouteInfo[] iuiRouteInfos =
 433           this.buildIuiRouteInfo(microServiceInfo, serviceName, RouteUtil.ROUTEWAY_IP);
 434       for (int i = 0; i < iuiRouteInfos.length; i++) {
 435         IuiRouteServiceWrapper.getInstance().saveIuiRouteInstance(iuiRouteInfos[i],
 436             RouteUtil.ROUTEWAY_IP);
 437       }
 438     } else if (RouteUtil.PROTOCOL_REST.equals(microServiceInfo.getProtocol())) {
 439       ApiRouteInfo[] apiRouteInfos =
 440           this.buildApiRouteInfo(microServiceInfo, serviceName, version, RouteUtil.ROUTEWAY_IP);
 441       for (int i = 0; i < apiRouteInfos.length; i++) {
 442         ApiRouteServiceWrapper.getInstance().saveApiRouteInstance(apiRouteInfos[i],
 443             RouteUtil.ROUTEWAY_IP);
 444       }
 445     } else if (RouteUtil.PROTOCOL_HTTP.equals(microServiceInfo.getProtocol())) {
 446       if (!serviceName.startsWith("/")) {
 447         serviceName = "/" + serviceName;
 448       }
 449       CustomRouteInfo[] customRouteInfos =
 450           this.buildCustomRouteInfo(microServiceInfo, serviceName, RouteUtil.ROUTEWAY_IP);
 451       for (int i = 0; i < customRouteInfos.length; i++) {
 452         CustomRouteServiceWrapper.getInstance().saveCustomRouteInstance(customRouteInfos[i],
 453             RouteUtil.ROUTEWAY_IP);
 454       }
 455     }
 456   }
 457
 458
 459   @Override
 460   public void onStatusChange(String serviceName, String version, String host, String protocol,
 461       String publish_port, String status) {
 462
 463     // 获取服务的host
 464
 465     if (StringUtils.isBlank(host)) {
 466       host = serviceName.toLowerCase();
 467     }
 468
 469     if (RouteUtil.PROTOCOL_UI.equals(protocol)) {
 470
 471       IuiRouteServiceWrapper.getInstance().updateIuiRouteStatus(serviceName, host, publish_port,
 472           status, RouteUtil.ROUTEWAY_IP);
 473
 474     } else if (RouteUtil.PROTOCOL_REST.equals(protocol)) {
 475       ApiRouteServiceWrapper.getInstance().updateApiRouteStatus(serviceName, version, host,
 476           publish_port, status, RouteUtil.ROUTEWAY_IP);
 477
 478     } else if (RouteUtil.PROTOCOL_HTTP.equals(protocol)) {
 479       if (!serviceName.startsWith("/")) {
 480         serviceName = "/" + serviceName;
 481       }
 482       CustomRouteServiceWrapper.getInstance().updateCustomRouteStatus(serviceName, host,
 483           publish_port, status, RouteUtil.ROUTEWAY_IP);
 484     }
 485
 486
 487   }
 488
 489   private boolean buildRouteHttpProtocol(MicroServiceFullInfo microServiceInfo, String routeWay) {
 490
 491     // Portal协议处理
 492     if (RouteUtil.CUSTOM_PORTAL.equals(microServiceInfo.getCustom())) {
 493       if (RouteUtil.ROUTEWAY_DOMAIN.equals(routeWay)) {
 494         return true;
 495       } else {
 496         return false;
 497       }
 498     }
 499
 500     // 自定义开启SSL处理
 501     return microServiceInfo.isEnable_ssl();
 502
 503   }
 504
 505   private RouteServer[] buildRouteNodes(MicroServiceFullInfo microServiceInfo, String routeWay) {
 506
 507     // 针对custom=portal场景的域名路由使用apigateway发布地址作为node
 508     if (RouteUtil.CUSTOM_PORTAL.equals(microServiceInfo.getCustom())) {
 509       if (RouteUtil.ROUTEWAY_DOMAIN.equals(routeWay)) {
 510
 511         String discoverServiceName =
 512             RouteUtil.getRouteNameByns(microServiceInfo.getServiceName(),
 513                 microServiceInfo.getNamespace());
 514         List<Node> publishNodes =
 515             getPublishNodes(discoverServiceName, microServiceInfo.getVersion(),
 516                 microServiceInfo.getNamespace());
 517         if (publishNodes != null && publishNodes.size() > 0) {
 518           RouteServer[] routeServers = new RouteServer[publishNodes.size()];
 519           int i = 0;
 520           for (Node node : publishNodes) {
 521             RouteServer routeServer = new RouteServer(node.getIp(), node.getPort());
 522             routeServers[i] = routeServer;
 523             i++;
 524           }
 525           return routeServers;
 526         }
 527       }
 528     }
 529
 530
 531     Set<Node> nodes = microServiceInfo.getNodes();
 532     RouteServer[] routeServers = new RouteServer[nodes.size()];
 533     int n = 0;
 534     for (Node node : nodes) {
 535       RouteServer routeServer = new RouteServer(node.getIp(), node.getPort());
 536       routeServers[n] = routeServer;
 537       n++;
 538     }
 539
 540     return routeServers;
 541
 542   }
 543
 544   /**
 545    * From MicroServiceInfo to ApiRouteInfo
 546    *
 547    * @param microServiceInfo
 548    * @return
 549    */
 550   private ApiRouteInfo[] buildApiRouteInfo(MicroServiceFullInfo microServiceInfo,
 551       String redis_serviceName, String redis_version, String routeWay) {
 552
 553     ApiRouteInfo apiRouteInfo = new ApiRouteInfo();
 554     apiRouteInfo.setUrl(microServiceInfo.getUrl());
 555
 556     apiRouteInfo.setServers(buildRouteNodes(microServiceInfo, routeWay));
 557
 558     apiRouteInfo.setVisualRange(RouteUtil.getVisualRangeByRouter(microServiceInfo.getVisualRange()));
 559
 560
 561     if ("ip_hash".equals(microServiceInfo.getLb_policy())) {
 562       apiRouteInfo.setUseOwnUpstream("1");
 563     }
 564
 565     apiRouteInfo.setConsulServiceName(microServiceInfo.getServiceName());
 566     apiRouteInfo.setServiceName(redis_serviceName);
 567     apiRouteInfo.setVersion(redis_version);
 568     apiRouteInfo.setApiJson(microServiceInfo.getUrl() + "/swagger.json");
 569     apiRouteInfo.setMetricsUrl("/admin/metrics");
 570     apiRouteInfo.setEnable_ssl(buildRouteHttpProtocol(microServiceInfo, routeWay));
 571     // 默认 HttpProtocol和PublishProtocol=http
 572     if (apiRouteInfo.isEnable_ssl()) {
 573       apiRouteInfo.setPublishProtocol("https");
 574     }
 575
 576     // 获取服务的host
 577     String host = getHost(microServiceInfo);
 578
 579     apiRouteInfo.setHost(host.toLowerCase());
 580     apiRouteInfo.setNamespace(microServiceInfo.getNamespace());
 581
 582     if (RouteUtil.ROUTEWAY_IP.equals(routeWay)) {
 583
 584       if (StringUtils.isNotBlank(microServiceInfo.getPublish_port())) {
 585         apiRouteInfo.setPublishProtocol("https");
 586       }
 587
 588       // 获取服务的发布端口(支持多端口格式:https|http)
 589       String[] publishPorts = StringUtils.split(microServiceInfo.getPublish_port(), "|");
 590       if (publishPorts.length == 2) {
 591         apiRouteInfo.setPublishProtocol("https");
 592         apiRouteInfo.setPublish_port(publishPorts[0]);
 593
 594         try {
 595           ApiRouteInfo apiRouteInfo_http = (ApiRouteInfo) apiRouteInfo.clone();
 596           apiRouteInfo.setPublishProtocol("http");
 597           apiRouteInfo.setPublish_port(publishPorts[1]);
 598           return new ApiRouteInfo[] {apiRouteInfo, apiRouteInfo_http};
 599         } catch (CloneNotSupportedException e) {
 600           LOGGER.error("CLONE is wrong:" + apiRouteInfo);
 601           return new ApiRouteInfo[] {apiRouteInfo};
 602         }
 603
 604       }
 605     }
 606
 607
 608
 609     apiRouteInfo.setPublish_port(microServiceInfo.getPublish_port());
 610     return new ApiRouteInfo[] {apiRouteInfo};
 611
 612
 613   }
 614
 615
 616   /**
 617    * From MicroServiceInfo to CustomRouteInfo
 618    *
 619    * @param microServiceInfo
 620    * @return
 621    */
 622   private CustomRouteInfo[] buildCustomRouteInfo(MicroServiceFullInfo microServiceInfo,
 623       String redis_serviceName, String routeWay) {
 624
 625     CustomRouteInfo customRouteInfo = new CustomRouteInfo();
 626     customRouteInfo.setUrl(microServiceInfo.getUrl());
 627
 628
 629     customRouteInfo.setServers(buildRouteNodes(microServiceInfo, routeWay));
 630
 631     customRouteInfo.setVisualRange(RouteUtil.getVisualRangeByRouter(microServiceInfo.getVisualRange()));
 632
 633     if ("ip_hash".equals(microServiceInfo.getLb_policy())) {
 634       customRouteInfo.setUseOwnUpstream("1");
 635     }
 636
 637     customRouteInfo.setConsulServiceName(microServiceInfo.getServiceName());
 638     customRouteInfo.setServiceName(redis_serviceName);
 639
 640     // 获取服务的host
 641     String host = getHost(microServiceInfo);
 642
 643     customRouteInfo.setHost(host.toLowerCase());
 644     customRouteInfo.setNamespace(microServiceInfo.getNamespace());
 645     customRouteInfo.setEnable_ssl(buildRouteHttpProtocol(microServiceInfo, routeWay));
 646
 647     if (customRouteInfo.isEnable_ssl()) {
 648       customRouteInfo.setPublishProtocol("https");
 649     }
 650
 651
 652     if (RouteUtil.ROUTEWAY_IP.equals(routeWay)) {
 653       if (StringUtils.isNotBlank(microServiceInfo.getPublish_port())) {
 654         customRouteInfo.setPublishProtocol("https");
 655       }
 656
 657       String[] publishPorts = StringUtils.split(microServiceInfo.getPublish_port(), "|");
 658       if (publishPorts.length == 2) {
 659         // 获取服务的发布端口(支持多端口格式:https|http)
 660         customRouteInfo.setPublishProtocol("https");
 661         customRouteInfo.setPublish_port(publishPorts[0]);
 662
 663         try {
 664           CustomRouteInfo customRouteInfo_http = (CustomRouteInfo) customRouteInfo.clone();
 665           customRouteInfo.setPublishProtocol("http");
 666           customRouteInfo.setPublish_port(publishPorts[1]);
 667           return new CustomRouteInfo[] {customRouteInfo, customRouteInfo_http};
 668         } catch (CloneNotSupportedException e) {
 669           LOGGER.error("CLONE is wrong:" + customRouteInfo);
 670           return new CustomRouteInfo[] {customRouteInfo};
 671         }
 672
 673       }
 674     }
 675
 676
 677     customRouteInfo.setPublish_port(microServiceInfo.getPublish_port());
 678     return new CustomRouteInfo[] {customRouteInfo};
 679   }
 680
 681
 682   /**
 683    * From MicroServiceInfo to IuiRouteInfo
 684    *
 685    * @param microServiceInfo
 686    * @return
 687    */
 688   private IuiRouteInfo[] buildIuiRouteInfo(MicroServiceFullInfo microServiceInfo,
 689       String redis_serviceName, String routeWay) {
 690
 691     IuiRouteInfo iuiRouteInfo = new IuiRouteInfo();
 692     iuiRouteInfo.setUrl(microServiceInfo.getUrl());
 693
 694     iuiRouteInfo.setServers(buildRouteNodes(microServiceInfo, routeWay));
 695
 696     iuiRouteInfo.setVisualRange(RouteUtil.getVisualRangeByRouter(microServiceInfo.getVisualRange()));
 697
 698     if ("ip_hash".equals(microServiceInfo.getLb_policy())) {
 699       iuiRouteInfo.setUseOwnUpstream("1");
 700     }
 701
 702
 703     iuiRouteInfo.setConsulServiceName(microServiceInfo.getServiceName());
 704     iuiRouteInfo.setServiceName(redis_serviceName);
 705
 706     // 获取服务的host
 707     String host = getHost(microServiceInfo);
 708
 709     iuiRouteInfo.setHost(host.toLowerCase());
 710     iuiRouteInfo.setNamespace(microServiceInfo.getNamespace());
 711     iuiRouteInfo.setEnable_ssl(buildRouteHttpProtocol(microServiceInfo, routeWay));
 712     if (iuiRouteInfo.isEnable_ssl()) {
 713       iuiRouteInfo.setPublishProtocol("https");
 714     }
 715
 716     if (RouteUtil.ROUTEWAY_IP.equals(routeWay)) {
 717
 718       if (StringUtils.isNotBlank(microServiceInfo.getPublish_port())) {
 719         iuiRouteInfo.setPublishProtocol("https");
 720       }
 721
 722       String[] publishPorts = StringUtils.split(microServiceInfo.getPublish_port(), "|");
 723       if (publishPorts.length == 2) {
 724         // 获取服务的发布端口(支持多端口格式:https|http)
 725         iuiRouteInfo.setPublishProtocol("https");
 726         iuiRouteInfo.setPublish_port(publishPorts[0]);
 727
 728         try {
 729           IuiRouteInfo iuiRouteInfo_http = (IuiRouteInfo) iuiRouteInfo.clone();
 730           iuiRouteInfo.setPublishProtocol("http");
 731           iuiRouteInfo.setPublish_port(publishPorts[1]);
 732           return new IuiRouteInfo[] {iuiRouteInfo, iuiRouteInfo_http};
 733         } catch (CloneNotSupportedException e) {
 734           LOGGER.error("CLONE is wrong:" + iuiRouteInfo);
 735           return new IuiRouteInfo[] {iuiRouteInfo};
 736         }
 737
 738       }
 739     }
 740     iuiRouteInfo.setPublish_port(microServiceInfo.getPublish_port());
 741     return new IuiRouteInfo[] {iuiRouteInfo};
 742   }
 743
 744
 745
 746   private List<Node> getPublishNodes(String discoverServiceName, String version, String namespace) {
 747     List<Node> nodes = new ArrayList<Node>();
 748
 749     if (StringUtils.isBlank(version)) {
 750       version = "null";
 751     }
 752
 753     DiscoverInfo discoverInfo = ConfigUtil.getInstance().getDiscoverInfo();
 754
 755     String allpublishaddressUrl =
 756         (new StringBuilder().append("http://").append(discoverInfo.toString())
 757             .append(RouteUtil.MSB_ROUTE_URL).append("/").append(discoverServiceName)
 758             .append("/version/").append(version).append("/allpublishaddress?namespace=")
 759             .append(namespace).append("&visualRange=0")).toString();
 760
 761     String resultJson = HttpClientUtil.httpGet(allpublishaddressUrl);
 762     List<PublishFullAddress> publishFullAddressList =
 763         JacksonJsonUtil
 764             .jsonToListBean(resultJson, new TypeReference<List<PublishFullAddress>>() {});
 765     if (publishFullAddressList != null && publishFullAddressList.size() > 0) {
 766       for (PublishFullAddress publishFullAddress : publishFullAddressList) {
 767         if (StringUtils.isNotBlank(publishFullAddress.getIp())
 768             && "https".equals(publishFullAddress.getPublish_protocol())) {
 769           nodes.add(new Node(publishFullAddress.getIp(), publishFullAddress.getPort()));
 770         }
 771
 772       }
 773     }
 774
 775     return nodes;
 776   }
 777
 778
 779 }