1 files changed, 423 insertions, 0 deletions
diff --git a/apiroute/apiroute-service/src/main/java/org/openo/msb/wrapper/util/MicroServiceDB.java b/apiroute/apiroute-service/src/main/java/org/openo/msb/wrapper/util/MicroServiceDB.java
new file mode 100644
index 0000000..ed22745
--- /dev/null
+++ b/apiroute/apiroute-service/src/main/java/org/openo/msb/wrapper/util/MicroServiceDB.java
@@ -0,0 +1,423 @@
+/**
+* Copyright (C) 2016 ZTE, Inc. and others. All rights reserved. (ZTE)
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package org.openo.msb.wrapper.util;
+
+import java.sql.Date;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.commons.lang3.StringUtils;
+import org.openo.msb.api.MicroServiceFullInfo;
+import org.openo.msb.api.MicroServiceInfo;
+import org.openo.msb.api.Node;
+import org.openo.msb.api.NodeInfo;
+import org.openo.msb.api.Service;
+import org.openo.msb.wrapper.serviceListener.IMicroServiceChangeListener;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import redis.clients.jedis.Jedis;
+
+public class MicroServiceDB {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(MicroServiceDB.class);
+
+    private static MicroServiceDB instance = new MicroServiceDB();
+
+    private List<IMicroServiceChangeListener> serviceListenerlist =
+            new ArrayList<IMicroServiceChangeListener>();
+
+    private MicroServiceDB() {}
+
+    public static MicroServiceDB getInstance() {
+        return instance;
+    }
+
+   
+    public void addServiceChangeListener(IMicroServiceChangeListener listener) {
+        synchronized (serviceListenerlist) {
+            serviceListenerlist.add(listener);
+        }
+    }
+
+   
+    public void removeServiceChangeListener(IMicroServiceChangeListener listener) {
+        synchronized (serviceListenerlist) {
+            serviceListenerlist.remove(listener);
+        }
+    }
+    
+    
+    public MicroServiceFullInfo[] getAllMicroServiceInstances() throws Exception {
+        Jedis jedis = null;
+        MicroServiceFullInfo[] microServiceList;
+        try {
+            jedis = JedisUtil.getJedis();
+
+            String routekey =
+                    MicroServiceUtil.getPrefixedKey("","*", MicroServiceUtil.SUFFIX_PATH_INFO);
+            Set<String> serviceSet = jedis.keys(routekey);
+            microServiceList = new MicroServiceFullInfo[serviceSet.size()];
+
+            Pattern redisKeyPattern = MicroServiceUtil.getRedisKeyPattern();
+            int i = 0;
+            for (String servicePath : serviceSet) {
+                Matcher matcher = redisKeyPattern.matcher(servicePath);
+                if (matcher.matches()) {
+                    microServiceList[i] = getMicroServiceByJedis(jedis, matcher.group("servicename"),matcher.group("version"), "");
+                    i++;
+                }
+            }
+        } catch (Exception e) {
+            LOGGER.error("call redis throw exception", e);
+            throw new Exception("call redis throw exception:"+e.getMessage());       
+       } finally {
+            JedisUtil.returnJedisInstance(jedis);
+        }
+        
+        return microServiceList;
+    }
+
+    public void saveMicroServiceInfo2Redis(MicroServiceInfo microServiceInfo,String serverPort) throws Exception {
+        // 1.1 set info
+        String serviceInfokey =
+                MicroServiceUtil.getServiceInfoKey(serverPort,microServiceInfo.getServiceName(),
+                        microServiceInfo.getVersion());
+        Map<String, String> serviceInfoMap = new HashMap<String, String>();
+        serviceInfoMap.put("url", microServiceInfo.getUrl());
+        serviceInfoMap.put("protocol", microServiceInfo.getProtocol());
+        serviceInfoMap.put("visualRange",microServiceInfo.getVisualRange());
+        serviceInfoMap.put("lb_policy",microServiceInfo.getLb_policy());
+        serviceInfoMap.put("status", "0");
+        
+        
+
+        // 1.2 set lb info
+        String serviceLBkey =
+                MicroServiceUtil.getPrefixedKey(serverPort,microServiceInfo.getServiceName(),
+                        microServiceInfo.getVersion(), MicroServiceUtil.ROUTE_PATH_LOADBALANCE);
+
+
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtil.getJedis();
+            // 2.1 save info
+            jedis.hmset(serviceInfokey, serviceInfoMap);
+
+
+            for(Node node:microServiceInfo.getNodes()){
+               
+                String key=serviceLBkey+":"+node.getIp()+"-"+node.getPort();
+                
+                Map<String,String> nodeMap = new HashMap<String,String>();
+               
+                nodeMap.put("ip", node.getIp());
+                nodeMap.put("port", node.getPort());
+                nodeMap.put("ttl", Integer.toString(node.getTtl()));
+                long expiration_time=System.currentTimeMillis()+node.getTtl()*1000;
+                nodeMap.put("expiration", Long.toString(expiration_time));
+                
+                if(jedis.keys(key).isEmpty()){
+                    nodeMap.put("created_at",  Long.toString(System.currentTimeMillis()));
+                }
+//                else{
+//                    Map<String,String> nodeLBmap = jedis.hgetAll(key); 
+//                    nodeMap.put("created_at", nodeLBmap.get("created_at"));
+//                }
+                nodeMap.put("updated_at", Long.toString(System.currentTimeMillis()));
+                
+                jedis.hmset(key, nodeMap);
+            }
+            
+//            jedis.sadd(serviceLBkey, nodeArray);
+
+        } catch (Exception e) {
+            LOGGER.error("save to redis throw exception", e);
+            throw new Exception("save to  redis throw exception:"+e.getMessage());
+        } finally {
+            JedisUtil.returnJedisInstance(jedis);
+        }
+
+
+
+    }
+    
+    public void updateMicroServiceStatus(String serviceName, String version,String status) throws Exception{
+        
+        
+        String serviceInfokey = MicroServiceUtil.getServiceInfoKey("",serviceName, version);
+        Map<String, String> serviceInfoMap = new HashMap<String, String>();
+        serviceInfoMap.put("status", status);
+
+
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtil.borrowJedisInstance();
+            if (jedis == null) {
+                throw new Exception("fetch from jedis pool failed,null object!");
+            }
+            jedis.hmset(serviceInfokey, serviceInfoMap);
+        }
+        catch (Exception e) {
+            LOGGER.error("update MicroService status throw exception", e);
+            throw new Exception("update MicroService status throw exception:"+e.getMessage());
+        } finally {
+            JedisUtil.returnJedisInstance(jedis);
+        }
+        
+    }
+    
+    
+    public void  updateMicroServiceNode2Redis(String serviceName, String version,String ip,String port,int ttl) throws Exception {
+        String serviceLBkey =
+                MicroServiceUtil.getPrefixedKey("",serviceName,version, MicroServiceUtil.ROUTE_PATH_LOADBALANCE);
+
+
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtil.getJedis();
+          
+               
+                String nodeKey=serviceLBkey+":"+ip+"-"+port;                
+                Map<String,String> nodeLBmap = jedis.hgetAll(nodeKey);
+                
+                if(nodeLBmap.isEmpty()){
+                    throw new NullPointerException(" MicroService Node not fond ");  
+                }
+                
+               
+                nodeLBmap.put("ttl", Integer.toString(ttl));
+                long expiration_time=System.currentTimeMillis()+ttl*1000;
+                nodeLBmap.put("expiration", Long.toString(expiration_time));
+                nodeLBmap.put("updated_at", Long.toString(System.currentTimeMillis()));
+                
+                jedis.hmset(nodeKey, nodeLBmap);
+
+
+        } 
+        catch (NullPointerException e){
+            throw e;  
+        }
+        catch (Exception e) {
+            LOGGER.error("update MicroService Node throw exception", e);
+            throw new Exception("update MicroService Node throw exception:"+e.getMessage());
+        } finally {
+            JedisUtil.returnJedisInstance(jedis);
+        }
+    }
+    
+    
+    public void noticeUpdateApiListener(String serviceName,String version,Service microServiceInfo,String serverPort) {
+        if (isNeedNotify(microServiceInfo)) {
+            for (IMicroServiceChangeListener serviceListener : serviceListenerlist) {
+                serviceListener.onChange(serviceName,version, microServiceInfo,serverPort);
+            }
+        }
+        
+    }
+    
+    public void noticeUpdateStatusListener(Service microServiceInfo,String status) {
+       
+        for (IMicroServiceChangeListener serviceListener : serviceListenerlist) {
+            serviceListener.onStatusChange(microServiceInfo.getServiceName(),microServiceInfo.getUrl(),
+                    microServiceInfo.getVersion(),microServiceInfo.getProtocol(),status);
+        }
+    }
+    
+ 
+
+    public void noticeApiListener(Service microServiceInfo, String type,String serverPort) {
+        if (isNeedNotify(microServiceInfo)) {
+
+            if ("ADD".equals(type)) {
+                for (IMicroServiceChangeListener serviceListener : serviceListenerlist) {
+                    serviceListener.onSave(microServiceInfo,serverPort);
+                }
+            } else if ("DELETE".equals(type)) {
+                for (IMicroServiceChangeListener serviceListener : serviceListenerlist) {
+                    serviceListener.onDelete(microServiceInfo.getServiceName(),microServiceInfo.getUrl(),
+                            microServiceInfo.getVersion(),microServiceInfo.getProtocol(),serverPort);
+                }
+            } 
+
+        }
+    }
+
+
+    public MicroServiceFullInfo getMicroServiceInstance(String serviceName, String version,String serverPort)
+            throws Exception {
+        if (null == version || "null".equals(version)) {
+            version = "";
+        }
+
+        Jedis jedis = null;
+        MicroServiceFullInfo microServiceInfo = null;
+       
+        try {
+            jedis = JedisUtil.getJedis();
+            
+            microServiceInfo= getMicroServiceByJedis(jedis,serviceName,version, serverPort);
+
+           
+        } catch (Exception e) {
+            LOGGER.error("call redis throw exception", e);
+            throw new Exception("call redis throw exception:"+e.getMessage());
+        } finally {
+            JedisUtil.returnJedisInstance(jedis);
+        }
+        
+        return microServiceInfo;
+       
+    }
+
+    private MicroServiceFullInfo getMicroServiceByJedis(Jedis jedis,String serviceName, String version,String serverPort){
+        MicroServiceFullInfo microServiceInfo = null;
+        String serviceInfoKey = MicroServiceUtil.getServiceInfoKey(serverPort,serviceName, version);
+        Map<String, String> infomap = jedis.hgetAll(serviceInfoKey);
+        if (!infomap.isEmpty()) {
+            microServiceInfo = new MicroServiceFullInfo();
+            microServiceInfo.setServiceName(serviceName);
+            microServiceInfo.setVersion(version);
+            microServiceInfo.setUrl(infomap.get("url"));
+            microServiceInfo.setProtocol(infomap.get("protocol"));
+            microServiceInfo.setVisualRange(infomap.get("visualRange"));
+            microServiceInfo.setStatus(infomap.get("status"));
+            microServiceInfo.setLb_policy(infomap.get("lb_policy"));
+
+            String nodeLBkey =
+                    MicroServiceUtil.getPrefixedKey(serverPort,microServiceInfo.getServiceName(),
+                            microServiceInfo.getVersion(),
+                            MicroServiceUtil.ROUTE_PATH_LOADBALANCE);
+            
+            Set<String>  nodeKeys=jedis.keys(nodeLBkey+":*");
+            
+            Set<NodeInfo> nodes=new HashSet<NodeInfo>();
+            for(String nodeKey:nodeKeys){
+                Map<String,String> nodeLBmap = jedis.hgetAll(nodeKey);
+                NodeInfo nodeInfo=new NodeInfo();
+                nodeInfo.setNodeId(serviceName+"_"+nodeLBmap.get("ip")+"_"+nodeLBmap.get("port"));
+                nodeInfo.setIp(nodeLBmap.get("ip"));
+                nodeInfo.setPort(nodeLBmap.get("port"));
+                nodeInfo.setTtl(Integer.parseInt(nodeLBmap.get("ttl")));
+                nodeInfo.setCreated_at(new Date(Long.parseLong(nodeLBmap.get("created_at"))));
+                nodeInfo.setUpdated_at(new Date(Long.parseLong(nodeLBmap.get("updated_at"))));
+                nodeInfo.setExpiration(new Date(Long.parseLong(nodeLBmap.get("expiration"))));
+              
+                nodes.add(nodeInfo);
+            }
+            
+            microServiceInfo.setNodes(nodes);
+        }
+            
+           
+           
+            
+            return microServiceInfo;
+    }
+        
+
+    public void deleteMicroService(String serviceName, String version,String serverPort) throws Exception {
+        if (null == version || "null".equals(version)) {
+            version = "";
+        }
+        
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtil.getJedis();
+            String routekey = MicroServiceUtil.getPrefixedKey(serverPort,serviceName, version, "*");
+            Set<String> infoSet = jedis.keys(routekey);
+
+            String[] paths = new String[infoSet.size()];
+
+            infoSet.toArray(paths);
+
+            jedis.del(paths);
+        } catch (Exception e) {
+            LOGGER.error("call redis throw exception", e);
+            throw new Exception("call redis throw exception:"+e.getMessage());
+        } finally {
+            JedisUtil.returnJedisInstance(jedis);
+        }
+    }
+
+    public void deleteNode(String serviceName, String version, String ip,String port) throws Exception {
+        if (null == version || "null".equals(version)) {
+            version = "";
+        }
+        
+        Jedis jedis = null;
+        try {
+            jedis = JedisUtil.getJedis();
+            String serviceLBkey =
+                    MicroServiceUtil.getPrefixedKey("",serviceName, version,
+                            MicroServiceUtil.ROUTE_PATH_LOADBALANCE,ip+"-"+port);
+            jedis.del(serviceLBkey);
+        } catch (Exception e) {
+            LOGGER.error("call redis throw exception", e);
+            throw new Exception("call redis throw exception:"+e.getMessage());
+        } finally {
+            JedisUtil.returnJedisInstance(jedis);
+        }
+
+    }
+
+
+    /**
+     * Determine whether the service needs to send a notification 
+     * TODO: filter according to the agreement,
+     * the only notice of agreement for REST \ UI interface MSB - REST     
+     * @param protocol
+     * @return
+     */
+    private boolean isNeedNotifyByProtocol(String protocol) {
+        return "UI".equalsIgnoreCase(protocol) ||("REST".equalsIgnoreCase(protocol));
+    }
+    
+    /**
+     * Determine whether the service needs to send a notification 
+     * TODO: according to the visual range filter conditions   
+     * @param visualRange
+     * @return
+     */
+    private boolean isNeedNotifyByVisualRange(String visualRange) {
+        String[] rangeArray=StringUtils.split(visualRange, "|");
+        return RouteUtil.contain(RouteUtil.visualRangeMatches, rangeArray);
+    }
+
+    /**
+     * According to the MicroServiceInfo entity information to judge whether need to send a notification
+     * @param microServiceInfo
+     * @return
+     */
+    private boolean isNeedNotify(Service microServiceInfo) {
+        if (null != microServiceInfo) {
+            return isNeedNotifyByProtocol(microServiceInfo.getProtocol()) &&
+                   isNeedNotifyByVisualRange(microServiceInfo.getVisualRange());
+        } else {
+            return false;
+        }
+    }
+    
+    
+    
+}