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

   1 /**
   2  * Copyright 2016 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
  17 package org.onap.msb.apiroute.wrapper;
  18
  19 import java.util.HashSet;
  20 import java.util.List;
  21 import java.util.Set;
  22 import java.util.regex.Matcher;
  23 import java.util.regex.Pattern;
  24
  25 import org.onap.msb.apiroute.api.MicroServiceFullInfo;
  26 import org.onap.msb.apiroute.api.Node;
  27 import org.onap.msb.apiroute.api.exception.ExtendedInternalServerErrorException;
  28 import org.onap.msb.apiroute.api.exception.ExtendedNotFoundException;
  29 import org.onap.msb.apiroute.api.exception.UnprocessableEntityException;
  30 import org.onap.msb.apiroute.wrapper.dao.RedisAccessWrapper;
  31 import org.onap.msb.apiroute.wrapper.service.MicroServiceFullService;
  32 import org.onap.msb.apiroute.wrapper.serviceListener.RouteNotify;
  33 import org.onap.msb.apiroute.wrapper.util.MicroServiceUtil;
  34 import org.onap.msb.apiroute.wrapper.util.RegExpTestUtil;
  35 import org.onap.msb.apiroute.wrapper.util.RouteUtil;
  36 import org.slf4j.Logger;
  37 import org.slf4j.LoggerFactory;
  38
  39 public class MicroServiceWrapper {
  40
  41   private static final Logger LOGGER = LoggerFactory.getLogger(MicroServiceWrapper.class);
  42
  43   private static MicroServiceWrapper instance = new MicroServiceWrapper();
  44
  45
  46   private MicroServiceWrapper() {}
  47
  48   public static MicroServiceWrapper getInstance() {
  49     return instance;
  50   }
  51
  52
  53
  54
  55   /**
  56    * @Title: getAllMicroServiceInstances
  57    * @Description: getAllMicroServiceInstances
  58    * @param: @return
  59    * @return: Response
  60    * @throws Exception
  61    */
  62   public List<MicroServiceFullInfo> getAllMicroServiceInstances() {
  63
  64     try {
  65       return MicroServiceFullService.getInstance().getAllMicroServiceInstances();
  66
  67     } catch (Exception e) {
  68       throw new ExtendedInternalServerErrorException(e.getMessage());
  69     }
  70
  71   }
  72
  73   public Set<String> getAllMicroServiceKey() {
  74      int failedNum = 0;
  75      int retryCount=3;
  76      int failedTimer = 5 * 1000;
  77
  78      Set<String> serviceKeys=null;
  79
  80      do {
  81
  82        try {
  83          serviceKeys= MicroServiceFullService.getInstance().getAllMicroServiceKey();
  84          break;
  85
  86        } catch (Exception e) {
  87
  88          LOGGER.error(failedNum + "/"+retryCount+" :  get AllMicroServiceKey  fail"+e);
  89          failedNum++;
  90
  91            try {
  92              Thread.sleep(failedTimer);
  93            } catch (InterruptedException ex) {
  94              LOGGER.warn("get AllMicroServiceKey  Thread.sleep throw except:" + ex.getMessage());
  95            }
  96        }
  97
  98      }while (failedNum <= retryCount);
  99
 100
 101       return serviceKeys;
 102
 103   }
 104
 105
 106
 107
 108   /**
 109    * @Title: getMicroServiceInstance
 110    * @Description: (getMicroServiceInstance)
 111    * @param: @param serviceName
 112    * @param: @param version
 113    * @param: @return
 114    * @return: ApiRouteInfo
 115    */
 116   public MicroServiceFullInfo getMicroServiceInstance(String serviceName, String version) {
 117     if ("null".equals(version)) {
 118       version = "";
 119     }
 120     serviceName = serviceName.replace("*", "/");
 121
 122     RouteUtil.checkServiceNameAndVersion(serviceName, version);
 123
 124     MicroServiceFullInfo microServiceInfo;
 125     try {
 126       microServiceInfo =
 127           MicroServiceFullService.getInstance().getMicroServiceInstance(serviceName, version);
 128
 129     } catch (Exception e) {
 130       throw new ExtendedInternalServerErrorException(e.getMessage());
 131     }
 132
 133     if (null == microServiceInfo) {
 134       String errInfo = "microservice not found: serviceName-" + serviceName + ",version-" + version;
 135       throw new ExtendedNotFoundException(errInfo);
 136
 137     }
 138
 139     return microServiceInfo;
 140   }
 141
 142
 143
 144   /**
 145    * @Title updateMicroServiceStatus
 146    * @Description updateMicroServiceStatus
 147    * @param serviceName
 148    * @param version
 149    * @param status
 150    * @return
 151    * @return RouteResult
 152    */
 153
 154   public synchronized MicroServiceFullInfo updateMicroServiceStatus(String serviceName,
 155       String version, String status) {
 156
 157     if ("null".equals(version)) {
 158       version = "";
 159     }
 160     serviceName = serviceName.replace("*", "/");
 161
 162     RouteUtil.checkServiceNameAndVersion(serviceName, version);
 163
 164     RouteUtil.checkServiceStatus(status);
 165
 166     try {
 167
 168       MicroServiceFullService.getInstance().updateMicroServiceStatus(serviceName, version, status);
 169
 170       MicroServiceFullInfo newMicroServiceInfo =
 171           MicroServiceFullService.getInstance().getMicroServiceInstance(serviceName, version);
 172
 173       // Notify the listeners
 174       RouteNotify.getInstance().noticeUpdateStatusListener(newMicroServiceInfo, status);
 175
 176
 177       return newMicroServiceInfo;
 178     } catch (NullPointerException e) {
 179       throw new ExtendedNotFoundException(e.getMessage());
 180     } catch (Exception e) {
 181       LOGGER.error("update MicroServiceNode throw exception", e);
 182       throw new ExtendedInternalServerErrorException(e.getMessage());
 183     }
 184
 185
 186   }
 187
 188
 189   public synchronized MicroServiceFullInfo saveMicroServiceInstance(
 190       MicroServiceFullInfo microServiceInfo, boolean createOrUpdate, String requestIP,
 191       String serverPort) {
 192
 193     RouteUtil.checkMicroServiceInfoFormat(microServiceInfo, requestIP);
 194
 195     try {
 196
 197       if (createOrUpdate == false) {
 198         deleteServiceAndnoticeRoute(microServiceInfo);
 199       }
 200
 201       saveServiceAndnoticeRoute(microServiceInfo);
 202
 203
 204       MicroServiceFullInfo newMicroServiceInfo =
 205           MicroServiceFullService.getInstance().getMicroServiceInstance(
 206               microServiceInfo.getServiceName(), microServiceInfo.getVersion());
 207
 208
 209       return newMicroServiceInfo;
 210
 211     } catch (UnprocessableEntityException e) {
 212       throw e;
 213     } catch (Exception e) {
 214       throw new ExtendedInternalServerErrorException("save MicroServiceInfo  fail :[serviceName]" + microServiceInfo.getServiceName()
 215           + "[version]" + microServiceInfo.getVersion()+ e.getMessage());
 216     }
 217
 218   }
 219
 220
 221   public synchronized void deleteMicroService4AllVersion(String serviceName) {
 222     try {
 223
 224       List<MicroServiceFullInfo> microServiceList4AllVersion =
 225           MicroServiceFullService.getInstance().getAllVersionsOfTheService(serviceName);
 226
 227       if (microServiceList4AllVersion.size() == 0) {
 228         LOGGER.info("delete MicroServiceInfo for All Version Fail:serviceName-" + serviceName
 229             + " not fond");
 230       } else {
 231         for (MicroServiceFullInfo microServiceInfo : microServiceList4AllVersion) {
 232           deleteServiceAndnoticeRoute(microServiceInfo);
 233         }
 234       }
 235
 236     } catch (Exception e) {
 237       LOGGER.error("delete MicroServiceInfo for all version :serviceName-" + serviceName +" throw exception", e);
 238
 239     }
 240   }
 241
 242
 243   public synchronized void deleteMicroService(String serviceName, String version) {
 244     if ("null".equals(version)) {
 245       version = "";
 246     }
 247     serviceName = serviceName.replace("*", "/");
 248
 249     RouteUtil.checkServiceNameAndVersion(serviceName, version);
 250
 251     try {
 252
 253       MicroServiceFullInfo microServiceInfo =
 254           MicroServiceFullService.getInstance().getMicroServiceInstance(serviceName, version);
 255
 256       if (microServiceInfo == null) {
 257         LOGGER.error("delete MicroServiceInfo FAIL:serviceName-" + serviceName + ",version-"+ version + " not fond ");
 258       } else {
 259
 260         deleteServiceAndnoticeRoute(microServiceInfo);
 261       }
 262
 263
 264     } catch (ExtendedNotFoundException e) {
 265       throw e;
 266     } catch (Exception e) {
 267
 268       throw new ExtendedInternalServerErrorException("delete MicroServiceInfo serviceName-" + serviceName + ",version-" + version+e.getMessage());
 269
 270     }
 271
 272
 273   }
 274
 275   public synchronized void deleteMicroServiceInstance(String serviceName, String version,
 276       String ip, String port) {
 277     if ("null".equals(version)) {
 278       version = "";
 279     }
 280     serviceName = serviceName.replace("*", "/");
 281
 282     RouteUtil.checkServiceNameAndVersion(serviceName, version);
 283
 284     if (!RegExpTestUtil.ipRegExpTest(ip)) {
 285       throw new UnprocessableEntityException("delete MicroServiceInfo FAIL:IP(" + ip+ ")is not a valid IP address");
 286     }
 287
 288     if (!RegExpTestUtil.portRegExpTest(port)) {
 289       throw new UnprocessableEntityException("delete MicroServiceInfo FAIL:Port(" + port + ")is not a valid Port address");
 290     }
 291
 292
 293     try {
 294       MicroServiceFullInfo microServiceInfo =
 295           MicroServiceFullService.getInstance().getMicroServiceInstance(serviceName, version);
 296
 297       if (microServiceInfo == null) {
 298         throw new UnprocessableEntityException("delete MicroServiceInfo FAIL:serviceName-"+ serviceName + ",version-" + version + " not fond ");
 299       }
 300
 301       Set<Node> nodes = microServiceInfo.getNodes();
 302
 303       boolean ifFindBNode = false;
 304
 305       for (Node node : nodes) {
 306         if (node.getIp().equals(ip) && node.getPort().equals(port)) {
 307           ifFindBNode = true;
 308           nodes.remove(node);
 309
 310           if (nodes.isEmpty()) {
 311             // delete MicroService
 312             deleteServiceAndnoticeRoute(microServiceInfo);
 313           } else {
 314             // delete Node
 315             MicroServiceFullService.getInstance().saveMicroServiceInfo2Redis(microServiceInfo);
 316             RouteNotify.getInstance().noticeRouteListener4Update(serviceName, version,
 317                 microServiceInfo);
 318           }
 319
 320           break;
 321         }
 322       }
 323
 324       if (!ifFindBNode) {
 325         throw new ExtendedNotFoundException("delete MicroServiceInfo FAIL:serviceName-"+ serviceName + ",version-" + version +",node-" + ip + ":" + port + " not fond ");
 326       }
 327
 328
 329     } catch (ExtendedNotFoundException e) {
 330       throw e;
 331     } catch (Exception e) {
 332       throw new ExtendedInternalServerErrorException("delete MicroServiceInfo :serviceName-"+ serviceName + ",version-" + version+",node-" + ip + ":" + port +"throw exception"+e.getMessage());
 333
 334     }
 335
 336   }
 337
 338
 339   public void deleteServiceAndnoticeRoute(MicroServiceFullInfo service) throws Exception {
 340
 341     try {
 342       // Delete the redis record
 343       MicroServiceFullService.getInstance().deleteMicroService(service.getServiceName(),
 344           service.getVersion());
 345       LOGGER.info("delete MicroServiceInfo  And notice to Route success:[serviceName]"+ service.getServiceName() + "[version]" + service.getVersion());
 346
 347       // Notify the listeners
 348       RouteNotify.getInstance().noticeRouteListener4Delete(service);
 349
 350     } catch (Exception e) {
 351       LOGGER.error("delete MicroService And synchro to Route:[serviceName]"+ service.getServiceName() + "[version]" + service.getVersion()+" throw exception", e);
 352       throw e;
 353     }
 354   }
 355
 356   public void saveServiceAndnoticeRoute(MicroServiceFullInfo service) throws Exception {
 357
 358     try {
 359       // save the redis record
 360       MicroServiceFullService.getInstance().saveMicroServiceInfo2Redis(service);
 361
 362       LOGGER.info("save MicroServiceInfo  And notice to Route success:[serviceName]"+ service.getServiceName() + "[version]" + service.getVersion());
 363
 364       // Notify the listeners
 365       RouteNotify.getInstance().noticeRouteListener4Add(service);
 366
 367
 368     } catch (Exception e) {
 369       LOGGER.error("save MicroServiceInfo And synchro to  Route fail :[serviceName]" + service.getServiceName()+ "[version]" + service.getVersion() + " throw exception", e);
 370       throw e;
 371     }
 372   }
 373
 374   public Set<String> getAllVersion(String serviceName) {
 375     Set<String> serviceVersionSet = new HashSet<String>();
 376     try {
 377       String pattern = MicroServiceUtil.getServiceKey(serviceName, "*");
 378       Set<String> serviceKeySet = RedisAccessWrapper.filterKeys(pattern);
 379
 380
 381       Pattern serviceKeyRegexPattern = MicroServiceUtil.getServiceKeyRegexPattern();
 382       for (String serviceKey : serviceKeySet) {
 383         Matcher matcher = serviceKeyRegexPattern.matcher(serviceKey);
 384         if (matcher.matches()) {
 385           serviceVersionSet.add(matcher.group("version"));
 386         }
 387       }
 388     } catch (Exception e) {
 389       LOGGER.error("getAllVersion [serviceName]:" + serviceName + "  throw exception", e);
 390     }
 391
 392     return serviceVersionSet;
 393
 394   }
 395
 396
 397
 398 }