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

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