gerrit.onap Code Review - msb/apigateway.git/blob

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