2 * Copyright (C) 2016 ZTE, Inc. and others. All rights reserved. (ZTE)
\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
8 * http://www.apache.org/licenses/LICENSE-2.0
\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
17 package org.openo.msb.wrapper;
\r
19 import java.util.Set;
\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
35 public class MicroServiceWrapper {
\r
37 private static final Logger LOGGER = LoggerFactory.getLogger(MicroServiceWrapper.class);
\r
39 private static MicroServiceWrapper instance = new MicroServiceWrapper();
\r
42 private MicroServiceWrapper() {}
\r
44 public static MicroServiceWrapper getInstance() {
\r
50 * @Title: getAllMicroServiceInstances
\r
51 * @Description: getAllMicroServiceInstances
\r
56 public MicroServiceFullInfo[] getAllMicroServiceInstances(){
\r
59 return MicroServiceDB.getInstance().getAllMicroServiceInstances();
\r
61 } catch (Exception e) {
\r
62 throw new ExtendedInternalServerErrorException(e.getMessage());
\r
68 * @Title: getMicroServiceInstance
\r
69 * @Description: (getMicroServiceInstance)
\r
70 * @param: @param serviceName
\r
71 * @param: @param version
\r
73 * @return: ApiRouteInfo
\r
75 public MicroServiceFullInfo getMicroServiceInstance(String serviceName, String version,String serverPort) {
\r
76 if("null".equals(version)) {
\r
79 serviceName=serviceName.replace("*", "/");
\r
81 if (StringUtils.isBlank(serviceName)) {
\r
82 throw new ExtendedNotSupportedException("serviceName can't be empty");
\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
92 MicroServiceFullInfo microServiceInfo;
\r
95 MicroServiceDB.getInstance().getMicroServiceInstance(serviceName, version,serverPort);
\r
97 } catch (Exception e) {
\r
98 throw new ExtendedInternalServerErrorException(e.getMessage());
\r
101 if (null == microServiceInfo) {
\r
103 "microservice not found: serviceName-" + serviceName + ",version-" + version;
\r
104 LOGGER.warn(errInfo);
\r
105 throw new ExtendedNotFoundException(errInfo);
\r
109 return microServiceInfo;
\r
115 * @Title: updateMicroServiceInstance
\r
116 * @Description: updateMicroServiceInstance
\r
117 * @param: serviceName
\r
119 * @param: microServiceInfo
\r
120 * @return: RouteResult
\r
122 public synchronized MicroServiceFullInfo updateMicroServiceInstance(String serviceName,
\r
123 String version, MicroServiceInfo microServiceInfo) {
\r
124 if("null".equals(version)) {
\r
127 serviceName=serviceName.replace("*", "/");
\r
132 MicroServiceFullInfo oldService= getMicroServiceInstance(serviceName,version,"");
\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
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
154 public synchronized MicroServiceFullInfo updateMicroServiceNode(String serviceName,
\r
155 String version, String ip,String port, int ttl) {
\r
156 if("null".equals(version)) {
\r
159 serviceName=serviceName.replace("*", "/");
\r
161 if (StringUtils.isBlank(serviceName)) {
\r
162 throw new ExtendedNotSupportedException(
\r
163 "update MicroService Node FAIL:serviceName can't be empty");
\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
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
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
185 MicroServiceDB.getInstance().updateMicroServiceNode2Redis(serviceName, version, ip,port,ttl);
\r
187 MicroServiceFullInfo newMicroServiceInfo =
\r
188 MicroServiceDB.getInstance().getMicroServiceInstance(serviceName, version,"");
\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
200 * @Title updateMicroServiceStatus
\r
201 * @Description updateMicroServiceStatus
\r
202 * @param serviceName
\r
206 * @return RouteResult
\r
209 public synchronized MicroServiceFullInfo updateMicroServiceStatus(String serviceName, String version,
\r
212 if ("null".equals(version)) {
\r
215 serviceName=serviceName.replace("*", "/");
\r
217 if (StringUtils.isBlank(serviceName)) {
\r
218 throw new ExtendedNotSupportedException(
\r
219 "update MicroService status FAIL:serviceName can't be empty");
\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
229 if(!"0".equals(status) && !"2".equals(status) && !"1".equals(status)){
\r
231 throw new ExtendedNotSupportedException("update MicroService status FAIL:status is wrong");
\r
237 MicroServiceDB.getInstance().updateMicroServiceStatus(serviceName, version, status);
\r
239 MicroServiceFullInfo newMicroServiceInfo =
\r
240 MicroServiceDB.getInstance().getMicroServiceInstance(serviceName, version,"");
\r
242 // Notify the listeners
\r
243 MicroServiceDB.getInstance().noticeUpdateStatusListener(newMicroServiceInfo, status);
\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
258 public synchronized MicroServiceFullInfo saveMicroServiceInstance(
\r
259 MicroServiceInfo microServiceInfo, boolean createOrUpdate,String requestIP,String serverPort) {
\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
269 for (Node node : microServiceInfo.getNodes()) {
\r
271 if(node.getIp()==null || node.getIp().isEmpty()){
\r
272 node.setIp(requestIP);
\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
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
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
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
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
308 MicroServiceFullInfo existingMicroServiceInfo;
\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
315 MicroServiceFullInfo newMicroServiceInfo ;
\r
316 if (existingMicroServiceInfo != null) {
\r
317 //a service already exists
\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
324 if (createOrUpdate == false) {
\r
325 //After the first remove added
\r
326 MicroServiceDB.getInstance().deleteMicroService(
\r
327 microServiceInfo.getServiceName(), microServiceInfo.getVersion(),serverPort);
\r
329 MicroServiceDB.getInstance().saveMicroServiceInfo2Redis(microServiceInfo,serverPort);
\r
332 //Add the original record and save directly
\r
333 MicroServiceDB.getInstance().saveMicroServiceInfo2Redis(microServiceInfo,serverPort);
\r
336 newMicroServiceInfo =
\r
337 MicroServiceDB.getInstance().getMicroServiceInstance(
\r
338 microServiceInfo.getServiceName(), microServiceInfo.getVersion(),serverPort);
\r
340 //Notify the listeners
\r
341 MicroServiceDB.getInstance().noticeUpdateApiListener(microServiceInfo.getServiceName(),microServiceInfo.getVersion(),newMicroServiceInfo,serverPort);
\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
355 return newMicroServiceInfo;
\r
357 } catch (ExtendedNotSupportedException e) {
\r
359 } catch (Exception e) {
\r
360 throw new ExtendedInternalServerErrorException(e.getMessage());
\r
366 public synchronized void deleteMicroService(String serviceName, String version) {
\r
367 if("null".equals(version)) {
\r
370 serviceName=serviceName.replace("*", "/");
\r
372 if (StringUtils.isBlank(serviceName)) {
\r
373 throw new ExtendedNotSupportedException(
\r
374 "delete MicroServiceInfo FAIL:serviceName can't be empty");
\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
387 MicroServiceFullInfo microServiceInfo =
\r
388 MicroServiceDB.getInstance().getMicroServiceInstance(serviceName, version,"");
\r
390 if (microServiceInfo == null) {
\r
391 LOGGER.warn("serviceName-"+ serviceName + ",version-" + version + " not fond ");
\r
395 MicroServiceDB.getInstance().deleteMicroService(serviceName, version,"");
\r
396 //Notify the listeners
\r
397 MicroServiceDB.getInstance().noticeApiListener(microServiceInfo, "DELETE","");
\r
399 } catch (Exception e) {
\r
400 LOGGER.error("delete MicroServiceInfo throw exception", e);
\r
401 throw new ExtendedInternalServerErrorException(e.getMessage());
\r
405 LOGGER.info("delete MicroServiceInfo success:serviceName-"
\r
406 + serviceName + ",version-" + version );
\r
411 public synchronized void deleteMicroService(String serviceName, String version,String serverPort) {
\r
412 if("null".equals(version)) {
\r
415 serviceName=serviceName.replace("*", "/");
\r
417 if (StringUtils.isBlank(serviceName)) {
\r
418 throw new ExtendedNotSupportedException(
\r
419 "delete MicroServiceInfo FAIL:serviceName can't be empty");
\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
432 MicroServiceFullInfo microServiceInfo =
\r
433 MicroServiceDB.getInstance().getMicroServiceInstance(serviceName, version,serverPort);
\r
435 if (microServiceInfo == null) {
\r
436 throw new ExtendedNotFoundException("delete MicroServiceInfo FAIL:serviceName-"
\r
437 + serviceName + ",version-" + version + " not fond ");
\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
445 } catch (Exception e) {
\r
446 LOGGER.error("delete MicroServiceInfo throw exception", e);
\r
447 throw new ExtendedInternalServerErrorException(e.getMessage());
\r
451 LOGGER.info("delete MicroServiceInfo success:serviceName-"
\r
452 + serviceName + ",version-" + version );
\r
456 public synchronized void deleteMicroServiceInstance(String serviceName, String version,
\r
457 String ip,String port) {
\r
458 if("null".equals(version)) {
\r
461 serviceName=serviceName.replace("*", "/");
\r
463 if (StringUtils.isBlank(serviceName)) {
\r
464 throw new ExtendedNotSupportedException(
\r
465 "delete MicroServiceInfo FAIL:serviceName can't be empty");
\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
475 if (!RegExpTestUtil.ipRegExpTest(ip)) {
\r
476 throw new ExtendedNotSupportedException("delete MicroServiceInfo FAIL:IP(" + ip
\r
477 + ")is not a valid IP address");
\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
487 MicroServiceFullInfo microServiceInfo =
\r
488 MicroServiceDB.getInstance().getMicroServiceInstance(serviceName, version,"");
\r
490 if (microServiceInfo == null) {
\r
491 throw new ExtendedNotFoundException("delete MicroServiceInfo FAIL:serviceName-"
\r
492 + serviceName + ",version-" + version + " not fond ");
\r
495 Set<NodeInfo> nodes = microServiceInfo.getNodes();
\r
497 boolean ifFindBNode = false;
\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
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
511 MicroServiceDB.getInstance().deleteNode(serviceName, version, ip,port);
\r
512 MicroServiceDB.getInstance().noticeUpdateApiListener(serviceName, version,microServiceInfo,"");
\r
519 if (!ifFindBNode) {
\r
520 throw new ExtendedNotFoundException("delete MicroServiceInfo FAIL: node-" + ip+":"+port
\r
525 } catch (ExtendedNotFoundException e) {
\r
527 } catch (Exception e) {
\r
528 LOGGER.error("deleteApiRoute throw exception", e);
\r
529 throw new ExtendedInternalServerErrorException(e.getMessage());
\r