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

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