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

   1 /**
   2  * Copyright 2016 2015-2016 ZTE, Inc. and others. All rights reserved.
   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.serviceListener;
  17
  18 import java.util.Set;
  19
  20 import org.apache.commons.lang3.StringUtils;
  21 import org.openo.msb.api.ApiRouteInfo;
  22 import org.openo.msb.api.CustomRouteInfo;
  23 import org.openo.msb.api.IuiRouteInfo;
  24 import org.openo.msb.api.Node;
  25 import org.openo.msb.api.RouteServer;
  26 import org.openo.msb.api.Service;
  27 import org.openo.msb.wrapper.ApiRouteServiceWrapper;
  28 import org.openo.msb.wrapper.CustomRouteServiceWrapper;
  29 import org.openo.msb.wrapper.IuiRouteServiceWrapper;
  30 import org.openo.msb.wrapper.util.RegExpTestUtil;
  31 import org.openo.msb.wrapper.util.RouteUtil;
  32 import org.slf4j.Logger;
  33 import org.slf4j.LoggerFactory;
  34
  35
  36 public class MicroServiceChangeListener implements IMicroServiceChangeListener {
  37
  38     private static final Logger LOGGER = LoggerFactory.getLogger(MicroServiceChangeListener.class);
  39
  40     @Override
  41     public void onSave(Service microServiceInfo,String serverPort) {
  42
  43         if("UI".equals(microServiceInfo.getProtocol())){
  44             IuiRouteInfo iuiRouteInfo = this.buildIuiRouteInfo(microServiceInfo);
  45             if(null != iuiRouteInfo){
  46                 IuiRouteServiceWrapper.getInstance().saveIuiRouteInstance(iuiRouteInfo);
  47             }
  48         }
  49         else{
  50
  51             if(ifApiRouteUrl(microServiceInfo.getUrl())){
  52                 ApiRouteInfo apiRouteInfo = this.buildApiRouteInfo(microServiceInfo);
  53                 if(null != apiRouteInfo){
  54                     ApiRouteServiceWrapper.getInstance().saveApiRouteInstance(apiRouteInfo,serverPort);
  55                 }
  56             }
  57             else{
  58                 CustomRouteInfo customRouteInfo = this.buildCustomRouteInfo(microServiceInfo);
  59                 if(null != customRouteInfo){
  60                     CustomRouteServiceWrapper.getInstance().saveCustomRouteInstance(customRouteInfo,serverPort);
  61                 }
  62             }
  63         }
  64
  65
  66     }
  67
  68     @Override
  69     public void onChange(String serviceName, String version, Service microServiceInfo,String serverPort) {
  70
  71         if("UI".equals(microServiceInfo.getProtocol())){
  72             if(serviceName.startsWith("iui_")||serviceName.startsWith("IUI_")){
  73                 serviceName=serviceName.substring(4);
  74             }
  75             IuiRouteInfo iuiRouteInfo = this.buildIuiRouteInfo(microServiceInfo);
  76             if(null != iuiRouteInfo){
  77                 IuiRouteServiceWrapper.getInstance().updateIuiRouteInstance(serviceName, iuiRouteInfo);
  78             }
  79         }
  80         else{
  81
  82             if(ifApiRouteUrl(microServiceInfo.getUrl())){
  83                 ApiRouteInfo apiRouteInfo = this.buildApiRouteInfo(microServiceInfo);
  84                 if(null != apiRouteInfo){
  85                     ApiRouteServiceWrapper.getInstance().updateApiRouteInstance(serviceName, version, apiRouteInfo,serverPort);
  86                 }
  87             }
  88             else{
  89                 if(!serviceName.startsWith("/")){
  90                     serviceName="/"+serviceName;
  91                 }
  92                 CustomRouteInfo customRouteInfo = this.buildCustomRouteInfo(microServiceInfo);
  93                 if(null != customRouteInfo){
  94                     CustomRouteServiceWrapper.getInstance().updateCustomRouteInstance(serviceName,customRouteInfo,serverPort);
  95                 }
  96             }
  97         }
  98
  99     }
 100
 101     @Override
 102     public void onStatusChange(String serviceName,String url,String version,String protocol,String status) {
 103         if("UI".equals(protocol)){
 104
 105             if(serviceName.startsWith("iui_")||serviceName.startsWith("IUI_")){
 106                 serviceName=serviceName.substring(4);
 107             }
 108            IuiRouteServiceWrapper.getInstance().updateIuiRouteStatus(serviceName, status);
 109
 110         }
 111         else{
 112             if(ifApiRouteUrl(url)){
 113                 ApiRouteServiceWrapper.getInstance().updateApiRouteStatus(serviceName, version, status);
 114             }
 115             else{
 116                 if(!serviceName.startsWith("/")){
 117                     serviceName="/"+serviceName;
 118                 }
 119                 CustomRouteServiceWrapper.getInstance().updateCustomRouteStatus(serviceName, status);
 120             }
 121         }
 122
 123
 124
 125     }
 126
 127     @Override
 128     public void onDelete(String serviceName,String url, String version,String protocol,String serverPort) {
 129
 130         if("UI".equals(protocol)){
 131             if(serviceName.startsWith("iui_")||serviceName.startsWith("IUI_")){
 132                 serviceName=serviceName.substring(4);
 133             }
 134            IuiRouteServiceWrapper.getInstance().deleteIuiRoute(serviceName, "*");
 135
 136         }
 137         else{
 138             if(ifApiRouteUrl(url)){
 139                 ApiRouteServiceWrapper.getInstance().deleteApiRoute(serviceName, version, "*",serverPort);
 140             }
 141             else{
 142
 143
 144                 if(!serviceName.startsWith("/")){
 145                     serviceName="/"+serviceName;
 146                 }
 147
 148                 CustomRouteServiceWrapper.getInstance().deleteCustomRoute(serviceName, "*",serverPort);
 149             }
 150         }
 151     }
 152
 153
 154     /**
 155     * @Title ifApiRouteUrl
 156     * @Description TODO(According to judge whether the API registration URL format)
 157     * @param url
 158     * @return
 159     * @return boolean
 160     */
 161     private boolean ifApiRouteUrl(String url){
 162         return RegExpTestUtil.apiRouteUrlRegExpTest(url);
 163     }
 164
 165
 166     /**
 167      * From MicroServiceInfo to ApiRouteInfo
 168      * @param microServiceInfo
 169      * @return
 170      */
 171     private ApiRouteInfo buildApiRouteInfo(Service microServiceInfo){
 172
 173         ApiRouteInfo apiRouteInfo = new ApiRouteInfo();
 174         apiRouteInfo.setUrl(microServiceInfo.getUrl());
 175
 176         Set<Node> nodes=microServiceInfo.getNodes();
 177         RouteServer[] routeServers=new RouteServer[nodes.size()];
 178
 179
 180         int i=0;
 181         for(Node node:nodes){
 182             RouteServer routeServer = new RouteServer(node.getIp(),node.getPort());
 183             routeServers[i]=routeServer;
 184             i++;
 185         }
 186
 187
 188         apiRouteInfo.setServers(routeServers);
 189         String[] rangs=StringUtils.split(microServiceInfo.getVisualRange(), "|");
 190         if(RouteUtil.contain(rangs, "0")){
 191             apiRouteInfo.setVisualRange("0");
 192         }
 193         else{
 194             apiRouteInfo.setVisualRange("1");
 195         }
 196
 197
 198       if("ip_hash".equals(microServiceInfo.getLb_policy())){
 199           apiRouteInfo.setUseOwnUpstream("1");
 200     }
 201
 202
 203
 204         apiRouteInfo.setServiceName(microServiceInfo.getServiceName());
 205         apiRouteInfo.setVersion(microServiceInfo.getVersion());
 206         //TODO:set json and metrics defaultValue
 207         String version="".equals(microServiceInfo.getVersion())?"":"/"+microServiceInfo.getVersion();
 208         apiRouteInfo.setApiJson(microServiceInfo.getUrl()+"/swagger.json");
 209         apiRouteInfo.setMetricsUrl("/admin/metrics");
 210         return apiRouteInfo;
 211     }
 212
 213
 214     /**
 215      * From MicroServiceInfo to CustomRouteInfo
 216      * @param microServiceInfo
 217      * @return
 218      */
 219     private CustomRouteInfo buildCustomRouteInfo(Service microServiceInfo){
 220
 221         CustomRouteInfo customRouteInfo = new CustomRouteInfo();
 222         customRouteInfo.setUrl(microServiceInfo.getUrl());
 223
 224         Set<Node> nodes=microServiceInfo.getNodes();
 225         RouteServer[] routeServers=new RouteServer[nodes.size()];
 226
 227
 228         int i=0;
 229         for(Node node:nodes){
 230             RouteServer routeServer = new RouteServer(node.getIp(),node.getPort());
 231             routeServers[i]=routeServer;
 232             i++;
 233         }
 234
 235         customRouteInfo.setServers(routeServers);
 236         String[] rangs=StringUtils.split(microServiceInfo.getVisualRange(), "|");
 237         if(RouteUtil.contain(rangs, "0")){
 238             customRouteInfo.setVisualRange("0");
 239         }
 240         else{
 241             customRouteInfo.setVisualRange("1");
 242         }
 243
 244         if("ip_hash".equals(microServiceInfo.getLb_policy())){
 245             customRouteInfo.setUseOwnUpstream("1");
 246         }
 247
 248         String serviceName;
 249         if(!microServiceInfo.getServiceName().startsWith("/")){
 250             serviceName="/"+microServiceInfo.getServiceName();
 251         }
 252         else{
 253             serviceName=microServiceInfo.getServiceName();
 254         }
 255         customRouteInfo.setServiceName(serviceName);
 256
 257         return customRouteInfo;
 258     }
 259
 260
 261     /**
 262      * From MicroServiceInfo to IuiRouteInfo
 263      * @param microServiceInfo
 264      * @return
 265      */
 266     private IuiRouteInfo buildIuiRouteInfo(Service microServiceInfo){
 267
 268         IuiRouteInfo iuiRouteInfo = new IuiRouteInfo();
 269         iuiRouteInfo.setUrl(microServiceInfo.getUrl());
 270
 271         Set<Node> nodes=microServiceInfo.getNodes();
 272         RouteServer[] routeServers=new RouteServer[nodes.size()];
 273
 274
 275         int i=0;
 276         for(Node node:nodes){
 277             RouteServer routeServer = new RouteServer(node.getIp(),node.getPort());
 278             routeServers[i]=routeServer;
 279             i++;
 280         }
 281
 282         iuiRouteInfo.setServers(routeServers);
 283         String[] rangs=StringUtils.split(microServiceInfo.getVisualRange(), "|");
 284         if(RouteUtil.contain(rangs, "0")){
 285             iuiRouteInfo.setVisualRange("0");
 286         }
 287         else{
 288             iuiRouteInfo.setVisualRange("1");
 289         }
 290
 291         if("ip_hash".equals(microServiceInfo.getLb_policy())){
 292             iuiRouteInfo.setUseOwnUpstream("1");
 293         }
 294
 295         String serviceName=microServiceInfo.getServiceName();
 296         if(serviceName.startsWith("iui_")||serviceName.startsWith("IUI_")){
 297             serviceName=serviceName.substring(4);
 298         }
 299
 300
 301         iuiRouteInfo.setServiceName(serviceName);
 302
 303         return iuiRouteInfo;
 304     }
 305 }