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

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