采集终端日志相关数据至中心

hos-broker/src/main/java/com/yihu/hos/broker/common/camelrouter/CenterMongoRouter.java

@@ -16,26 +16,26 @@ public class CenterMongoRouter extends RouteBuilder {
    @Override
    public void configure() throws Exception {
        from("quartz://myGroup/myTimerName?cron=0 0 0 1 /1 * ?")
            .setBody().constant("{ \"flowType\": \"class\" }")
            .to("mongodb:mongo?database=runtime&collection=serviceFlow&operation=findOneByQuery")
            .split(simple("${body}"))
            .process(new Processor() {
                @Override
                public void process(Exchange exchange) throws Exception {
                    addMongoInfo(exchange, "runtime", "serviceFlow");
                }
            }).to("bean:centerMongoService?method=log")
            .setBody().constant("{ \"tenant\": \"yichang\" }")
            .to("mongodb:mongo?database=runtime&collection=arbiterServer&operation=findOneByQuery")
            .split(simple("${body}"))
            .process(new Processor() {
                @Override
                public void process(Exchange exchange) throws Exception {
                    addMongoInfo(exchange, "runtime", "arbiterServer");
                }
            }).to("bean:centerMongoService?method=log");
//        from("quartz://myGroup/myTimerName?cron=0 0 0 1 /1 * ?")
//            .setBody().constant("{ \"flowType\": \"class\" }")
//            .to("mongodb:mongo?database=runtime&collection=serviceFlow&operation=findOneByQuery")
//            .split(simple("${body}"))
//            .process(new Processor() {
//                @Override
//                public void process(Exchange exchange) throws Exception {
//                    addMongoInfo(exchange, "runtime", "serviceFlow");
//                }
//            }).to("bean:centerMongoService?method=log")
//
//            .setBody().constant("{ \"tenant\": \"yichang\" }")
//            .to("mongodb:mongo?database=runtime&collection=arbiterServer&operation=findOneByQuery")
//            .split(simple("${body}"))
//            .process(new Processor() {
//                @Override
//                public void process(Exchange exchange) throws Exception {
//                    addMongoInfo(exchange, "runtime", "arbiterServer");
//                }
//            }).to("bean:centerMongoService?method=log");
//
//            .setBody().constant("{ \"flowType\": \"class\" }")
//            .to("mongodb:mongo?database=runtime&collection=brokerServer&operation=findOneByQuery")

hos-broker/src/main/java/com/yihu/hos/broker/configurations/MongoConfiguration.java

@@ -21,8 +21,6 @@ public class MongoConfiguration extends AbstractMongoConfiguration {
    @Value("${spring.data.mongodb.host}")
    private String host;
    @Value("${spring.data.centerdb.host}")
    private String centerHost;
    @Value("${spring.data.mongodb.port}")
    private int port;
    @Value("${spring.data.mongodb.username}")
@@ -33,7 +31,6 @@ public class MongoConfiguration extends AbstractMongoConfiguration {
    private String authenticationDatabase;
    @Value("${spring.data.mongodb.database}")
    private String database;
    private static MongoClient mongoclient;
    @Override
    public String getDatabaseName() {
@@ -47,17 +44,8 @@ public class MongoConfiguration extends AbstractMongoConfiguration {
    }
    @Bean
    public Mongo centerMongo() throws Exception {
        return new MongoClient(singletonList(new ServerAddress(centerHost, port)),
                singletonList(MongoCredential.createCredential(username, authenticationDatabase, password.toCharArray())));
    }
    public MongoClient mongoClient() throws Exception {
        if(mongoclient == null) {
            return new MongoClient(singletonList(new ServerAddress(host, port)),
                    singletonList(MongoCredential.createCredential(username, authenticationDatabase, password.toCharArray())));
        }
        return mongoclient;
        return new MongoClient(singletonList(new ServerAddress(host, port)),
                singletonList(MongoCredential.createCredential(username, authenticationDatabase, password.toCharArray())));
    }
}

hos-broker/src/main/java/com/yihu/hos/broker/services/CenterMongoService.java

@@ -1,39 +1,25 @@
package com.yihu.hos.broker.services;
import com.mongodb.BasicDBObject;
import com.mongodb.DBCollection;
import com.mongodb.Mongo;
import com.yihu.hos.core.http.HttpClientKit;
import com.yihu.hos.core.log.Logger;
import com.yihu.hos.core.log.LoggerFactory;
import org.json.JSONArray;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.Map;
@Component("centerMongoService")
public class CenterMongoService {
    private static final Logger logger = LoggerFactory.getLogger(CenterMongoService.class);
    @Autowired
    private Mongo centerMongo;
    @Value("${hos.rest.url}")
    private String url;
    public void log(String msg) {
        JSONArray jsonArray = new JSONArray(msg);
        JSONObject info = (JSONObject) jsonArray.get(0);
        String database = info.getString("database");
        String collection = info.getString("collection");
        DBCollection center = centerMongo.getDB(database).getCollection(collection);
        JSONObject record = (JSONObject) jsonArray.get(1);
        BasicDBObject dbObject = new BasicDBObject();
        for (Object key : record.keySet()) {
            dbObject.put((String) key, record.get((String) key).toString());
        }
        try {
            center.save(dbObject);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(info);
        System.out.println(record);
        Map<String, String> params = new HashMap<>();
        params.put("msg", msg);
        String returnData = HttpClientKit.post(url + "/metric/saveToMongo", params).getBody();
        System.out.println(returnData);
    }
}

hos-broker/src/main/java/com/yihu/hos/broker/services/ServerMonitorService.java

@@ -25,9 +25,6 @@ public class ServerMonitorService {
    private static String host = SigarUtil.getHost();
    @Autowired
    private Mongo mongo;
    @Autowired
    private Mongo centerMongo;
    /**
     * 服务器健康指标采集
@@ -38,7 +35,6 @@ public class ServerMonitorService {
        try {
            BasicDBObject result = new BasicDBObject();
            DBCollection terminal = mongo.getDB(MonitorConstant.MONITOR_DATABASE).getCollection(MonitorConstant.SERVER);
            DBCollection center = centerMongo.getDB(MonitorConstant.MONITOR_DATABASE).getCollection(MonitorConstant.SERVER);
            result.put("tenant", tenant);
            result.put("create_date", DateUtil.getCurrentString(DateUtil.DEFAULT_YMDHMSDATE_FORMAT));
            result.put("create_time", new Date());
@@ -49,7 +45,6 @@ public class ServerMonitorService {
            result.put("data", cpu);
            result.put("type", MonitorConstant.CPU);
            terminal.insert(result);
            center.insert(result);
            //内存
            net.sf.json.JSONObject memory = net.sf.json.JSONObject.fromObject(SigarUtil.memory());
@@ -57,14 +52,12 @@ public class ServerMonitorService {
            result.put("type", MonitorConstant.MEMORY);
            result.remove("_id");
            terminal.insert(result);
            center.insert(result);
            //硬盘
            List<net.sf.json.JSONObject> files = JSONArray.fromObject(SigarUtil.file());
            result.put("data", files);
            result.put("type", MonitorConstant.FILES);
            result.remove("_id");
            terminal.insert(result);
            center.insert(result);
            //网络
            JSONObject net = JSONObject.fromObject(SigarUtil.net());
@@ -72,7 +65,6 @@ public class ServerMonitorService {
            result.put("type", MonitorConstant.NET);
            result.remove("_id");
            terminal.insert(result);
            center.insert(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
@@ -80,7 +72,6 @@ public class ServerMonitorService {
    public void checkHost() {
        DBCollection terminal = mongo.getDB(MonitorConstant.MONITOR_DATABASE).getCollection(MonitorConstant.HOST);
        DBCollection center = centerMongo.getDB(MonitorConstant.MONITOR_DATABASE).getCollection(MonitorConstant.HOST);
        BasicDBObject queryObject = new BasicDBObject().append(QueryOperators.AND,
                new BasicDBObject[]{
@@ -97,7 +88,6 @@ public class ServerMonitorService {
                result.put("name", hostName);
                result.put("host", host);
                terminal.insert(result);
                center.insert(result);
            } catch (Exception e) {
                e.printStackTrace();
            }

hos-broker/src/main/java/com/yihu/hos/broker/services/ServiceMonitorService.java

@@ -30,8 +30,6 @@ public class ServiceMonitorService {
    @Autowired
    private Mongo mongo;
    @Autowired
    private Mongo centerMongo;
    @Autowired
    private BrokerDao brokerDao;
    private DBCollection businessLog;
@@ -389,8 +387,6 @@ public class ServiceMonitorService {
        document.put("createTime", createTime);
        DBCollection terminal = mongo.getDB(MonitorConstant.MONITOR_DATABASE).getCollection(MonitorConstant.SERVICE);
        terminal.save(document);
        DBCollection center = centerMongo.getDB(MonitorConstant.MONITOR_DATABASE).getCollection(MonitorConstant.SERVICE);
        center.save(document);
    }
    public Integer isNull(Integer count) {

hos-broker/src/main/java/com/yihu/hos/broker/services/camel/ESBCamelService.java

@@ -1,6 +1,8 @@
package com.yihu.hos.broker.services.camel;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mongodb.Mongo;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
@@ -48,7 +50,7 @@ import java.util.ArrayList;
public class ESBCamelService {
    private static Logger logger = LogManager.getLogger(ESBCamelService.class);
    @Autowired
    private MongoConfiguration mongoConfig;
    private MongoClient mongoClient;
    private String serviceFlow = "serviceFlow";
    private String configuration = "configuration";
@@ -317,7 +319,7 @@ public class ESBCamelService {
     */
    private void deleteServiceFlow(String routeCode) {
        try {
            MongoDatabase db = mongoConfig.mongoClient().getDatabase(configuration);
            MongoDatabase db = mongoClient.getDatabase(configuration);
            MongoCollection<Document> collection = db.getCollection(serviceFlow);
            DeleteResult result = collection.deleteMany(Filters.eq("routeCode", routeCode));
        } catch (Exception e) {

hos-broker/src/main/resources/application.yml

@@ -35,8 +35,6 @@ spring:
      user: admin
      password: admin
  data:
    centerdb:
      host: 172.19.103.57
    mongodb:
      host: 172.19.103.58
      port: 27017
@@ -54,6 +52,8 @@ hos:
  arbiter:
    enable: true
    url: http://localhost:10135
  rest:
    url: http://localhost:8088
  timer:
      period: 10000
  tenant:
@@ -97,6 +97,8 @@ hos:
  arbiter:
    enable: false
    url: http://172.19.103.57:10135
  rest:
    url: http://localhost:8088
  timer:
      period: 10000
@@ -140,6 +142,8 @@ hos:
  arbiter:
    enable: true
    url: http://192.168.131.38:10135
  rest:
    url: http://localhost:8088
  timer:
      period: 10000
  tenant:

hos-rest/src/main/java/com/yihu/hos/rest/controllers/MetricController.java

@@ -0,0 +1,32 @@
package com.yihu.hos.rest.controllers;
import com.yihu.hos.rest.services.crawler.MetricManager;
import com.yihu.hos.web.framework.model.Result;
import com.yihu.hos.web.framework.util.controller.BaseController;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.annotation.Resource;
/**
 * 应用管理
 */
@RequestMapping("/metric")
@Controller
public class MetricController extends BaseController {
    @Resource(name = MetricManager.BEAN_ID)
    private MetricManager metricManager;
    @RequestMapping("/saveToMongo")
    @ResponseBody
    public Result saveToMongo(String msg) {
        try {
            Result result = metricManager.saveToMongo(msg);
            return result;
        } catch (Exception ex) {
            ex.printStackTrace();
            return Result.error(ex.getMessage());
        }
    }
}

hos-rest/src/main/java/com/yihu/hos/rest/services/crawler/MetricManager.java

@@ -0,0 +1,38 @@
package com.yihu.hos.rest.services.crawler;
import com.yihu.ehr.dbhelper.mongodb.MongodbHelper;
import com.yihu.hos.web.framework.model.Result;
import org.json.JSONArray;
import org.json.JSONObject;
import org.springframework.stereotype.Service;
@Service("MetricManager")
public class MetricManager {
    public static final String BEAN_ID = "MetricManager";
    MongodbHelper mongoLog = new MongodbHelper("log");
    MongodbHelper mongoRuntime = new MongodbHelper("runtime");
    public Result saveToMongo(String msg) {
        JSONArray jsonArray = new JSONArray(msg);
        JSONObject info = (JSONObject) jsonArray.get(0);
        String database = info.getString("database");
        MongodbHelper mongo;
        if (database.equals("log")) {
            mongo = mongoLog;
        } else {
            mongo = mongoRuntime;
        }
        String collection = info.getString("collection");
        JSONObject record = (JSONObject) jsonArray.get(1);
        JSONObject jsonObject = new JSONObject();
        for (Object key : record.keySet()) {
            jsonObject.put((String) key, record.get((String) key).toString());
        }
        try {
            mongo.insert(collection, jsonObject);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.success("保存成功！");
    }
}

src/main/java/com/yihu/hos/common/graph/BFSGraph.java

@@ -0,0 +1,366 @@
package com.yihu.hos.common.graph;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.*;
/**
 * 邻接链表（Adjacency List）实现的有向图
 * @param <V>
 */
public class BFSGraph<V> implements DGraph<V>{
    private static Logger logger = LoggerFactory.getLogger(BFSGraph.class);
    /**
     * 顶点对象，其中有对应的顶点以及从以此顶点为起点的边
     */
    private class VE {
        /**此顶点*/
        private V v;
        /**以此顶点为起点的边的集合，是一个列表，列表的每一项是一条边*/
        private List<Edge<V>> mEdgeList;
        
        /**
         * 构造一个新的顶点对象
         * @param v
         */
        public VE(V v) {
            this.v = v;
            this.mEdgeList = new LinkedList<Edge<V>>();
            logger.info("VE construct : %s", v);
        }
        
        @Override
        public String toString() {
            String ret = String.format("v : %s , list len : %s",
                                       v, mEdgeList.size());
            return ret;
        }
        
        /**
         * 将一条边添加到边集合中
         * @param e
         */
        public void addEdge(Edge<V> e) {
            logger.info("add edge : %s", e);
            if(getEdge(e.getDest()) == null) {
                mEdgeList.add(e);
            } else {
                logger.info("edge exist : %s", e);
            }
        }
        
        /**
         * 读取某条边
         * @param dest
         * @return
         */
        public Edge<V> getEdge(V dest) {
            Edge<V> ret = null;
            if(dest != null) {
                for(Edge<V> edge : mEdgeList) {
                    if(edge.getDest() != null &&
                       dest.equals(edge.getDest())) {
                        logger.info("get edge : %s", edge);
                        ret = edge;
                        break;
                    }
                }
            }
            return ret;
        }
        
        /**
         * 读取某条边
         * @param dest
         * @return
         */
        public Edge<V> removeEdge(V dest) {
            Edge<V> ret = null;
            if(dest != null) {
                for(Edge<V> edge : mEdgeList) {
                    if(edge.getDest() != null &&
                       dest.equals(edge.getDest())) {
                        logger.info("remove edge : %s", edge);
                        ret = edge;
                        mEdgeList.remove(edge);
                        break;
                    }
                }
            }
            return ret;
        }
    }
    
    /**
     * 广度优先的迭代器
     */
    private class BFSIterator implements Iterator<V> {
        /**已访问过的顶点列表*/
        private List<V> mVisitList = null;
        /**待访问的顶点队列*/
        private Queue<V> mVQueue = null;
        
        /**
         * 构造广度优先迭代器
         * @param root
         */
        public BFSIterator(V root) {
            mVisitList = new LinkedList<V>();
            mVQueue = new LinkedList<V>();
            
            //将初始节点入队列
            mVQueue.offer(root);
        }
        
        @Override
        public boolean hasNext() {
            logger.info("queue size : " + mVQueue.size());
            if(mVQueue.size() > 0) {
                return true;
            } else {
                return false;
            }
        }
        @Override
        public V next() {
            //1.取队列元素
            V v = mVQueue.poll();
            
            if(v != null) {
                //2.将此元素的邻接边中对应顶点入队列，这些顶点需要符合以下条件：
                //1)没访问过；
                //2)不在队列中；
                VE ve = getVE(v);
                if(ve != null) {
                    List<Edge<V>> list = ve.mEdgeList;
                    for(Edge<V> edge : list) {
                        V dest = edge.getDest();
                        if(!VinList(dest, mVisitList.iterator()) &&
                           !VinList(dest, mVQueue.iterator())) {
                            mVQueue.offer(dest);
                            logger.info("add to queue : " + dest);
                        }
                    }
                }
                
                //3.将此顶点添加到已访问过的顶点列表中
                mVisitList.add(v);
            }
            
            //4.返回出队列的元素
            return v;
        }
        @Override
        public void remove() {
            // 暂时不实现
        }
        
    }
    
    /**顶点列表，由于会经常进行插入删除，使用链表队列*/
    private LinkedList<VE> mVEList;
    /**
     * 构造邻接链表有向图
     */
    public BFSGraph() {
        mVEList = new LinkedList<VE>();
        logger.info("ListDGraph construct!");
    }
    @Override
    public int add(V v) {
        int index = -1;
        if(v != null) {
            logger.info("add v: %s", v);
            VE ve = new VE(v);
            mVEList.add(ve);
            index = mVEList.indexOf(ve);
        }
        return index;
    }
    @Override
    public void add(Edge<V> e) {
        if(e != null) {
            logger.info("add edge: %s", e);
            VE ve = getVE(e.getSource());
            if(ve != null) {
                //若边的起点已经在列表里，则直接将其添加到对应的顶点对象中
                ve.addEdge(e);
            } else {
                //否则提示错误
                logger.info("Error, can't find v : %s", e.getSource());
            }
        }
    }
    
    @Override
    public V remove(V v) {
        V ret = null;
        
        VE ve = removeVE(v);
        if(ve != null) {
            ret = ve.v;
        }
        
        removeRelateEdge(v);
        
        return ret;
    }
    @Override
    public Edge<V> remove(Edge<V> e) {
        Edge<V> ret = null;
        
        if(e != null) {
            VE ve = getVE(e.getSource());
            if(ve != null) {
                ret = ve.removeEdge(e.getDest());
            }
        }
        
        return ret;
    }
    @Override
    public V get(int index) {
        V ret = null;
        if(index >=0 && index < mVEList.size()) {
            VE ve = mVEList.get(index);
            if(ve != null) {
                ret = ve.v;
                logger.info("get , index : %s , v : %s", index, ret);
            }
        }
        return ret;
    }
    @Override
    public Edge<V> get(int src, int dest) {
        Edge<V> ret = null;
        V s = get(src);
        V d = get(dest);
        if(s != null && d != null) {
            VE ve = getVE(s);
            if(ve != null) {
                ret = ve.getEdge(d);
            }
        }
        return ret;
    }
    @Override
    public Iterator<V> iterator(V root) {
        Iterator<V> ret = null;
            //广度优先的迭代器
        ret = new BFSIterator(root);
        return ret;
    }
    @Override
    public void convertDAG() {
        // TODO Auto-generated method stub
        
    }
    /**
     * 从顶点对象列表中读取输入顶点对应的所有边对象
     * @param v
     * @return
     */
    @Override
    public List<Edge<V>> getEdgeList(V v) {
        List<Edge<V>> edgeList = new ArrayList<>();
        VE ret = null;
        if(v != null) {
            for(VE ve : mVEList) {
                if(ve.v != null && v.equals(ve.v)) {
                    logger.info("getVE : %s", ve);
                    ret = ve;
                    break;
                }
            }
        }
        if (ret != null) {
            return ret.mEdgeList;
        }
        return edgeList;
    }
    //////////////////////////////私有方法//////////////////////////////
    /**
     * 从顶点对象列表中读取输入顶点对应的对象
     * @param v
     * @return
     */
    public VE getVE(V v) {
        VE ret = null;
        if(v != null) {
            for(VE ve : mVEList) {
                if(ve.v != null && v.equals(ve.v)) {
                    logger.info("getVE : %s", ve);
                    ret = ve;
                    break;
                }
            }
        }
        return ret;
    }
    /**
     * 从顶点对象列表中删除输入顶点对应的对象
     * @param v
     * @return 删除的顶点对象
     */
    private VE removeVE(V v) {
        VE ret = null;
        if(v != null) {
            for(VE ve : mVEList) {
                if(ve.v != null && v.equals(ve.v)) {
                    logger.info("removeVE : %s", v);
                    ret = ve;
                    mVEList.remove(ve);
                    break;
                }
            }
        }
        return ret;
    }
    
    /**
     * 删除以某个点作为重点的边
     * @param v
     */
    private void removeRelateEdge(V v) {
        if(v != null) {
            for(VE ve : mVEList) {
                ve.removeEdge(v);
            }
        }
    }
    
    /**
     * 判断某个端点是否在某个列表里
     * @param v
     * @param it
     * @return
     */
    private boolean VinList(V v, Iterator<V> it) {
        boolean ret = false;
        
        if(v != null && it != null) {
            while(it.hasNext()) {
                V v_temp = it.next();
                if(v_temp != null && v_temp.equals(v)) {
                    ret = true;
                    break;
                }
            }
        }
        
        return ret;
    }
}

src/main/java/com/yihu/hos/common/graph/DGraph.java

@@ -0,0 +1,75 @@
package com.yihu.hos.common.graph;
import java.util.Iterator;
import java.util.List;
/**
 * 有向图接口，定义需要实现的各个方法，可以选择使用邻接矩阵或者邻接链表来实现
 * @param <V> V代表端点，可以根据需要设置器数据类型
 */
public interface DGraph<V> {
    
    /**广度优先遍历*/
    public static final int ITERATOR_TYPE_BFS = 0;
    
    /**
     * 添加一个端点
     * @param v
     * @return 新增端点的编号，-1表示插入失败
     */
    public int add(V v);
    
    /**
     * 添加一个边
     * @param e
     */
    public void add(Edge<V> e);
    
    /**
     * 删除一个顶点，与其相连的边也会被删除
     * @param v
     * @return 被删除的顶点，如果找不到对应顶点则返回null
     */
    public V remove(V v);
    
    /**
     * 删除一条边
     * @param e
     * @return 被删除的边，如果找不到对应的边则返回null
     */
    public Edge<V> remove(Edge<V> e);
    
    /**
     * 获得一个顶点
     * @param index 顶点的编号
     * @return
     */
    public V get(int index);
    
    /**
     * 获得一条边
     * @param src 起点的编号
     * @param dest 终点的编号
     * @return
     */
    public Edge<V> get(int src, int dest);
    
    /**
     * 得到当前图的迭代器，用于对图进行遍历
     * @param root 从哪个点开始遍历
     * @return
     */
    public Iterator<V> iterator(V root);
    
    /**
     * 将图转换为无环图
     */
    public void convertDAG();
    /**
     * 从顶点对象列表中读取输入顶点对应的所有边对象
     * @param v
     * @return
     */
    public List<Edge<V>> getEdgeList(V v);
}

src/main/java/com/yihu/hos/common/graph/Edge.java

@@ -0,0 +1,56 @@
package com.yihu.hos.common.graph;
/**
 * 一条边，可以根据需要继承此类
 * @param <V>
 */
public class Edge<V> {
    /**起点*/
    private V src;
    /**终点*/
    private V dest;
    /**名称*/
    private V name;
    
    /**
     * 带名称的一条边
     * @param src
     * @param dest
     * @param name
     */
    public Edge(V src, V dest, V name) {
        this.src = src;
        this.dest = dest;
        this.name = name;
    }
    
    /**
     * 获取起点
     * @return
     */
    public V getSource() {
        return this.src;
    }
    
    /**
     * 获取终点
     * @return
     */
    public V getDest() {
        return this.dest;
    }
    
    /**
     * 获取名称
     * @return
     */
    public V getName() {
        return this.name;
    }
    
    @Override
    public String toString() {
        String ret = String.format("src : %s , dest : %s , weight : %s", src, dest, name);
        return ret;
    }
}

src/main/java/com/yihu/hos/config/MongoConfig.java

@@ -1,5 +1,6 @@
package com.yihu.hos.config;
import com.mongodb.Mongo;
import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
@@ -26,15 +27,16 @@ public class MongoConfig {
    @Value("${spring.data.mongodb.authenticationDatabase}")
    private String authenticationDatabase;
    private static MongoClient mongo;
    @Bean
    public MongoClient mongoClient() throws Exception {
        if(mongo == null) {
            return new MongoClient(singletonList(new ServerAddress(host, port)),
                    singletonList(MongoCredential.createCredential(username, authenticationDatabase, password.toCharArray())));
        }
        return mongo;
        return new MongoClient(singletonList(new ServerAddress(host, port)),
                singletonList(MongoCredential.createCredential(username, authenticationDatabase, password.toCharArray())));
    }
    @Bean
    public Mongo mongo() throws Exception {
        return new MongoClient(singletonList(new ServerAddress(host, port)),
                singletonList(MongoCredential.createCredential(username, authenticationDatabase, password.toCharArray())));
    }
    public String getHost() {

src/main/java/com/yihu/hos/system/service/ProcessManager.java

@@ -2,6 +2,9 @@ package com.yihu.hos.system.service;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yihu.hos.common.graph.BFSGraph;
import com.yihu.hos.common.graph.DGraph;
import com.yihu.hos.common.graph.Edge;
import com.yihu.hos.config.MongoConfig;
import com.yihu.hos.core.datatype.StringUtil;
import com.yihu.hos.core.encrypt.DES;
@@ -108,60 +111,41 @@ public class ProcessManager {
                "        }\n" +
                "    }\n" +
                "}";
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode flowJson = objectMapper.readValue(flowJsonStr, JsonNode.class);
        String code = flowJson.get("code").asText();
        //sort flow by lines
        JsonNode lines = flowJson.get("lines");
        Iterator<JsonNode> lineIterator = lines.iterator();
        String[] nodeNameArray = new String[lines.size() + 1];
        Boolean isFirstLineFlg = true;
        while (lineIterator.hasNext()) {
            JsonNode line = lineIterator.next();
            String nodeNameFrom = line.get("from").asText();
            String nodeNameTo = line.get("to").asText();
            if (isFirstLineFlg) {
                nodeNameArray[0] = nodeNameFrom;
                nodeNameArray[1] = nodeNameTo;
                isFirstLineFlg = false;
                continue;
            }
            for (int i=0; i<nodeNameArray.length; i++) {
                if (nodeNameArray[i].equals(nodeNameFrom)) {
                    if (StringUtil.isEmpty(nodeNameArray[i + 1])) {
                        nodeNameArray[i + 1] = nodeNameTo;
                    } else {
                        insertArray(nodeNameTo, nodeNameArray, i + 1);
                    }
                    break;
                } else if (nodeNameArray[i].equals(nodeNameTo)) {
                    insertArray(nodeNameFrom, nodeNameArray, i);
                }
            }
        }
        JsonNode lines = flowJson.get("lines");
        Iterator<Map.Entry<String, JsonNode>> lineIterator = lines.fields();
        //get nodeMap by nodes
        JsonNode nodes = flowJson.get("nodes");
        Map<String, JsonNode> nodeMap = new HashMap<>();
        Iterator<Map.Entry<String, JsonNode>> nodeIterator = nodes.fields();
        //for the java code import processor class
        List<String> processorImport = new ArrayList<>();
        Map<String, JsonNode> nodeMap = new HashMap<>();
        Map<String, JsonNode> lineMap = new HashMap<>();
        DGraph<String> mDG = new BFSGraph<String>();
        while (nodeIterator.hasNext()) {
            Map.Entry<String, JsonNode> map = nodeIterator.next();
            JsonNode node = map.getValue();
            String type = node.get("type").asText();
            if (type.equals("processor")) {
                processorImport.add(node.get("value").asText());
            }
            nodeMap.put(map.getKey(), map.getValue());
            mDG.add(map.getKey());
        }
        while (lineIterator.hasNext()) {
            Map.Entry<String, JsonNode> map = lineIterator.next();
            lineMap.put(map.getKey(), map.getValue());
            String nodeNameFrom = map.getValue().get("from").asText();
            String nodeNameTo = map.getValue().get("to").asText();
            mDG.add(new Edge<String>(nodeNameFrom, nodeNameTo, map.getKey()));
        }
        //generate the java code
        return generate(code, processorImport, nodeMap, nodeNameArray);
        return generate(code, lineMap, nodeMap, mDG);
    }
    public String generate(String code, List<String> processorImport, Map<String, JsonNode> nodeMap, String[] nodeNameArray) throws IOException {
    public String generate(String code, Map<String, JsonNode> lineMap, Map<String, JsonNode> nodeMap, DGraph<String> mDG) throws IOException {
        Boolean isFirstNodeFlg = true;
        StringBuilder javaBuilder = new StringBuilder();
        String javaName = toUpperCaseFirstOne(code)+"Route";
@@ -169,14 +153,19 @@ public class ProcessManager {
        javaBuilder.append("package "+code+".route;\n\n");
        javaBuilder.append("import org.apache.camel.Exchange;\n");
        javaBuilder.append("import org.apache.camel.builder.RouteBuilder;\n");
        for (String packageName : processorImport) {
            javaBuilder.append("import " + packageName + ";\n");
        for (String key : nodeMap.keySet()) {
            JsonNode node = nodeMap.get(key);
            String type = node.get("type").asText();
            if (type.equals("processor")) {
                javaBuilder.append("import " + node.get("value").asText() + ";\n");
            }
        }
        javaBuilder.append("public class "+javaName+" extends RouteBuilder {\n");
        javaBuilder.append("public void configure() throws Exception {\n");
        for (int i=0;i<nodeNameArray.length;i++) {
            String nodeName = nodeNameArray[i];
        Iterator<String> it = mDG.iterator("1");
        while(it.hasNext()) {
            String nodeName = it.next();
            JsonNode node = nodeMap.get(nodeName);
            String type = node.get("type").asText();
            String value = node.get("value").asText();
@@ -190,26 +179,7 @@ public class ProcessManager {
                if (type.equals("processor")) {
                    javaBuilder.append("\n.process(\"new "+name+"())");
                } else if (type.equals("judgement")) {
                    String correctNodeName = value.split(",")[1];
                    value = value.split(",")[0];
                    javaBuilder.append("\n.when("+value+")");
                    String nodeName1 = nodeNameArray[++i];
                    JsonNode node1 = nodeMap.get(nodeName1);
                    String nodeName2 = nodeNameArray[++i];
                    JsonNode node2 = nodeMap.get(nodeName2);
                    String firstValue = node1.get("value").asText();
                    String secondValue =  node2.get("value").asText();
                    if (!correctNodeName.equals(nodeName1)) {
                        secondValue = node1.get("value").asText();
                        firstValue =  node2.get("value").asText();
                    }
                    javaBuilder.append("\n.setHeader(Exchange.HTTP_METHOD, constant(\"POST\"))");
                    javaBuilder.append("\n.to(\"");
                    javaBuilder.append(firstValue + "\")");
                    javaBuilder.append(".otherwise()");
                    javaBuilder.append("\n.setHeader(Exchange.HTTP_METHOD, constant(\"POST\"))");
                    javaBuilder.append("\n.to(\"");
                    javaBuilder.append(secondValue + "\")");
                    judgement(javaBuilder, value, nodeName, mDG, it, lineMap, nodeMap);
                } else {
                    javaBuilder.append("\n.setHeader(Exchange.HTTP_METHOD, constant(\"POST\"))");
                    javaBuilder.append("\n.to(\"");
@@ -217,6 +187,7 @@ public class ProcessManager {
                }
            }
        }
        javaBuilder.append("\n}\n}");
        System.out.println(javaBuilder.toString());
@@ -243,14 +214,6 @@ public class ProcessManager {
        return "";
    }
    public void insertArray(String nodeName, String[] array, int index) {
        for (int i=index; i<array.length; i++) {
            String nodeNameTemp = array[i];
            array[i] = nodeName;
            nodeName = nodeNameTemp;
        }
    }
    //首字母转大写
    public String toUpperCaseFirstOne(String s) {
        if(Character.isUpperCase(s.charAt(0)))
@@ -258,4 +221,36 @@ public class ProcessManager {
        else
            return (new StringBuilder()).append(Character.toUpperCase(s.charAt(0))).append(s.substring(1)).toString();
    }
    public void judgement(StringBuilder javaBuilder, String value, String nodeName, DGraph<String> mDG, Iterator<String> it,  Map<String, JsonNode> lineMap, Map<String, JsonNode> nodeMap) {
        javaBuilder.append("\n.when("+value+")");
        List<Edge<String>> edgeList = mDG.getEdgeList(nodeName);
        String trueNodeName = "";
        String falseNodeName = "";
        for (Edge<String> edge : edgeList) {
            String nextNodeName = edge.getDest();
            String nextLineName = edge.getName();
            JsonNode nextLine = lineMap.get(nextLineName);
            if (nextLine.get("value").asText().equals("right")) {
                trueNodeName = nextNodeName;
            } else {
                falseNodeName = nextNodeName;
            }
        }
        JsonNode node1 = nodeMap.get(trueNodeName);
        JsonNode node2 = nodeMap.get(falseNodeName);
        String firstValue = node1.get("value").asText();
        String secondValue =  node2.get("value").asText();
        javaBuilder.append("\n.setHeader(Exchange.HTTP_METHOD, constant(\"POST\"))");
        javaBuilder.append("\n.to(\"");
        javaBuilder.append(firstValue + "\")");
        javaBuilder.append(".otherwise()");
        javaBuilder.append("\n.setHeader(Exchange.HTTP_METHOD, constant(\"POST\"))");
        javaBuilder.append("\n.to(\"");
        javaBuilder.append(secondValue + "\")");
        it.next();
        it.next();
    }
}

src/test/java/com/yihu/hos/BFSGraphTest.java

@@ -0,0 +1,57 @@
package com.yihu.hos;
import com.yihu.hos.common.graph.DGraph;
import com.yihu.hos.common.graph.Edge;
import com.yihu.hos.common.graph.BFSGraph;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Iterator;
public class BFSGraphTest {
    private static Logger logger = LoggerFactory.getLogger(BFSGraphTest.class);
    DGraph<String> mDG = new BFSGraph<String>();
    @Test
    public void testAll() {
        logger.info("===============add v=================");
        
        mDG.add("1");
        mDG.add("2");
        mDG.add("3");
        mDG.add("4");
        mDG.add("5");
        mDG.add("6");
        mDG.add("7");
        mDG.add("8");
        logger.info("===============add edge=================");
        
        mDG.add(new Edge<String>("1", "2"));
        mDG.add(new Edge<String>("1", "3"));
        mDG.add(new Edge<String>("2", "4"));
        mDG.add(new Edge<String>("2", "5"));
        mDG.add(new Edge<String>("3", "6"));
        mDG.add(new Edge<String>("3", "7"));
        mDG.add(new Edge<String>("4", "8"));
        mDG.add(new Edge<String>("8", "5"));
        mDG.add(new Edge<String>("6", "7"));
        
        logger.info("===============test travelling=================");
        
        Iterator<String> it = mDG.iterator("1");
        while(it.hasNext()) {
            String s = it.next();
            System.out.println("next : " + s);
        }
        
        mDG.get(0);
        
        mDG.get(0, 1);
        
        mDG.remove("6");
        
        mDG.remove(new Edge<String>("3", "7"));
    }
}