msb-core/apiroute/apiroute-service/src/main/java/org/openo/msb/wrapper/MicroServiceWrapper.java

   1 /**\r
   2 * Copyright (C) 2016 ZTE, Inc. and others. All rights reserved. (ZTE)\r
   3 *\r
   4 * Licensed under the Apache License, Version 2.0 (the "License");\r
   5 * you may not use this file except in compliance with the License.\r
   6 * You may obtain a copy of the License at\r
   7 *\r
   8 * http://www.apache.org/licenses/LICENSE-2.0\r
   9 *\r
  10 * Unless required by applicable law or agreed to in writing, software\r
  11 * distributed under the License is distributed on an "AS IS" BASIS,\r
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  13 * See the License for the specific language governing permissions and\r
  14 * limitations under the License.\r
  15 */\r
  16 \r
  17 package org.openo.msb.wrapper;\r
  18 \r
  19 import java.util.Set;\r
  20 \r
  21 import org.apache.commons.lang3.StringUtils;\r
  22 import org.openo.msb.api.MicroServiceFullInfo;\r
  23 import org.openo.msb.api.MicroServiceInfo;\r
  24 import org.openo.msb.api.Node;\r
  25 import org.openo.msb.api.NodeInfo;\r
  26 import org.openo.msb.api.exception.ExtendedInternalServerErrorException;\r
  27 import org.openo.msb.api.exception.ExtendedNotFoundException;\r
  28 import org.openo.msb.api.exception.ExtendedNotSupportedException;\r
  29 import org.openo.msb.wrapper.util.MicroServiceDB;\r
  30 import org.openo.msb.wrapper.util.RegExpTestUtil;\r
  31 import org.openo.msb.wrapper.util.RouteUtil;\r
  32 import org.slf4j.Logger;\r
  33 import org.slf4j.LoggerFactory;\r
  34 \r
  35 public class MicroServiceWrapper {\r
  36 \r
  37     private static final Logger LOGGER = LoggerFactory.getLogger(MicroServiceWrapper.class);\r
  38 \r
  39     private static MicroServiceWrapper instance = new MicroServiceWrapper();\r
  40 \r
  41 \r
  42     private MicroServiceWrapper() {}\r
  43 \r
  44     public static MicroServiceWrapper getInstance() {\r
  45         return instance;\r
  46     }\r
  47 \r
  48 \r
  49     /**\r
  50      * @Title: getAllMicroServiceInstances\r
  51      * @Description: getAllMicroServiceInstances\r
  52      * @param: @return\r
  53      * @return: Response\r
  54      * @throws Exception\r
  55      */\r
  56     public MicroServiceFullInfo[] getAllMicroServiceInstances(){\r
  57 \r
  58         try {\r
  59             return MicroServiceDB.getInstance().getAllMicroServiceInstances();\r
  60 \r
  61         } catch (Exception e) {\r
  62             throw new ExtendedInternalServerErrorException(e.getMessage());\r
  63         }\r
  64 \r
  65     }\r
  66 \r
  67     /**\r
  68      * @Title: getMicroServiceInstance\r
  69      * @Description: (getMicroServiceInstance)\r
  70      * @param: @param serviceName\r
  71      * @param: @param version\r
  72      * @param: @return\r
  73      * @return: ApiRouteInfo\r
  74      */\r
  75     public MicroServiceFullInfo getMicroServiceInstance(String serviceName, String version,String serverPort) {\r
  76         if("null".equals(version)) {\r
  77             version="";\r
  78         }\r
  79         serviceName=serviceName.replace("*", "/");\r
  80         \r
  81         if (StringUtils.isBlank(serviceName)) {\r
  82             throw new ExtendedNotSupportedException("serviceName  can't be empty");\r
  83         }\r
  84 \r
  85         if (StringUtils.isNotBlank(version)) {\r
  86             if (!RegExpTestUtil.versionRegExpTest(version)) {\r
  87                 throw new ExtendedNotSupportedException("version (" + version\r
  88                         + ") is not a valid  format");\r
  89             }\r
  90         }\r
  91 \r
  92         MicroServiceFullInfo microServiceInfo;\r
  93         try {\r
  94             microServiceInfo =\r
  95                     MicroServiceDB.getInstance().getMicroServiceInstance(serviceName, version,serverPort);\r
  96 \r
  97         } catch (Exception e) {\r
  98             throw new ExtendedInternalServerErrorException(e.getMessage());\r
  99         }\r
 100 \r
 101         if (null == microServiceInfo) {\r
 102             String errInfo =\r
 103                     "microservice not found: serviceName-" + serviceName + ",version-" + version;\r
 104             LOGGER.warn(errInfo);\r
 105             throw new ExtendedNotFoundException(errInfo);\r
 106 \r
 107         }\r
 108 \r
 109         return microServiceInfo;\r
 110     }\r
 111 \r
 112 \r
 113 \r
 114     /**\r
 115      * @Title: updateMicroServiceInstance\r
 116      * @Description: updateMicroServiceInstance\r
 117      * @param: serviceName\r
 118      * @param: version\r
 119      * @param: microServiceInfo\r
 120      * @return: RouteResult\r
 121      */\r
 122     public synchronized MicroServiceFullInfo updateMicroServiceInstance(String serviceName,\r
 123             String version, MicroServiceInfo microServiceInfo) {\r
 124         if("null".equals(version)) {\r
 125             version="";\r
 126         }\r
 127         serviceName=serviceName.replace("*", "/");\r
 128 \r
 129         try {\r
 130        \r
 131             \r
 132             MicroServiceFullInfo oldService= getMicroServiceInstance(serviceName,version,"");\r
 133 \r
 134             // Delete the original record\r
 135             MicroServiceDB.getInstance().deleteMicroService(serviceName, version,"");\r
 136             // Notify the listeners\r
 137             MicroServiceDB.getInstance().noticeApiListener(oldService, "DELETE","");\r
 138             // Save the new record\r
 139             MicroServiceDB.getInstance().saveMicroServiceInfo2Redis(microServiceInfo,"");\r
 140           \r
 141             MicroServiceDB.getInstance().noticeApiListener(microServiceInfo, "ADD","");\r
 142             MicroServiceFullInfo newMicroServiceInfo =\r
 143                     MicroServiceDB.getInstance().getMicroServiceInstance(\r
 144                             microServiceInfo.getServiceName(), microServiceInfo.getVersion(),"");\r
 145             return newMicroServiceInfo;\r
 146         } catch (Exception e) {\r
 147             LOGGER.error("update MicroService throw exception", e);\r
 148             throw new ExtendedInternalServerErrorException(e.getMessage());\r
 149         }\r
 150 \r
 151 \r
 152     }\r
 153 \r
 154     public synchronized MicroServiceFullInfo updateMicroServiceNode(String serviceName,\r
 155             String version, String ip,String port, int ttl) {\r
 156         if("null".equals(version)) {\r
 157             version="";\r
 158         }\r
 159         serviceName=serviceName.replace("*", "/");\r
 160         \r
 161         if (StringUtils.isBlank(serviceName)) {\r
 162             throw new ExtendedNotSupportedException(\r
 163                     "update MicroService Node FAIL:serviceName  can't be empty");\r
 164         }\r
 165 \r
 166         if (StringUtils.isNotBlank(version)) {\r
 167             if (!RegExpTestUtil.versionRegExpTest(version)) {\r
 168                 throw new ExtendedNotSupportedException(\r
 169                         "update MicroService Node FAIL:version is not a valid  format");\r
 170             }\r
 171         }\r
 172 \r
 173         if (!RegExpTestUtil.ipRegExpTest(ip)) {\r
 174             throw new ExtendedNotSupportedException("update MicroService Node FAIL:ip(" + ip\r
 175                     + ")is not a valid IP address");\r
 176         }\r
 177         \r
 178         if (!RegExpTestUtil.portRegExpTest(port)) {\r
 179             throw new ExtendedNotSupportedException("update MicroService Node FAIL:port(" + port\r
 180                     + ")is not a valid Port address");\r
 181         }\r
 182         \r
 183         try {\r
 184 \r
 185             MicroServiceDB.getInstance().updateMicroServiceNode2Redis(serviceName, version, ip,port,ttl);\r
 186 \r
 187             MicroServiceFullInfo newMicroServiceInfo =\r
 188                     MicroServiceDB.getInstance().getMicroServiceInstance(serviceName, version,"");\r
 189 \r
 190             return newMicroServiceInfo;\r
 191         } catch (NullPointerException e) {\r
 192             throw new ExtendedNotFoundException(e.getMessage());\r
 193         } catch (Exception e) {\r
 194             LOGGER.error("update MicroServiceNode throw exception", e);\r
 195             throw new ExtendedInternalServerErrorException(e.getMessage());\r
 196         }\r
 197     }\r
 198 \r
 199     /**\r
 200      * @Title updateMicroServiceStatus\r
 201      * @Description updateMicroServiceStatus\r
 202      * @param serviceName\r
 203      * @param version\r
 204      * @param status\r
 205      * @return\r
 206      * @return RouteResult\r
 207      */\r
 208  \r
 209     public synchronized MicroServiceFullInfo updateMicroServiceStatus(String serviceName, String version,\r
 210             String status) {\r
 211 \r
 212         if ("null".equals(version)) {\r
 213             version = "";\r
 214         }\r
 215         serviceName=serviceName.replace("*", "/");\r
 216 \r
 217         if (StringUtils.isBlank(serviceName)) {\r
 218             throw new ExtendedNotSupportedException(\r
 219                     "update MicroService status FAIL:serviceName  can't be empty");\r
 220         }\r
 221 \r
 222         if (StringUtils.isNotBlank(version)) {\r
 223             if (!RegExpTestUtil.versionRegExpTest(version)) {\r
 224                 throw new ExtendedNotSupportedException(\r
 225                         "update MicroService status FAIL:version is not a valid  format");\r
 226             }\r
 227         }\r
 228         \r
 229         if(!"0".equals(status) && !"2".equals(status) && !"1".equals(status)){\r
 230 \r
 231             throw new ExtendedNotSupportedException("update MicroService status FAIL:status is wrong");\r
 232         }\r
 233         \r
 234         \r
 235         try {\r
 236 \r
 237             MicroServiceDB.getInstance().updateMicroServiceStatus(serviceName, version, status);\r
 238 \r
 239             MicroServiceFullInfo newMicroServiceInfo =\r
 240                     MicroServiceDB.getInstance().getMicroServiceInstance(serviceName, version,"");\r
 241             \r
 242             // Notify the listeners\r
 243             MicroServiceDB.getInstance().noticeUpdateStatusListener(newMicroServiceInfo, status);\r
 244 \r
 245 \r
 246             return newMicroServiceInfo;\r
 247         } catch (NullPointerException e) {\r
 248             throw new ExtendedNotFoundException(e.getMessage());\r
 249         } catch (Exception e) {\r
 250             LOGGER.error("update MicroServiceNode throw exception", e);\r
 251             throw new ExtendedInternalServerErrorException(e.getMessage());\r
 252         }\r
 253  \r
 254 \r
 255     }\r
 256 \r
 257 \r
 258     public synchronized MicroServiceFullInfo saveMicroServiceInstance(\r
 259             MicroServiceInfo microServiceInfo, boolean createOrUpdate,String requestIP,String serverPort) {\r
 260         // 保存数据格式判断\r
 261 \r
 262         if (StringUtils.isBlank(microServiceInfo.getServiceName())\r
 263                 || StringUtils.isBlank(microServiceInfo.getProtocol())\r
 264                 || microServiceInfo.getNodes().size() == 0) {\r
 265             throw new ExtendedNotSupportedException(\r
 266                     "register MicroServiceInfo FAIL: Some required fields are empty");\r
 267         }\r
 268 \r
 269         for (Node node : microServiceInfo.getNodes()) {\r
 270          \r
 271             if(node.getIp()==null || node.getIp().isEmpty()){\r
 272                 node.setIp(requestIP);\r
 273             }\r
 274             else if (!RegExpTestUtil.ipRegExpTest(node.getIp())) {\r
 275                 throw new ExtendedNotSupportedException("register MicroServiceInfo FAIL:IP("\r
 276                         + node.getIp() + ")is not a valid ip address");\r
 277             }\r
 278             \r
 279             if (!RegExpTestUtil.portRegExpTest(node.getPort())) {\r
 280                 throw new ExtendedNotSupportedException("register MicroServiceInfo FAIL:Port("\r
 281                         + node.getPort() + ")is not a valid Port address");\r
 282             }\r
 283         }\r
 284 \r
 285         if (StringUtils.isNotBlank(microServiceInfo.getVersion())) {\r
 286             if (!RegExpTestUtil.versionRegExpTest(microServiceInfo.getVersion())) {\r
 287                 throw new ExtendedNotSupportedException(\r
 288                         "register MicroServiceInfo FAIL:version is not a valid  format");\r
 289 \r
 290             }\r
 291         }\r
 292 \r
 293         if (StringUtils.isNotBlank(microServiceInfo.getUrl().trim())) {\r
 294             if (!RegExpTestUtil.urlRegExpTest(microServiceInfo.getUrl())) {\r
 295                 throw new ExtendedNotSupportedException(\r
 296                         "register MicroServiceInfo FAIL:url is not a valid format(url must be begin with /)");\r
 297 \r
 298             }\r
 299         }\r
 300 \r
 301 \r
 302         if (RouteUtil.PROTOCOL_LIST.indexOf(microServiceInfo.getProtocol().trim()) == -1) {\r
 303             throw new ExtendedNotSupportedException(\r
 304                     "register MicroServiceInfo FAIL:Protocol is wrong,value range:("\r
 305                             + RouteUtil.PROTOCOL_LIST + ")");\r
 306         }\r
 307 \r
 308         MicroServiceFullInfo existingMicroServiceInfo;\r
 309         try {\r
 310             //To determine whether a service already exists\r
 311             existingMicroServiceInfo =\r
 312                     MicroServiceDB.getInstance().getMicroServiceInstance(\r
 313                             microServiceInfo.getServiceName().trim(), microServiceInfo.getVersion().trim(),serverPort);\r
 314 \r
 315             MicroServiceFullInfo newMicroServiceInfo ;\r
 316             if (existingMicroServiceInfo != null) {\r
 317                 //a service already exists\r
 318 \r
 319                 if (!existingMicroServiceInfo.getProtocol().equals(microServiceInfo.getProtocol())) {\r
 320                     throw new ExtendedNotSupportedException(\r
 321                             "MicroServiceInfo with different protocols and same serviceName is already existing");\r
 322                 }\r
 323 \r
 324                 if (createOrUpdate == false) {\r
 325                     //After the first remove added\r
 326                     MicroServiceDB.getInstance().deleteMicroService(\r
 327                             microServiceInfo.getServiceName(), microServiceInfo.getVersion(),serverPort);\r
 328 \r
 329                     MicroServiceDB.getInstance().saveMicroServiceInfo2Redis(microServiceInfo,serverPort);\r
 330          \r
 331                 } else {\r
 332                     //Add the original record and save directly\r
 333                     MicroServiceDB.getInstance().saveMicroServiceInfo2Redis(microServiceInfo,serverPort);\r
 334                 }\r
 335                 \r
 336                 newMicroServiceInfo =\r
 337                         MicroServiceDB.getInstance().getMicroServiceInstance(\r
 338                                 microServiceInfo.getServiceName(), microServiceInfo.getVersion(),serverPort);\r
 339 \r
 340                 //Notify the listeners\r
 341                 MicroServiceDB.getInstance().noticeUpdateApiListener(microServiceInfo.getServiceName(),microServiceInfo.getVersion(),newMicroServiceInfo,serverPort);\r
 342 \r
 343             } else {\r
 344                 //Save the new record\r
 345                 MicroServiceDB.getInstance().saveMicroServiceInfo2Redis(microServiceInfo,serverPort);\r
 346                 //Notify the listeners\r
 347                 MicroServiceDB.getInstance().noticeApiListener(microServiceInfo, "ADD",serverPort);\r
 348                 newMicroServiceInfo =\r
 349                         MicroServiceDB.getInstance().getMicroServiceInstance(\r
 350                                 microServiceInfo.getServiceName(), microServiceInfo.getVersion(),serverPort);\r
 351             }\r
 352 \r
 353   \r
 354 \r
 355             return newMicroServiceInfo;\r
 356 \r
 357         } catch (ExtendedNotSupportedException e) {\r
 358             throw e;\r
 359         } catch (Exception e) {\r
 360             throw new ExtendedInternalServerErrorException(e.getMessage());\r
 361         }\r
 362 \r
 363     }\r
 364     \r
 365     \r
 366     public synchronized void deleteMicroService(String serviceName, String version) {\r
 367         if("null".equals(version)) {\r
 368             version="";\r
 369         }\r
 370         serviceName=serviceName.replace("*", "/");\r
 371         \r
 372         if (StringUtils.isBlank(serviceName)) {\r
 373             throw new ExtendedNotSupportedException(\r
 374                     "delete MicroServiceInfo FAIL：serviceName  can't be empty");\r
 375         }\r
 376 \r
 377         if (StringUtils.isNotBlank(version)) {\r
 378             if (!RegExpTestUtil.versionRegExpTest(version)) {\r
 379                 throw new ExtendedNotSupportedException(\r
 380                         "delete MicroServiceInfo FAIL:version is not a valid  format");\r
 381 \r
 382             }\r
 383         }\r
 384 \r
 385         try {\r
 386 \r
 387             MicroServiceFullInfo microServiceInfo =\r
 388                     MicroServiceDB.getInstance().getMicroServiceInstance(serviceName, version,"");\r
 389 \r
 390             if (microServiceInfo == null) {\r
 391                 LOGGER.warn("serviceName-"+ serviceName + ",version-" + version + " not fond ");\r
 392                 return;\r
 393             }\r
 394 \r
 395             MicroServiceDB.getInstance().deleteMicroService(serviceName, version,"");\r
 396             //Notify the listeners\r
 397             MicroServiceDB.getInstance().noticeApiListener(microServiceInfo, "DELETE","");\r
 398         \r
 399         } catch (Exception e) {\r
 400             LOGGER.error("delete MicroServiceInfo throw exception", e);\r
 401             throw new ExtendedInternalServerErrorException(e.getMessage());\r
 402 \r
 403         }\r
 404         \r
 405         LOGGER.info("delete MicroServiceInfo success:serviceName-"\r
 406                 + serviceName + ",version-" + version );\r
 407 \r
 408     }\r
 409 \r
 410 \r
 411     public synchronized void deleteMicroService(String serviceName, String version,String serverPort) {\r
 412         if("null".equals(version)) {\r
 413             version="";\r
 414         }\r
 415         serviceName=serviceName.replace("*", "/");\r
 416         \r
 417         if (StringUtils.isBlank(serviceName)) {\r
 418             throw new ExtendedNotSupportedException(\r
 419                     "delete MicroServiceInfo FAIL：serviceName  can't be empty");\r
 420         }\r
 421 \r
 422         if (StringUtils.isNotBlank(version)) {\r
 423             if (!RegExpTestUtil.versionRegExpTest(version)) {\r
 424                 throw new ExtendedNotSupportedException(\r
 425                         "delete MicroServiceInfo FAIL:version is not a valid  format");\r
 426 \r
 427             }\r
 428         }\r
 429 \r
 430         try {\r
 431 \r
 432             MicroServiceFullInfo microServiceInfo =\r
 433                     MicroServiceDB.getInstance().getMicroServiceInstance(serviceName, version,serverPort);\r
 434 \r
 435             if (microServiceInfo == null) {\r
 436                 throw new ExtendedNotFoundException("delete MicroServiceInfo FAIL:serviceName-"\r
 437                         + serviceName + ",version-" + version + " not fond ");\r
 438             }\r
 439 \r
 440             MicroServiceDB.getInstance().deleteMicroService(serviceName, version,serverPort);\r
 441             //Notify the listeners\r
 442             MicroServiceDB.getInstance().noticeApiListener(microServiceInfo, "DELETE",serverPort);\r
 443         } catch (ExtendedNotFoundException e) {\r
 444             throw e;\r
 445         } catch (Exception e) {\r
 446             LOGGER.error("delete MicroServiceInfo throw exception", e);\r
 447             throw new ExtendedInternalServerErrorException(e.getMessage());\r
 448 \r
 449         }\r
 450         \r
 451         LOGGER.info("delete MicroServiceInfo success:serviceName-"\r
 452                 + serviceName + ",version-" + version );\r
 453 \r
 454     }\r
 455 \r
 456     public synchronized void deleteMicroServiceInstance(String serviceName, String version,\r
 457             String ip,String port) {\r
 458         if("null".equals(version)) {\r
 459             version="";\r
 460         }\r
 461         serviceName=serviceName.replace("*", "/");\r
 462         \r
 463         if (StringUtils.isBlank(serviceName)) {\r
 464             throw new ExtendedNotSupportedException(\r
 465                     "delete MicroServiceInfo FAIL:serviceName  can't be empty");\r
 466         }\r
 467 \r
 468         if (StringUtils.isNotBlank(version)) {\r
 469             if (!RegExpTestUtil.versionRegExpTest(version)) {\r
 470                 throw new ExtendedNotSupportedException(\r
 471                         "delete MicroServiceInfo FAIL:version is not a valid  format");\r
 472             }\r
 473         }\r
 474 \r
 475         if (!RegExpTestUtil.ipRegExpTest(ip)) {\r
 476             throw new ExtendedNotSupportedException("delete MicroServiceInfo FAIL:IP(" + ip\r
 477                     + ")is not a valid IP address");\r
 478         }\r
 479         \r
 480         if (!RegExpTestUtil.portRegExpTest(port)) {\r
 481             throw new ExtendedNotSupportedException("delete MicroServiceInfo FAIL:Port(" + port\r
 482                     + ")is not a valid Port address");\r
 483         }\r
 484 \r
 485 \r
 486         try {\r
 487             MicroServiceFullInfo microServiceInfo =\r
 488                     MicroServiceDB.getInstance().getMicroServiceInstance(serviceName, version,"");\r
 489 \r
 490             if (microServiceInfo == null) {\r
 491                 throw new ExtendedNotFoundException("delete MicroServiceInfo FAIL:serviceName-"\r
 492                         + serviceName + ",version-" + version + " not fond ");\r
 493             }\r
 494 \r
 495             Set<NodeInfo> nodes = microServiceInfo.getNodes();\r
 496 \r
 497             boolean ifFindBNode = false;\r
 498 \r
 499             for (Node node : nodes) {\r
 500                 if (node.getIp().equals(ip) && node.getPort().equals(port)) {\r
 501                     ifFindBNode = true;\r
 502                     nodes.remove(node);\r
 503 \r
 504                     if (nodes.isEmpty()) {\r
 505                         //delete MicroService\r
 506                         MicroServiceDB.getInstance().deleteMicroService(serviceName, version,"");\r
 507                         //Notify the listeners\r
 508                         MicroServiceDB.getInstance().noticeApiListener(microServiceInfo, "DELETE","");\r
 509                     } else {\r
 510                         //delete Node\r
 511                         MicroServiceDB.getInstance().deleteNode(serviceName, version, ip,port);\r
 512                         MicroServiceDB.getInstance().noticeUpdateApiListener(serviceName, version,microServiceInfo,"");\r
 513                     }\r
 514 \r
 515                     break;\r
 516                 }\r
 517             }\r
 518 \r
 519             if (!ifFindBNode) {\r
 520                 throw new ExtendedNotFoundException("delete MicroServiceInfo FAIL: node-" + ip+":"+port\r
 521                         + " not fond ");\r
 522             }\r
 523 \r
 524 \r
 525         } catch (ExtendedNotFoundException e) {\r
 526             throw e;\r
 527         } catch (Exception e) {\r
 528             LOGGER.error("deleteApiRoute throw exception", e);\r
 529             throw new ExtendedInternalServerErrorException(e.getMessage());\r
 530 \r
 531         }\r
 532 \r
 533     }\r
 534 \r
 535 \r
 536 }\r