根据自定义arangoRDD重构代码

IP-learning-graph/pom.xml

@@ -39,6 +39,12 @@
             <version>1.2.1</version>
         </dependency>
 
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+        </dependency>
+
         <dependency>
             <groupId>com.arangodb</groupId>
             <artifactId>arangodb-java-driver</artifactId>

IP-learning-graph/src/main/java/cn/ac/iie/dao/BaseArangoData.java

@@ -0,0 +1,145 @@
+package cn.ac.iie.dao;
+
+import cn.ac.iie.config.ApplicationConfig;
+import cn.ac.iie.service.ingestion.ReadHistoryArangoData;
+import cn.ac.iie.utils.ArangoDBConnect;
+import cn.ac.iie.utils.ExecutorThreadPool;
+import com.arangodb.ArangoCursor;
+import com.arangodb.entity.BaseDocument;
+import com.arangodb.entity.BaseEdgeDocument;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+
+/**
+ * 获取arangoDB历史数据
+ */
+public class BaseArangoData {
+    private static final Logger LOG = LoggerFactory.getLogger(BaseArangoData.class);
+
+    static ConcurrentHashMap<Integer,ConcurrentHashMap<String, BaseDocument>> historyVertexFqdnMap = new ConcurrentHashMap<>();
+    static ConcurrentHashMap<Integer,ConcurrentHashMap<String, BaseDocument>> historyVertexIpMap = new ConcurrentHashMap<>();
+    static ConcurrentHashMap<Integer,ConcurrentHashMap<String, BaseDocument>> historyVertexSubscriberMap = new ConcurrentHashMap<>();
+    static ConcurrentHashMap<Integer,ConcurrentHashMap<String, BaseEdgeDocument>> historyRelationFqdnAddressIpMap = new ConcurrentHashMap<>();
+    static ConcurrentHashMap<Integer,ConcurrentHashMap<String, BaseEdgeDocument>> historyRelationIpVisitFqdnMap = new ConcurrentHashMap<>();
+    static ConcurrentHashMap<Integer,ConcurrentHashMap<String, BaseEdgeDocument>> historyRelationFqdnSameFqdnMap = new ConcurrentHashMap<>();
+    static ConcurrentHashMap<Integer,ConcurrentHashMap<String, BaseEdgeDocument>> historyRelationSubsciberLocateIpMap = new ConcurrentHashMap<>();
+
+    private static ArangoDBConnect arangoDBConnect = ArangoDBConnect.getInstance();
+
+    private ExecutorThreadPool threadPool = ExecutorThreadPool.getInstance();
+
+    <T extends BaseDocument> void readHistoryData(String table,
+                                                  ConcurrentHashMap<Integer,ConcurrentHashMap<String, T>> map,
+                                                  Class<T> type) {
+        try {
+            LOG.info("开始更新"+table);
+            long start = System.currentTimeMillis();
+            for (int i = 0; i < ApplicationConfig.THREAD_POOL_NUMBER; i++){
+                map.put(i,new ConcurrentHashMap<>());
+            }
+            CountDownLatch countDownLatch = new CountDownLatch(ApplicationConfig.THREAD_POOL_NUMBER);
+//            long[] timeRange = getTimeRange(table);
+            Long countTotal = getCountTotal(table);
+            for (int i = 0; i < ApplicationConfig.THREAD_POOL_NUMBER; i++) {
+//                String sql = getQuerySql(timeRange, i, table);
+                String sql = getQuerySql(countTotal, i, table);
+                ReadHistoryArangoData<T> readHistoryArangoData =
+                        new ReadHistoryArangoData<>(arangoDBConnect, sql, map,type,table,countDownLatch);
+                threadPool.executor(readHistoryArangoData);
+            }
+            countDownLatch.await();
+            long last = System.currentTimeMillis();
+            LOG.info("读取"+table+" arangoDB 共耗时："+(last-start));
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+    }
+
+    public <T extends BaseDocument> ConcurrentHashMap<Integer,ConcurrentHashMap<String, T>> readHistoryData(String table, Class<T> type){
+        ConcurrentHashMap<Integer,ConcurrentHashMap<String, T>> map = new ConcurrentHashMap<>();
+        try {
+            LOG.info("开始更新"+table);
+            long start = System.currentTimeMillis();
+            for (int i = 0; i < ApplicationConfig.THREAD_POOL_NUMBER; i++){
+                map.put(i,new ConcurrentHashMap<>());
+            }
+            CountDownLatch countDownLatch = new CountDownLatch(ApplicationConfig.THREAD_POOL_NUMBER);
+            Long countTotal = getCountTotal(table);
+            for (int i = 0; i < ApplicationConfig.THREAD_POOL_NUMBER; i++) {
+                String sql = getQuerySql(countTotal, i, table);
+                ReadHistoryArangoData<T> readHistoryArangoData =
+                        new ReadHistoryArangoData<>(arangoDBConnect, sql, map,type,table,countDownLatch);
+                threadPool.executor(readHistoryArangoData);
+            }
+            countDownLatch.await();
+            long last = System.currentTimeMillis();
+            LOG.info("读取"+table+" arangoDB 共耗时："+(last-start));
+        }catch (Exception e){
+            e.printStackTrace();
+            LOG.error("读取历史数据失败 "+e.toString());
+        }
+        return map;
+    }
+
+    private long[] getTimeRange(String table){
+        long minTime = 0L;
+        long maxTime = 0L;
+        long startTime = System.currentTimeMillis();
+        String sql = "LET doc = (FOR doc IN "+table+" RETURN doc) return {max_time:MAX(doc[*].FIRST_FOUND_TIME),min_time:MIN(doc[*].FIRST_FOUND_TIME)}";
+        ArangoCursor<BaseDocument> timeDoc = arangoDBConnect.executorQuery(sql, BaseDocument.class);
+        try {
+            if (timeDoc != null){
+                while (timeDoc.hasNext()) {
+                    BaseDocument doc = timeDoc.next();
+                    maxTime = Long.parseLong(doc.getAttribute("max_time").toString()) + ApplicationConfig.THREAD_POOL_NUMBER;
+                    minTime = Long.parseLong(doc.getAttribute("min_time").toString());
+                }
+                long lastTime = System.currentTimeMillis();
+                LOG.info(sql+"\n查询最大最小时间用时：" + (lastTime - startTime));
+            }else {
+                LOG.warn("获取ArangoDb时间范围为空");
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+        return new long[]{minTime, maxTime};
+
+    }
+
+    private Long getCountTotal(String table){
+        long start = System.currentTimeMillis();
+        Long cnt = 0L;
+        String sql = "RETURN LENGTH("+table+")";
+        try {
+            ArangoCursor<Long> longs = arangoDBConnect.executorQuery(sql, Long.class);
+            while (longs.hasNext()){
+                cnt = longs.next();
+            }
+        }catch (Exception e){
+            LOG.error(sql +"执行异常");
+        }
+        long last = System.currentTimeMillis();
+        LOG.info(sql+" 结果："+cnt+" 执行时间："+(last-start));
+        return cnt;
+    }
+
+    private String getQuerySql(Long cnt,int threadNumber, String table){
+        long sepNum = cnt / ApplicationConfig.THREAD_POOL_NUMBER + 1;
+        long offsetNum = threadNumber * sepNum;
+        return "FOR doc IN " + table + " limit "+offsetNum+","+sepNum+" RETURN doc";
+    }
+
+
+    private String getQuerySql(long[] timeRange,int threadNumber,String table){
+        long minTime = timeRange[0];
+        long maxTime = timeRange[1];
+        long diffTime = (maxTime - minTime) / ApplicationConfig.THREAD_POOL_NUMBER;
+        long maxThreadTime = minTime + (threadNumber + 1)* diffTime;
+        long minThreadTime = minTime + threadNumber * diffTime;
+        return "FOR doc IN "+table+" filter doc.FIRST_FOUND_TIME >= "+minThreadTime+" and doc.FIRST_FOUND_TIME <= "+maxThreadTime+" " + ApplicationConfig.ARANGODB_READ_LIMIT + " RETURN doc";
+    }
+
+}

IP-learning-graph/src/main/java/cn/ac/iie/dao/BaseClickhouseData.java

@@ -35,10 +35,11 @@ public class BaseClickhouseData {
     private DruidPooledConnection connection;
     private Statement statement;
 
-    <T extends BaseDocument> HashMap<Integer, HashMap<String,ArrayList<T>>> baseDocumentFromClickhouse(Supplier<String> getSqlSupplier,
+    <T extends BaseDocument> void baseDocumentFromClickhouse(HashMap<Integer, HashMap<String, ArrayList<T>>> newMap,
+                                                             Supplier<String> getSqlSupplier,
                                                              Function<ResultSet,T> formatResultFunc) {
         long start = System.currentTimeMillis();
-        HashMap<Integer, HashMap<String, ArrayList<T>>> newMap = initializeMap();
+        initializeMap(newMap);
         String sql = getSqlSupplier.get();
         try {
             connection = manger.getConnection();
@@ -59,7 +60,48 @@ public class BaseClickhouseData {
         }finally {
             manger.clear(statement,connection);
         }
-        return newMap;
+    }
+
+    private <T extends BaseDocument> void initializeMap(HashMap<Integer, HashMap<String,ArrayList<T>>> map){
+        try {
+            for (int i = 0; i < ApplicationConfig.THREAD_POOL_NUMBER; i++) {
+                map.put(i, new HashMap<>());
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+            LOG.error("初始化数据失败");
+        }
+    }
+
+    public <T extends BaseDocument> HashMap<Integer, HashMap<String,ArrayList<T>>> baseDocFromCk(Supplier<String> getSqlSupplier,
+                                                             Function<ResultSet,T> formatResultFunc){
+        long start = System.currentTimeMillis();
+        HashMap<Integer, HashMap<String, ArrayList<T>>> newDataMap = initializeMap();
+        if (newDataMap == null){
+            return null;
+        }
+        String sql = getSqlSupplier.get();
+        try {
+            connection = manger.getConnection();
+            statement = connection.createStatement();
+            ResultSet resultSet = statement.executeQuery(sql);
+            int i = 0;
+            while (resultSet.next()) {
+                T newDoc = formatResultFunc.apply(resultSet);
+                if (newDoc != null) {
+                    i+=1;
+                    putMapByHashcode(newDoc, newDataMap);
+                }
+            }
+            long last = System.currentTimeMillis();
+            LOG.info(sql + "\n读取"+i+"条数据，运行时间：" + (last - start));
+        }catch (Exception e){
+            e.printStackTrace();
+            LOG.error("获取原始数据失败 "+e.toString());
+        }finally {
+            manger.clear(statement,connection);
+        }
+        return newDataMap;
     }
 
     private <T extends BaseDocument> HashMap<Integer, HashMap<String,ArrayList<T>>> initializeMap(){
@@ -74,8 +116,8 @@ public class BaseClickhouseData {
             LOG.error("数据初始化失败 "+e.toString());
             return null;
         }
-    }
 
+    }
 
 
 }

IP-learning-graph/src/main/java/cn/ac/iie/dao/UpdateGraphData.java

@@ -4,8 +4,15 @@ import cn.ac.iie.config.ApplicationConfig;
 import cn.ac.iie.service.ingestion.ReadClickhouseData;
 import cn.ac.iie.service.update.Document;
 import cn.ac.iie.service.update.relationship.LocateFqdn2Ip;
+import cn.ac.iie.service.update.relationship.LocateSubscriber2Ip;
+import cn.ac.iie.service.update.relationship.VisitIp2Fqdn;
+import cn.ac.iie.service.update.vertex.Fqdn;
+import cn.ac.iie.service.update.vertex.Ip;
+import cn.ac.iie.service.update.vertex.Subscriber;
+import cn.ac.iie.utils.ArangoDBConnect;
 import cn.ac.iie.utils.ExecutorThreadPool;
 import com.arangodb.entity.BaseDocument;
+import com.arangodb.entity.BaseEdgeDocument;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -13,10 +20,14 @@ import java.lang.reflect.Constructor;
 import java.sql.ResultSet;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
+import static cn.ac.iie.dao.BaseArangoData.*;
+import static cn.ac.iie.dao.BaseClickhouseData.*;
+
 /**
  * 更新图数据库业务类
  * @author wlh
@@ -24,46 +35,109 @@ import java.util.function.Supplier;
 public class UpdateGraphData {
     private static final Logger LOG = LoggerFactory.getLogger(UpdateGraphData.class);
     private static ExecutorThreadPool pool = ExecutorThreadPool.getInstance();
+    private static ArangoDBConnect arangoManger = ArangoDBConnect.getInstance();
+    private static BaseArangoData baseArangoData = new BaseArangoData();
     private static BaseClickhouseData baseClickhouseData = new BaseClickhouseData();
 
 
     public void updateArango(){
         long start = System.currentTimeMillis();
         try {
-            updateDocument("ip_learning.r_locate_fqdn2ip_local", LocateFqdn2Ip.class,
-                    ReadClickhouseData::getRelationshipFqdnAddressIpSqlYsp,ReadClickhouseData::getRelationFqdnAddressIpDocument);
+
+            updateDocument(newVertexFqdnMap, historyVertexFqdnMap, "FQDN", Fqdn.class,BaseDocument.class,
+                    ReadClickhouseData::getVertexFqdnSql,ReadClickhouseData::getVertexFqdnDocument);
+
+            updateDocument(newVertexIpMap,historyVertexIpMap,"IP", Ip.class,BaseDocument.class,
+                    ReadClickhouseData::getVertexIpSql,ReadClickhouseData::getVertexIpDocument);
+
+            updateDocument(newVertexSubscriberMap,historyVertexSubscriberMap,"SUBSCRIBER", Subscriber.class,BaseDocument.class,
+                    ReadClickhouseData::getVertexSubscriberSql,ReadClickhouseData::getVertexSubscriberDocument);
+
+            updateDocument(newRelationFqdnAddressIpMap,historyRelationFqdnAddressIpMap,"R_LOCATE_FQDN2IP", LocateFqdn2Ip.class,BaseEdgeDocument.class,
+                    ReadClickhouseData::getRelationshipFqdnAddressIpSql,ReadClickhouseData::getRelationFqdnAddressIpDocument);
+
+//            updateDocument(newRelationIpVisitFqdnMap,historyRelationIpVisitFqdnMap,"R_VISIT_IP2FQDN",
+//                    VisitIp2Fqdn.class,BaseEdgeDocument.class,
+//                    ReadClickhouseData::getRelationshipIpVisitFqdnSql,ReadClickhouseData::getRelationIpVisitFqdnDocument);
+
+            updateDocument(newRelationSubsciberLocateIpMap,historyRelationSubsciberLocateIpMap,"R_LOCATE_SUBSCRIBER2IP",
+                    LocateSubscriber2Ip.class,BaseEdgeDocument.class,
+                    ReadClickhouseData::getRelationshipSubsciberLocateIpSql,ReadClickhouseData::getRelationshipSubsciberLocateIpDocument);
+
 
             long last = System.currentTimeMillis();
             LOG.info("iplearning application运行完毕，用时："+(last - start));
         }catch (Exception e){
             e.printStackTrace();
         }finally {
+            arangoManger.clean();
+            pool.shutdown();
+        }
+    }
+
+    public void updateArango2(){
+        long start = System.currentTimeMillis();
+        try {
+
+            updateDocument("FQDN", Fqdn.class,BaseDocument.class,
+                    ReadClickhouseData::getVertexFqdnSql,ReadClickhouseData::getVertexFqdnDocument);
+
+            updateDocument("IP", Ip.class,BaseDocument.class,
+                    ReadClickhouseData::getVertexIpSql,ReadClickhouseData::getVertexIpDocument);
+
+            updateDocument("SUBSCRIBER", Subscriber.class,BaseDocument.class,
+                    ReadClickhouseData::getVertexSubscriberSql,ReadClickhouseData::getVertexSubscriberDocument);
+
+            updateDocument("R_LOCATE_FQDN2IP", LocateFqdn2Ip.class,BaseEdgeDocument.class,
+                    ReadClickhouseData::getRelationshipFqdnAddressIpSql,ReadClickhouseData::getRelationFqdnAddressIpDocument);
+
+//            updateDocument("R_VISIT_IP2FQDN",
+//                    VisitIp2Fqdn.class,BaseEdgeDocument.class,
+//                    ReadClickhouseData::getRelationshipIpVisitFqdnSql,ReadClickhouseData::getRelationIpVisitFqdnDocument);
+
+            updateDocument("R_LOCATE_SUBSCRIBER2IP",
+                    LocateSubscriber2Ip.class,BaseEdgeDocument.class,
+                    ReadClickhouseData::getRelationshipSubsciberLocateIpSql,ReadClickhouseData::getRelationshipSubsciberLocateIpDocument);
+
+
+            long last = System.currentTimeMillis();
+            LOG.info("iplearning application运行完毕，用时："+(last - start));
+        }catch (Exception e){
+            e.printStackTrace();
+        }finally {
+            arangoManger.clean();
             pool.shutdown();
         }
     }
 
 
-    private <T extends BaseDocument> void updateDocument(String collection,
+    private <T extends BaseDocument> void updateDocument(HashMap<Integer, HashMap<String, ArrayList<T>>> newMap,
+                                                         ConcurrentHashMap<Integer, ConcurrentHashMap<String, T>> historyMap,
+                                                         String collection,
                                                          Class<? extends Document<T>> taskType,
+                                                         Class<T> docmentType,
                                                          Supplier<String> getSqlSupplier,
                                                          Function<ResultSet,T> formatResultFunc
                                                          ) {
         try {
 
+            baseArangoData.readHistoryData(collection,historyMap,docmentType);
             LOG.info(collection+" 读取clickhouse,封装结果集");
-            HashMap<Integer, HashMap<String, ArrayList<T>>> newMap =
-                    baseClickhouseData.baseDocumentFromClickhouse(getSqlSupplier, formatResultFunc);
+            baseClickhouseData.baseDocumentFromClickhouse(newMap, getSqlSupplier,formatResultFunc);
 
             LOG.info(collection+" 开始更新");
             long start = System.currentTimeMillis();
             CountDownLatch countDownLatch = new CountDownLatch(ApplicationConfig.THREAD_POOL_NUMBER);
             for (int i = 0; i < ApplicationConfig.THREAD_POOL_NUMBER; i++){
                 HashMap<String, ArrayList<T>> tmpNewMap = newMap.get(i);
+                ConcurrentHashMap<String, T> tmpHisMap = historyMap.get(i);
                 Constructor constructor = taskType.getConstructor(
                         HashMap.class,
+                        ArangoDBConnect.class,
                         String.class,
+                        ConcurrentHashMap.class,
                         CountDownLatch.class);
-                Document docTask = (Document)constructor.newInstance(tmpNewMap, collection, countDownLatch);
+                Document docTask = (Document)constructor.newInstance(tmpNewMap, arangoManger, collection, tmpHisMap, countDownLatch);
                 pool.executor(docTask);
             }
             countDownLatch.await();
@@ -71,6 +145,51 @@ public class UpdateGraphData {
             LOG.info(collection+" 更新完毕,共耗时："+(last-start));
         }catch (Exception e){
             e.printStackTrace();
+        }finally {
+            newMap.clear();
+            historyMap.clear();
         }
     }
+
+    private <T extends BaseDocument> void updateDocument(String collection,
+                                                         Class<? extends Document<T>> taskType,
+                                                         Class<T> docmentType,
+                                                         Supplier<String> getSqlSupplier,
+                                                         Function<ResultSet,T> formatResultFunc){
+        ConcurrentHashMap<Integer, ConcurrentHashMap<String, T>> historyData = baseArangoData.readHistoryData(collection, docmentType);
+        LOG.info(collection+" 读取clickhouse,封装结果集");
+        HashMap<Integer, HashMap<String, ArrayList<T>>> newData = baseClickhouseData.baseDocFromCk(getSqlSupplier, formatResultFunc);
+        try {
+            LOG.info(collection+" 开始更新");
+            long start = System.currentTimeMillis();
+            CountDownLatch countDownLatch = new CountDownLatch(ApplicationConfig.THREAD_POOL_NUMBER);
+            for (int i = 0; i < ApplicationConfig.THREAD_POOL_NUMBER; i++){
+                HashMap<String, ArrayList<T>> tmpNewMap = newData.get(i);
+                ConcurrentHashMap<String, T> tmpHisMap = historyData.get(i);
+                Constructor constructor = taskType.getConstructor(
+                        HashMap.class,
+                        ArangoDBConnect.class,
+                        String.class,
+                        ConcurrentHashMap.class,
+                        CountDownLatch.class);
+                Document docTask = (Document)constructor.newInstance(tmpNewMap, arangoManger, collection, tmpHisMap, countDownLatch);
+                pool.executor(docTask);
+            }
+            countDownLatch.await();
+            long last = System.currentTimeMillis();
+            LOG.info(collection+" 更新完毕,共耗时："+(last-start));
+
+        }catch (Exception e){
+            e.printStackTrace();
+            LOG.error("更新"+collection+"失败！！"+e.toString());
+        }finally {
+            newData.clear();
+            historyData.clear();
+        }
+
+
+    }
+
+
+
 }

IP-learning-graph/src/main/java/cn/ac/iie/service/ingestion/ReadClickhouseData.java

@@ -66,11 +66,9 @@ public class ReadClickhouseData {
             long bytesSum = resultSet.getLong("BYTES_SUM");
             String ipType = resultSet.getString("ip_type");
             String[] commonLinkInfos = (String[]) resultSet.getArray("common_link_info").getArray();
-            String commonLinkInfo;
-            if (commonLinkInfos.length > 1 && !commonLinkInfos[1].equals("")){
+            String commonLinkInfo = "";
+            if (commonLinkInfos.length > 1){
                 commonLinkInfo = commonLinkInfos[1];
-            }else {
-                commonLinkInfo = commonLinkInfos[0];
             }
             newDoc.setKey(ip);
             newDoc.addAttribute("IP", ip);
@@ -146,8 +144,7 @@ public class ReadClickhouseData {
                 long firstFoundTime = resultSet.getLong("FIRST_FOUND_TIME");
                 long lastFoundTime = resultSet.getLong("LAST_FOUND_TIME");
                 long countTotal = resultSet.getLong("COUNT_TOTAL");
-//                String schemaType = resultSet.getString("schema_type");
-                String schemaType = "";
+                String schemaType = resultSet.getString("schema_type");
                 String[] distCipRecents = (String[]) resultSet.getArray("DIST_CIP_RECENT").getArray();
                 long[] clientIpTs = new long[distCipRecents.length];
                 for (int i = 0; i < clientIpTs.length; i++) {
@@ -157,8 +154,8 @@ public class ReadClickhouseData {
                 String key = vFqdn + "-" + vIp;
                 newDoc = new BaseEdgeDocument();
                 newDoc.setKey(key);
-                newDoc.setFrom(vFqdn);
-                newDoc.setTo(vIp);
+                newDoc.setFrom("FQDN/" + vFqdn);
+                newDoc.setTo("IP/" + vIp);
                 newDoc.addAttribute("FIRST_FOUND_TIME", firstFoundTime);
                 newDoc.addAttribute("LAST_FOUND_TIME", lastFoundTime);
                 newDoc.addAttribute("DIST_CIP", distCipRecents);
@@ -186,8 +183,8 @@ public class ReadClickhouseData {
 
                 newDoc = new BaseEdgeDocument();
                 newDoc.setKey(key);
-                newDoc.setFrom(vIp);
-                newDoc.setTo(vFqdn);
+                newDoc.setFrom("IP/" + vIp);
+                newDoc.setTo("FQDN/" + vFqdn);
                 newDoc.addAttribute("FIRST_FOUND_TIME", firstFoundTime);
                 newDoc.addAttribute("LAST_FOUND_TIME", lastFoundTime);
                 newDoc.addAttribute("PROTOCOL_TYPE", schemaType);
@@ -215,8 +212,12 @@ public class ReadClickhouseData {
             if (fqdn == null || fqdn.length() == 0){
                 return false;
             }
-            fqdn = fqdn.split(":")[0];
-
+            if (fqdn.contains(":")){
+                String s = fqdn.split(":")[0];
+                if (s.contains(":")){
+                    return false;
+                }
+            }
             String[] fqdnArr = fqdn.split("\\.");
             if (fqdnArr.length < 4 || fqdnArr.length > 4) {
                 return true;
@@ -262,9 +263,9 @@ public class ReadClickhouseData {
     }
 
     public static String getVertexIpSql() {
-        String where = " common_recv_time >= " + minTime + " AND common_recv_time < " + maxTime + " AND common_schema_type != 'BASE'";
-        String clientIpSql = "SELECT common_client_ip AS IP, MIN(common_recv_time) AS FIRST_FOUND_TIME,MAX(common_recv_time) AS LAST_FOUND_TIME,count(*) as SESSION_COUNT,sum(common_c2s_byte_num+common_s2c_byte_num) as BYTES_SUM,groupUniqArray(2)(common_link_info_c2s) as common_link_info,'client' as ip_type FROM tsg_galaxy_v3.connection_record_log where " + where + " group by IP";
-        String serverIpSql = "SELECT common_server_ip AS IP, MIN(common_recv_time) AS FIRST_FOUND_TIME,MAX(common_recv_time) AS LAST_FOUND_TIME,count(*) as SESSION_COUNT,sum(common_c2s_byte_num+common_s2c_byte_num) as BYTES_SUM,groupUniqArray(2)(common_link_info_s2c) as common_link_info,'server' as ip_type FROM tsg_galaxy_v3.connection_record_log where " + where + " group by IP";
+        String where = " common_recv_time >= " + minTime + " AND common_recv_time < " + maxTime;
+        String clientIpSql = "SELECT common_client_ip AS IP, MIN(common_recv_time) AS FIRST_FOUND_TIME,MAX(common_recv_time) AS LAST_FOUND_TIME,count(*) as SESSION_COUNT,sum(common_c2s_byte_num+common_s2c_byte_num) as BYTES_SUM,groupUniqArray(2)(common_link_info) as common_link_info,'client' as ip_type FROM tsg_galaxy_v3.connection_record_log where " + where + " group by IP";
+        String serverIpSql = "SELECT common_server_ip AS IP, MIN(common_recv_time) AS FIRST_FOUND_TIME,MAX(common_recv_time) AS LAST_FOUND_TIME,count(*) as SESSION_COUNT,sum(common_c2s_byte_num+common_s2c_byte_num) as BYTES_SUM,groupUniqArray(2)(common_link_info) as common_link_info,'server' as ip_type FROM tsg_galaxy_v3.connection_record_log where " + where + " group by IP";
         return "SELECT * FROM((" + clientIpSql + ") UNION ALL (" + serverIpSql + "))";
     }
 
@@ -275,11 +276,6 @@ public class ReadClickhouseData {
         return "SELECT * FROM ((" + sslSql + ") UNION ALL (" + httpSql + "))WHERE FQDN != ''";
     }
 
-    public static String getRelationshipFqdnAddressIpSqlYsp() {
-        String where = "recv_time >= "+minTime+" and recv_time <= "+maxTime +" AND s1_domain != '' AND s1_d_ip != '' ";
-        return "SELECT s1_domain AS FQDN,s1_d_ip AS common_server_ip,MIN( recv_time ) AS FIRST_FOUND_TIME,MAX( recv_time ) AS LAST_FOUND_TIME,COUNT( * ) AS COUNT_TOTAL,groupUniqArray("+DISTINCT_CLIENT_IP_NUM+")(s1_s_ip) AS DIST_CIP_RECENT FROM media_expire_patch WHERE "+where+" GROUP BY s1_d_ip,s1_domain";
-    }
-
     public static String getRelationshipIpVisitFqdnSql() {
         String where = " common_recv_time >= " + minTime + " AND common_recv_time < " + maxTime;
         String httpSql = "SELECT http_host AS FQDN,common_client_ip,MAX(common_recv_time) AS LAST_FOUND_TIME,MIN(common_recv_time) AS FIRST_FOUND_TIME,COUNT(*) AS COUNT_TOTAL,'HTTP' AS schema_type FROM tsg_galaxy_v3.connection_record_log WHERE " + where + " and common_schema_type = 'HTTP' GROUP BY http_host,common_client_ip";

IP-learning-graph/src/main/java/cn/ac/iie/service/ingestion/ReadHistoryArangoData.java

@@ -0,0 +1,116 @@
+package cn.ac.iie.service.ingestion;
+
+import cn.ac.iie.config.ApplicationConfig;
+import cn.ac.iie.utils.ArangoDBConnect;
+import com.arangodb.ArangoCursor;
+import com.arangodb.entity.BaseDocument;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+
+import static cn.ac.iie.service.ingestion.ReadClickhouseData.*;
+
+/**
+ * @author wlh
+ * 多线程全量读取arangoDb历史数据，封装到map
+ */
+@SuppressWarnings("unchecked")
+public class ReadHistoryArangoData<T extends BaseDocument> extends Thread {
+    private static final Logger LOG = LoggerFactory.getLogger(ReadHistoryArangoData.class);
+
+    private ArangoDBConnect arangoConnect;
+    private String query;
+    private ConcurrentHashMap<Integer, ConcurrentHashMap<String, T>> map;
+    private Class<T> type;
+    private String table;
+    private CountDownLatch countDownLatch;
+
+    public ReadHistoryArangoData(ArangoDBConnect arangoConnect,
+                                 String query,
+                                 ConcurrentHashMap<Integer, ConcurrentHashMap<String, T>> map,
+                                 Class<T> type,
+                                 String table,
+                                 CountDownLatch countDownLatch) {
+        this.arangoConnect = arangoConnect;
+        this.query = query;
+        this.map = map;
+        this.type = type;
+        this.table = table;
+        this.countDownLatch = countDownLatch;
+    }
+
+    @Override
+    public void run() {
+        try {
+            long s = System.currentTimeMillis();
+            ArangoCursor<T> docs = arangoConnect.executorQuery(query, type);
+            if (docs != null) {
+                ArrayList<T> list = new ArrayList<>();
+                List<T> baseDocuments = docs.asListRemaining();
+                int i = 0;
+                for (T doc : baseDocuments) {
+                    String key = doc.getKey();
+                    switch (table) {
+                        case "R_LOCATE_FQDN2IP":
+                            updateProtocolDocument(doc);
+                            deleteDistinctClientIpByTime(doc);
+                            list.add(doc);
+                            break;
+                        default:
+                    }
+                    int hashCode = Math.abs(key.hashCode()) % ApplicationConfig.THREAD_POOL_NUMBER;
+                    ConcurrentHashMap<String, T> tmpMap = map.get(hashCode);
+                    tmpMap.put(key, doc);
+                    i++;
+                }
+                arangoConnect.overwrite(list,table);
+                long l = System.currentTimeMillis();
+                LOG.info(query + "\n读取" + i + "条数据，运行时间：" + (l - s));
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            countDownLatch.countDown();
+            LOG.info("本线程读取完毕，剩余线程数量：" + countDownLatch.getCount());
+        }
+    }
+
+    private void updateProtocolDocument(T doc) {
+        if (doc.getProperties().containsKey("PROTOCOL_TYPE")) {
+            for (String protocol : ReadClickhouseData.PROTOCOL_SET) {
+                String protocolRecent = protocol + "_CNT_RECENT";
+                ArrayList<Long> cntRecent = (ArrayList<Long>) doc.getAttribute(protocolRecent);
+                Long[] cntRecentsSrc = cntRecent.toArray(new Long[0]);
+                Long[] cntRecentsDst = new Long[RECENT_COUNT_HOUR];
+                System.arraycopy(cntRecentsSrc, 0, cntRecentsDst, 1, cntRecentsSrc.length - 1);
+                cntRecentsDst[0] = 0L;
+                doc.addAttribute(protocolRecent, cntRecentsDst);
+            }
+        }
+    }
+
+    private void deleteDistinctClientIpByTime(T doc) {
+        ArrayList<String> distCip = (ArrayList<String>) doc.getAttribute("DIST_CIP");
+        ArrayList<Long> distCipTs = (ArrayList<Long>) doc.getAttribute("DIST_CIP_TS");
+        distCipTs.add(currentHour - RECENT_COUNT_HOUR * 3600);
+        Collections.sort(distCipTs);
+        Collections.reverse(distCipTs);
+        int index = distCipTs.indexOf(currentHour - RECENT_COUNT_HOUR * 3600);
+        String[] distCipArr = new String[index];
+        long[] disCipTsArr = new long[index];
+        if (index != 0 && distCip.size() + 1 == distCipTs.size()){
+            for (int i = 0; i < index; i++) {
+                distCipArr[i] = distCip.get(i);
+                disCipTsArr[i] = distCipTs.get(i);
+            }
+        }
+        doc.updateAttribute("DIST_CIP", distCipArr);
+        doc.updateAttribute("DIST_CIP_TS", disCipTsArr);
+    }
+
+}

IP-learning-graph/src/main/java/cn/ac/iie/service/update/Document.java

@@ -1,32 +1,34 @@
 package cn.ac.iie.service.update;
 
 import cn.ac.iie.config.ApplicationConfig;
-import cn.ac.iie.utils.ClickhouseConnect;
-import com.alibaba.druid.pool.DruidPooledConnection;
+import cn.ac.iie.utils.ArangoDBConnect;
 import com.arangodb.entity.BaseDocument;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.sql.PreparedStatement;
-import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 
 public class Document<T extends BaseDocument> extends Thread{
     private static final Logger LOG = LoggerFactory.getLogger(Document.class);
     private HashMap<String, ArrayList<T>> newDocumentMap;
+    private ArangoDBConnect arangoManger;
     private String collectionName;
+    private ConcurrentHashMap<String, T> historyDocumentMap;
     private CountDownLatch countDownLatch;
 
-    private ClickhouseConnect manger =  ClickhouseConnect.getInstance();
-
     Document(HashMap<String, ArrayList<T>> newDocumentMap,
+             ArangoDBConnect arangoManger,
              String collectionName,
+             ConcurrentHashMap<String, T> historyDocumentMap,
              CountDownLatch countDownLatch) {
         this.newDocumentMap = newDocumentMap;
+        this.arangoManger = arangoManger;
         this.collectionName = collectionName;
+        this.historyDocumentMap = historyDocumentMap;
         this.countDownLatch = countDownLatch;
     }
 
@@ -34,32 +36,28 @@ public class Document<T extends BaseDocument> extends Thread{
     @Override
     public void run() {
         long start = System.currentTimeMillis();
-        LOG.info("读取数据"+newDocumentMap.size()+"条");
+        LOG.info("新读取数据"+newDocumentMap.size()+"条，历史数据"+historyDocumentMap.size()+"条");
         try {
             Set<String> keySet = newDocumentMap.keySet();
-            DruidPooledConnection connection  = manger.getConnection();
-            String sql = "INSERT INTO "+collectionName+" VALUES(?,?,?,?,?,?,?,?,?)";
-            PreparedStatement pstm  = connection.prepareStatement(sql);
+            ArrayList<T> resultDocumentList = new ArrayList<>();
             int i = 0;
             for (String key : keySet) {
                 ArrayList<T> newDocumentSchemaList = newDocumentMap.getOrDefault(key, null);
                 if (newDocumentSchemaList != null) {
                     T newDocument = mergeDocument(newDocumentSchemaList);
-                    pstm = setPstm(pstm, newDocument);
                     i += 1;
-                    pstm.addBatch();
+                    T historyDocument = historyDocumentMap.getOrDefault(key, null);
+                    updateDocument(newDocument,historyDocument,resultDocumentList);
                     if (i >= ApplicationConfig.UPDATE_ARANGO_BATCH) {
-                        pstm.executeBatch();
-                        connection.commit();
-                        LOG.warn("写入clickhouse数据量：" + i);
+                        arangoManger.overwrite(resultDocumentList, collectionName);
+                        LOG.info("更新"+collectionName+":" + i);
                         i = 0;
                     }
                 }
             }
             if (i != 0) {
-                pstm.executeBatch();
-                connection.commit();
-                LOG.warn("写入clickhouse数据量：" + i);
+                arangoManger.overwrite(resultDocumentList, collectionName);
+                LOG.info("更新"+collectionName+":" + i);
             }
         } catch (Exception e) {
             e.printStackTrace();
@@ -71,8 +69,18 @@ public class Document<T extends BaseDocument> extends Thread{
         }
     }
 
-    protected PreparedStatement setPstm(PreparedStatement pstm,T newDocument) throws SQLException {
-        return pstm;
+    private void updateDocument(T newDocument, T historyDocument, ArrayList<T> resultDocumentList) {
+        if (historyDocument != null){
+            updateFunction(newDocument,historyDocument);
+            resultDocumentList.add(historyDocument);
+        }else {
+            resultDocumentList.add(newDocument);
+        }
+    }
+
+    protected void updateFunction(T newDocument, T historyDocument) {
+        Object lastFoundTime = newDocument.getAttribute("LAST_FOUND_TIME");
+        historyDocument.addAttribute("LAST_FOUND_TIME",lastFoundTime);
     }
 
     private T mergeDocument(ArrayList<T> newDocumentSchemaList){

IP-learning-graph/src/main/java/cn/ac/iie/service/update/Relationship.java

@@ -1,18 +1,27 @@
 package cn.ac.iie.service.update;
 
 import cn.ac.iie.service.ingestion.ReadClickhouseData;
+import cn.ac.iie.utils.ArangoDBConnect;
 import com.arangodb.entity.BaseEdgeDocument;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 
 public class Relationship extends Document<BaseEdgeDocument> {
 
     public Relationship(HashMap<String, ArrayList<BaseEdgeDocument>> newDocumentHashMap,
+                        ArangoDBConnect arangoManger,
                         String collectionName,
+                        ConcurrentHashMap<String, BaseEdgeDocument> historyDocumentMap,
                         CountDownLatch countDownLatch) {
-        super(newDocumentHashMap,collectionName,countDownLatch);
+        super(newDocumentHashMap,arangoManger,collectionName,historyDocumentMap,countDownLatch);
+    }
+
+    @Override
+    protected void updateFunction(BaseEdgeDocument newEdgeDocument, BaseEdgeDocument historyEdgeDocument){
+        super.updateFunction(newEdgeDocument,historyEdgeDocument);
     }
 
     @Override
@@ -20,6 +29,26 @@ public class Relationship extends Document<BaseEdgeDocument> {
         super.mergeFunction(lastDoc, newDocument);
     }
 
+    protected void updateProcotol(BaseEdgeDocument historyEdgeDocument, String schema, BaseEdgeDocument newEdgeDocument){
+        String recentSchema = schema +"_CNT_RECENT";
+        String totalSchema = schema + "_CNT_TOTAL";
+        long countTotal = Long.parseLong(newEdgeDocument.getAttribute(totalSchema).toString());
+        if (countTotal > 0L){
+            long updateCountTotal = Long.parseLong(historyEdgeDocument.getAttribute(totalSchema).toString());
+
+            Long[] cntRecent = (Long[]) historyEdgeDocument.getAttribute(recentSchema);
+            cntRecent[0] = countTotal;
+
+            historyEdgeDocument.addAttribute(recentSchema, cntRecent);
+            historyEdgeDocument.addAttribute(totalSchema, countTotal + updateCountTotal);
+            String hisProtocolType = historyEdgeDocument.getAttribute("PROTOCOL_TYPE").toString();
+            if (!hisProtocolType.contains(schema)){
+                hisProtocolType = hisProtocolType + "," + schema;
+                historyEdgeDocument.addAttribute("PROTOCOL_TYPE",hisProtocolType);
+            }
+        }
+    }
+
     protected void mergeProtocol(BaseEdgeDocument lastDoc,BaseEdgeDocument newDocument) {
         String schema = lastDoc.getAttribute("PROTOCOL_TYPE").toString();
         if (ReadClickhouseData.PROTOCOL_SET.contains(schema)){

IP-learning-graph/src/main/java/cn/ac/iie/service/update/Vertex.java

@@ -1,9 +1,11 @@
 package cn.ac.iie.service.update;
 
+import cn.ac.iie.utils.ArangoDBConnect;
 import com.arangodb.entity.BaseDocument;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 
 /**
@@ -13,9 +15,11 @@ import java.util.concurrent.CountDownLatch;
 public class Vertex extends Document<BaseDocument> {
 
     public Vertex(HashMap<String, ArrayList<BaseDocument>> newDocumentHashMap,
+                  ArangoDBConnect arangoManger,
                   String collectionName,
+                  ConcurrentHashMap<String, BaseDocument> historyDocumentMap,
                   CountDownLatch countDownLatch) {
-        super(newDocumentHashMap, collectionName, countDownLatch);
+        super(newDocumentHashMap, arangoManger, collectionName, historyDocumentMap, countDownLatch);
     }
 
 }

IP-learning-graph/src/main/java/cn/ac/iie/service/update/relationship/LocateFqdn2Ip.java

@@ -1,23 +1,25 @@
 package cn.ac.iie.service.update.relationship;
 
+import cn.ac.iie.service.ingestion.ReadClickhouseData;
 import cn.ac.iie.service.update.Relationship;
+import cn.ac.iie.utils.ArangoDBConnect;
 import com.arangodb.entity.BaseEdgeDocument;
-import ru.yandex.clickhouse.ClickHouseArray;
-import ru.yandex.clickhouse.domain.ClickHouseDataType;
 
-import java.sql.PreparedStatement;
-import java.sql.SQLException;
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 
+import static cn.ac.iie.service.ingestion.ReadClickhouseData.DISTINCT_CLIENT_IP_NUM;
 import static cn.ac.iie.service.ingestion.ReadClickhouseData.currentHour;
 
 public class LocateFqdn2Ip extends Relationship {
 
     public LocateFqdn2Ip(HashMap<String, ArrayList<BaseEdgeDocument>> newDocumentHashMap,
+                         ArangoDBConnect arangoManger,
                          String collectionName,
+                         ConcurrentHashMap<String, BaseEdgeDocument> historyDocumentMap,
                          CountDownLatch countDownLatch) {
-        super(newDocumentHashMap, collectionName,countDownLatch);
+        super(newDocumentHashMap, arangoManger, collectionName, historyDocumentMap,countDownLatch);
     }
 
     @Override
@@ -27,22 +29,6 @@ public class LocateFqdn2Ip extends Relationship {
         mergeProtocol(lastDoc, newDocument);
     }
 
-    @Override
-    protected PreparedStatement setPstm(PreparedStatement pstm,BaseEdgeDocument newDocument) throws SQLException {
-        pstm.setString(1,newDocument.getFrom());
-        pstm.setString(2,newDocument.getTo());
-        pstm.setLong(3,Long.parseLong(newDocument.getAttribute("FIRST_FOUND_TIME").toString()));
-        pstm.setLong(4,Long.parseLong(newDocument.getAttribute("LAST_FOUND_TIME").toString()));
-        pstm.setLong(5,Long.parseLong(newDocument.getAttribute("DNS_CNT_TOTAL").toString()));
-        pstm.setLong(6,Long.parseLong(newDocument.getAttribute("TLS_CNT_TOTAL").toString()));
-        pstm.setLong(7,Long.parseLong(newDocument.getAttribute("HTTP_CNT_TOTAL").toString()));
-        Object[] distCips = (Object[]) newDocument.getAttribute("DIST_CIP");
-        pstm.setArray(8,new ClickHouseArray(ClickHouseDataType.Int64, distCips));
-        pstm.setLong(9,currentHour);
-
-        return pstm;
-    }
-
     private void mergeDistinctClientIp(BaseEdgeDocument lastDoc,BaseEdgeDocument newDocument){
         HashSet<String> clientIpSet = new HashSet<>();
         String[] distCips = (String[]) newDocument.getAttribute("DIST_CIP");
@@ -57,5 +43,56 @@ public class LocateFqdn2Ip extends Relationship {
         newDocument.addAttribute("DIST_CIP_TS", clientIpTs);
     }
 
+    @Override
+    protected void updateFunction(BaseEdgeDocument newEdgeDocument, BaseEdgeDocument historyEdgeDocument) {
+        super.updateFunction(newEdgeDocument, historyEdgeDocument);
+        for (String schema:ReadClickhouseData.PROTOCOL_SET){
+            updateProcotol(historyEdgeDocument,schema,newEdgeDocument);
+        }
+        updateDistinctClientIp(newEdgeDocument, historyEdgeDocument);
+    }
+
+    private void updateDistinctClientIp(BaseEdgeDocument newEdgeDocument,BaseEdgeDocument edgeDocument){
+        String[] distCip = (String[]) edgeDocument.getAttribute("DIST_CIP");
+        long[] distCipTs = (long[]) edgeDocument.getAttribute("DIST_CIP_TS");
+        HashMap<String, Long> distCipToTs = new HashMap<>();
+        if (distCip.length == distCipTs.length){
+            for (int i = 0;i < distCip.length;i++){
+                distCipToTs.put(distCip[i],distCipTs[i]);
+            }
+        }
+        Object[] distCipRecent = (Object[])newEdgeDocument.getAttribute("DIST_CIP");
+        for (Object cip:distCipRecent){
+            distCipToTs.put(cip.toString(), currentHour);
+        }
+
+        Map<String, Long> sortDistCip = sortMapByValue(distCipToTs);
+        edgeDocument.addAttribute("DIST_CIP",sortDistCip.keySet().toArray());
+        edgeDocument.addAttribute("DIST_CIP_TS",sortDistCip.values().toArray());
+    }
+
+
+    /**
+     * 使用 Map按value进行排序
+     */
+    private Map<String, Long> sortMapByValue(Map<String, Long> oriMap) {
+        if (oriMap == null || oriMap.isEmpty()) {
+            return null;
+        }
+        Map<String, Long> sortedMap = new LinkedHashMap<>();
+        List<Map.Entry<String, Long>> entryList = new ArrayList<>(oriMap.entrySet());
+        entryList.sort((o1, o2) -> o2.getValue().compareTo(o1.getValue()));
+
+        if(entryList.size() > DISTINCT_CLIENT_IP_NUM){
+            for(Map.Entry<String, Long> set:entryList.subList(0, DISTINCT_CLIENT_IP_NUM)){
+                sortedMap.put(set.getKey(), set.getValue());
+            }
+        }else {
+            for(Map.Entry<String, Long> set:entryList){
+                sortedMap.put(set.getKey(), set.getValue());
+            }
+        }
+        return sortedMap;
+    }
 
 }

IP-learning-graph/src/main/java/cn/ac/iie/service/update/relationship/LocateSubscriber2Ip.java

@@ -1,17 +1,21 @@
 package cn.ac.iie.service.update.relationship;
 
 import cn.ac.iie.service.update.Relationship;
+import cn.ac.iie.utils.ArangoDBConnect;
 import com.arangodb.entity.BaseEdgeDocument;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 
 public class LocateSubscriber2Ip extends Relationship {
 
     public LocateSubscriber2Ip(HashMap<String, ArrayList<BaseEdgeDocument>> newDocumentHashMap,
+                               ArangoDBConnect arangoManger,
                                String collectionName,
+                               ConcurrentHashMap<String, BaseEdgeDocument> historyDocumentMap,
                                CountDownLatch countDownLatch) {
-        super(newDocumentHashMap, collectionName, countDownLatch);
+        super(newDocumentHashMap, arangoManger, collectionName, historyDocumentMap, countDownLatch);
     }
 }

IP-learning-graph/src/main/java/cn/ac/iie/service/update/relationship/VisitIp2Fqdn.java

@@ -2,17 +2,30 @@ package cn.ac.iie.service.update.relationship;
 
 import cn.ac.iie.service.ingestion.ReadClickhouseData;
 import cn.ac.iie.service.update.Relationship;
+import cn.ac.iie.utils.ArangoDBConnect;
 import com.arangodb.entity.BaseEdgeDocument;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 
 public class VisitIp2Fqdn extends Relationship {
     public VisitIp2Fqdn(HashMap<String, ArrayList<BaseEdgeDocument>> newDocumentHashMap,
+                        ArangoDBConnect arangoManger,
                         String collectionName,
+                        ConcurrentHashMap<String, BaseEdgeDocument> historyDocumentMap,
                         CountDownLatch countDownLatch) {
-        super(newDocumentHashMap, collectionName,countDownLatch);
+        super(newDocumentHashMap, arangoManger, collectionName, historyDocumentMap,countDownLatch);
+    }
+
+    @Override
+    protected void updateFunction(BaseEdgeDocument newEdgeDocument, BaseEdgeDocument historyEdgeDocument) {
+        super.updateFunction(newEdgeDocument, historyEdgeDocument);
+        for (String schema: ReadClickhouseData.PROTOCOL_SET){
+            updateProcotol(historyEdgeDocument,schema,newEdgeDocument);
+        }
     }
 
     @Override

IP-learning-graph/src/main/java/cn/ac/iie/service/update/vertex/Fqdn.java

@@ -1,17 +1,21 @@
 package cn.ac.iie.service.update.vertex;
 
 import cn.ac.iie.service.update.Vertex;
+import cn.ac.iie.utils.ArangoDBConnect;
 import com.arangodb.entity.BaseDocument;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 
 public class Fqdn extends Vertex {
 
     public Fqdn(HashMap<String, ArrayList<BaseDocument>> newDocumentHashMap,
+                ArangoDBConnect arangoManger,
                 String collectionName,
+                ConcurrentHashMap<String, BaseDocument> historyDocumentMap,
                 CountDownLatch countDownLatch) {
-        super(newDocumentHashMap, collectionName,countDownLatch);
+        super(newDocumentHashMap, arangoManger, collectionName, historyDocumentMap,countDownLatch);
     }
 }

IP-learning-graph/src/main/java/cn/ac/iie/service/update/vertex/Ip.java

@@ -1,18 +1,29 @@
 package cn.ac.iie.service.update.vertex;
 
 import cn.ac.iie.service.update.Vertex;
+import cn.ac.iie.utils.ArangoDBConnect;
 import com.arangodb.entity.BaseDocument;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 
 public class Ip extends Vertex {
 
     public Ip(HashMap<String, ArrayList<BaseDocument>> newDocumentHashMap,
+              ArangoDBConnect arangoManger,
               String collectionName,
+              ConcurrentHashMap<String, BaseDocument> historyDocumentMap,
               CountDownLatch countDownLatch) {
-        super(newDocumentHashMap, collectionName,countDownLatch);
+        super(newDocumentHashMap, arangoManger, collectionName, historyDocumentMap,countDownLatch);
+    }
+
+    @Override
+    protected void updateFunction(BaseDocument newDocument, BaseDocument historyDocument) {
+        super.updateFunction(newDocument, historyDocument);
+        updateIpByType(newDocument, historyDocument);
+        super.replaceAttribute(newDocument,historyDocument,"COMMON_LINK_INFO");
     }
 
     @Override

IP-learning-graph/src/main/java/cn/ac/iie/service/update/vertex/Subscriber.java

@@ -1,17 +1,21 @@
 package cn.ac.iie.service.update.vertex;
 
 import cn.ac.iie.service.update.Vertex;
+import cn.ac.iie.utils.ArangoDBConnect;
 import com.arangodb.entity.BaseDocument;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 
 public class Subscriber extends Vertex {
 
     public Subscriber(HashMap<String, ArrayList<BaseDocument>> newDocumentHashMap,
+                      ArangoDBConnect arangoManger,
                       String collectionName,
+                      ConcurrentHashMap<String, BaseDocument> historyDocumentMap,
                       CountDownLatch countDownLatch) {
-        super(newDocumentHashMap, collectionName, countDownLatch);
+        super(newDocumentHashMap, arangoManger, collectionName, historyDocumentMap, countDownLatch);
     }
 }

IP-learning-graph/src/main/java/cn/ac/iie/test/IpLearningApplicationTest.java

@@ -6,7 +6,8 @@ public class IpLearningApplicationTest {
 
     public static void main(String[] args) {
         UpdateGraphData updateGraphData = new UpdateGraphData();
-        updateGraphData.updateArango();
+//        updateGraphData.updateArango();
+        updateGraphData.updateArango2();
 
     }
 }

IP-learning-graph/src/main/java/cn/ac/iie/utils/ArangoDBConnect.java

@@ -0,0 +1,96 @@
+package cn.ac.iie.utils;
+
+import cn.ac.iie.config.ApplicationConfig;
+import com.arangodb.ArangoCollection;
+import com.arangodb.ArangoCursor;
+import com.arangodb.ArangoDB;
+import com.arangodb.ArangoDatabase;
+import com.arangodb.entity.DocumentCreateEntity;
+import com.arangodb.entity.ErrorEntity;
+import com.arangodb.entity.MultiDocumentEntity;
+import com.arangodb.model.AqlQueryOptions;
+import com.arangodb.model.DocumentCreateOptions;
+import com.arangodb.util.MapBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+public class ArangoDBConnect {
+    private static final Logger LOG = LoggerFactory.getLogger(ArangoDBConnect.class);
+    private static ArangoDB arangoDB = null;
+    private static ArangoDBConnect conn = null;
+    static {
+        getArangoDB();
+    }
+
+    private static void getArangoDB(){
+        arangoDB = new ArangoDB.Builder()
+                .maxConnections(ApplicationConfig.THREAD_POOL_NUMBER)
+                .host(ApplicationConfig.ARANGODB_HOST, ApplicationConfig.ARANGODB_PORT)
+                .user(ApplicationConfig.ARANGODB_USER)
+                .password(ApplicationConfig.ARANGODB_PASSWORD)
+                .build();
+    }
+
+    public static synchronized ArangoDBConnect getInstance(){
+        if (null == conn){
+            conn = new ArangoDBConnect();
+        }
+        return conn;
+    }
+
+    private ArangoDatabase getDatabase(){
+        return arangoDB.db(ApplicationConfig.ARANGODB_DB_NAME);
+    }
+
+    public void clean(){
+        try {
+            if (arangoDB != null){
+                arangoDB.shutdown();
+            }
+        }catch (Exception e){
+            LOG.error(e.getMessage());
+        }
+    }
+
+    public <T> ArangoCursor<T> executorQuery(String query,Class<T> type){
+        ArangoDatabase database = getDatabase();
+        Map<String, Object> bindVars = new MapBuilder().get();
+        AqlQueryOptions options = new AqlQueryOptions()
+                .ttl(ApplicationConfig.ARANGODB_TTL);
+        try {
+            return database.query(query, bindVars, options, type);
+        }catch (Exception e){
+            LOG.error(e.getMessage());
+            return null;
+        }finally {
+            bindVars.clear();
+        }
+    }
+
+    public <T> void overwrite(List<T> docOverwrite, String collectionName){
+        ArangoDatabase database = getDatabase();
+        try {
+            ArangoCollection collection = database.collection(collectionName);
+            if (!docOverwrite.isEmpty()){
+                DocumentCreateOptions documentCreateOptions = new DocumentCreateOptions();
+                documentCreateOptions.overwrite(true);
+                documentCreateOptions.silent(true);
+                MultiDocumentEntity<DocumentCreateEntity<T>> documentCreateEntityMultiDocumentEntity = collection.insertDocuments(docOverwrite, documentCreateOptions);
+                Collection<ErrorEntity> errors = documentCreateEntityMultiDocumentEntity.getErrors();
+                for (ErrorEntity errorEntity:errors){
+                    LOG.error("写入arangoDB异常："+errorEntity.getErrorMessage());
+                }
+            }
+        }catch (Exception e){
+            LOG.error("更新失败："+e.toString());
+        }finally {
+            docOverwrite.clear();
+        }
+    }
+
+}

IP-learning-graph/src/main/resources/application.properties

@@ -1,9 +1,11 @@
 #arangoDB参数配置
-arangoDB.host=192.168.44.12
+arangoDB.host=192.168.40.182
+#arangoDB.host=192.168.40.224
 arangoDB.port=8529
 arangoDB.user=upsert
 arangoDB.password=ceiec2018
-arangoDB.DB.name=tsg_galaxy_v3
+arangoDB.DB.name=ip-learning-test
+#arangoDB.DB.name=tsg_galaxy_v3
 arangoDB.batch=100000
 arangoDB.ttl=3600
 
@@ -15,9 +17,9 @@ thread.await.termination.time=10
 
 
 #读取clickhouse时间范围方式，0：读取过去一小时，1：指定时间范围
-time.limit.type=1
-read.clickhouse.max.time=1571241610
-read.clickhouse.min.time=1571241600
+time.limit.type=0
+read.clickhouse.max.time=1596684142
+read.clickhouse.min.time=1596425769
 
 update.interval=3600
 distinct.client.ip.num=10000

IP-learning-graph/src/main/resources/clickhouse.properties

@@ -1,10 +1,9 @@
 drivers=ru.yandex.clickhouse.ClickHouseDriver
 mdb.user=default
-#db.id=192.168.44.10:8124/tsg_galaxy_v3?socket_timeout=300000
-#db.id=192.168.44.12:8123/tsg_galaxy_v3?socket_timeout=300000&compress=0
-#mdb.password=ceiec2019
-db.id=192.168.40.193:8123/tsg_galaxy_zx?socket_timeout=3600000
+db.id=192.168.40.186:8123/tsg_galaxy_v3?socket_timeout=300000
 mdb.password=111111
+#db.id=192.168.40.224:8123/tsg_galaxy_v3?socket_timeout=300000
+#mdb.password=ceiec2019
 initialsize=1
 minidle=1
 maxactive=50

IP-learning-graph/src/test/java/cn/ac/iie/TestList.java

@@ -1,5 +1,6 @@
 package cn.ac.iie;
 
+import cn.ac.iie.utils.ArangoDBConnect;
 import com.arangodb.ArangoCursor;
 import com.arangodb.entity.BaseEdgeDocument;
 

IP-learning-graph/src/test/java/cn/ac/iie/TestMap.java

@@ -1,8 +1,12 @@
 package cn.ac.iie;
 
+import cn.ac.iie.dao.BaseArangoData;
+import cn.ac.iie.utils.ArangoDBConnect;
+import cn.ac.iie.utils.ExecutorThreadPool;
 import com.arangodb.entity.*;
 
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class TestMap {
 

IP-learning-graph/src/test/java/cn/ac/iie/TestReadArango.java

@@ -0,0 +1,53 @@
+package cn.ac.iie;
+
+import cn.ac.iie.dao.BaseArangoData;
+import cn.ac.iie.utils.ArangoDBConnect;
+import cn.ac.iie.utils.ExecutorThreadPool;
+import com.arangodb.entity.BaseDocument;
+import com.arangodb.entity.BaseEdgeDocument;
+import org.junit.After;
+import org.junit.Test;
+
+import java.util.Enumeration;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class TestReadArango {
+    private static ExecutorThreadPool pool = ExecutorThreadPool.getInstance();
+    private static ArangoDBConnect arangoManger = ArangoDBConnect.getInstance();
+
+    private static BaseArangoData baseArangoData = new BaseArangoData();
+
+
+    @Test
+    public void testReadFqdnFromArango() {
+        ConcurrentHashMap<Integer, ConcurrentHashMap<String, BaseDocument>> historyData =
+                baseArangoData.readHistoryData("FQDN", BaseDocument.class);
+        printMap(historyData);
+    }
+
+    @Test
+    public void testReadFqdnLocIpFromArango() {
+        ConcurrentHashMap<Integer, ConcurrentHashMap<String, BaseEdgeDocument>> ip =
+                baseArangoData.readHistoryData("R_LOCATE_FQDN2IP", BaseEdgeDocument.class);
+        printMap(ip);
+    }
+
+    private <T extends BaseDocument> void printMap(ConcurrentHashMap<Integer, ConcurrentHashMap<String, T>> historyData) {
+        ConcurrentHashMap<String, T> map = historyData.get(2);
+        Enumeration<String> keys = map.keys();
+        while (keys.hasMoreElements()) {
+            String key = keys.nextElement();
+            T document = map.get(key);
+            System.out.println(document.toString());
+        }
+    }
+
+
+    @After
+    public void clearSource() {
+        pool.shutdown();
+        arangoManger.clean();
+    }
+
+
+}

IP-learning-graph/src/test/java/cn/ac/iie/TestReadClickhouse.java

@@ -0,0 +1,46 @@
+package cn.ac.iie;
+
+import cn.ac.iie.dao.BaseClickhouseData;
+import cn.ac.iie.service.ingestion.ReadClickhouseData;
+import com.arangodb.entity.BaseDocument;
+import com.arangodb.entity.BaseEdgeDocument;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Set;
+
+public class TestReadClickhouse {
+
+    private static BaseClickhouseData baseClickhouseData = new BaseClickhouseData();
+
+    @Test
+    public void testReadFqdnFromCk(){
+
+
+        HashMap<Integer, HashMap<String, ArrayList<BaseDocument>>> newData =
+                baseClickhouseData.baseDocFromCk(ReadClickhouseData::getVertexFqdnSql,
+                        ReadClickhouseData::getVertexFqdnDocument);
+        printMap(newData);
+
+    }
+
+    @Test
+    public void testReadFqdnLocIpFromCk(){
+        HashMap<Integer, HashMap<String, ArrayList<BaseEdgeDocument>>> map =
+                baseClickhouseData.baseDocFromCk(ReadClickhouseData::getRelationshipFqdnAddressIpSql,
+                        ReadClickhouseData::getRelationFqdnAddressIpDocument);
+
+        printMap(map);
+    }
+
+
+    private<T extends BaseDocument> void printMap(HashMap<Integer, HashMap<String, ArrayList<T>>> newData){
+        HashMap<String, ArrayList<T>> map = newData.get(1);
+        Set<String> strings = map.keySet();
+        for (String key:strings){
+            ArrayList<T> baseDocuments = map.get(key);
+            System.out.println(baseDocuments.get(0));
+        }
+    }
+}

IP-learning-graph/src/test/java/cn/ac/iie/readHistoryDataTest.java

@@ -0,0 +1,10 @@
+package cn.ac.iie;
+
+import cn.ac.iie.dao.BaseArangoData;
+import com.arangodb.entity.BaseEdgeDocument;
+
+public class readHistoryDataTest {
+    public static void main(String[] args) {
+        BaseArangoData baseArangoData = new BaseArangoData();
+    }
+}

ip-learning-spark/pom.xml

@@ -27,12 +27,6 @@
         <version>4.4.6</version>
     </dependency>
 
-    <dependency>
-        <groupId>com.alibaba</groupId>
-        <artifactId>druid</artifactId>
-        <version>1.1.10</version>
-    </dependency>
-
     <dependency>
         <groupId>com.google.guava</groupId>
         <artifactId>guava</artifactId>
@@ -69,6 +63,18 @@
         <version>6.6.3</version>
     </dependency>
 
+    <dependency>
+        <groupId>com.arangodb</groupId>
+        <artifactId>velocypack-module-jdk8</artifactId>
+        <version>1.1.0</version>
+    </dependency>
+
+    <dependency>
+        <groupId>com.arangodb</groupId>
+        <artifactId>velocypack-module-scala_2.11</artifactId>
+        <version>1.2.0</version>
+    </dependency>
+
     <dependency>
         <groupId>org.scala-lang</groupId>
         <artifactId>scala-library</artifactId>
@@ -87,7 +93,6 @@
         <version>1.0.4</version>
     </dependency>
 
-
     <dependency>
         <groupId>org.scala-tools</groupId>
         <artifactId>maven-scala-plugin</artifactId>

ip-learning-spark/src/main/java/cn/ac/iie/dao/BaseArangoData.java

@@ -0,0 +1,75 @@
+package cn.ac.iie.dao;
+
+import cn.ac.iie.config.ApplicationConfig;
+import cn.ac.iie.service.read.ReadHistoryArangoData;
+import cn.ac.iie.utils.ArangoDBConnect;
+import cn.ac.iie.utils.ExecutorThreadPool;
+import com.arangodb.ArangoCursor;
+import com.arangodb.entity.BaseDocument;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+
+/**
+ * 获取arangoDB历史数据
+ *
+ * @author wlh
+ */
+public class BaseArangoData {
+    private static final Logger LOG = LoggerFactory.getLogger(BaseArangoData.class);
+    private static ArangoDBConnect arangoDBConnect = ArangoDBConnect.getInstance();
+
+    private ExecutorThreadPool threadPool = ExecutorThreadPool.getInstance();
+
+    public <T extends BaseDocument> void readHistoryData(String table,
+                                                  ConcurrentHashMap<Integer, ConcurrentHashMap<String, T>> historyMap,
+                                                  Class<T> type) {
+        try {
+            LOG.warn("开始更新" + table);
+            long start = System.currentTimeMillis();
+            for (int i = 0; i < ApplicationConfig.THREAD_POOL_NUMBER(); i++) {
+                historyMap.put(i, new ConcurrentHashMap<>());
+            }
+            CountDownLatch countDownLatch = new CountDownLatch(ApplicationConfig.THREAD_POOL_NUMBER());
+//            long[] timeRange = getTimeRange(table);
+            Long countTotal = getCountTotal(table);
+            for (int i = 0; i < ApplicationConfig.THREAD_POOL_NUMBER(); i++) {
+//                String sql = getQuerySql(timeRange, i, table);
+                String sql = getQuerySql(countTotal, i, table);
+                ReadHistoryArangoData<T> readHistoryArangoData = new ReadHistoryArangoData<>(arangoDBConnect, sql, historyMap, type, table, countDownLatch);
+                threadPool.executor(readHistoryArangoData);
+            }
+            countDownLatch.await();
+            long last = System.currentTimeMillis();
+            LOG.warn("读取" + table + " arangoDB 共耗时：" + (last - start));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private Long getCountTotal(String table){
+        long start = System.currentTimeMillis();
+        Long cnt = 0L;
+        String sql = "RETURN LENGTH("+table+")";
+        try {
+            ArangoCursor<Long> longs = arangoDBConnect.executorQuery(sql, Long.class);
+            while (longs.hasNext()){
+                cnt = longs.next();
+            }
+        }catch (Exception e){
+            LOG.error(sql +"执行异常");
+        }
+        long last = System.currentTimeMillis();
+        LOG.info(sql+" 结果："+cnt+" 执行时间："+(last-start));
+        return cnt;
+    }
+
+    private String getQuerySql(Long cnt,int threadNumber, String table){
+        long sepNum = cnt / ApplicationConfig.THREAD_POOL_NUMBER() + 1;
+        long offsetNum = threadNumber * sepNum;
+        return "FOR doc IN " + table + " limit "+offsetNum+","+sepNum+" RETURN doc";
+    }
+
+}

ip-learning-spark/src/main/java/cn/ac/iie/service/read/ReadHistoryArangoData.java

@@ -0,0 +1,125 @@
+package cn.ac.iie.service.read;
+
+import cn.ac.iie.config.ApplicationConfig;
+import cn.ac.iie.utils.ArangoDBConnect;
+import com.arangodb.ArangoCursor;
+import com.arangodb.entity.BaseDocument;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+
+
+/**
+ * @author wlh
+ * 多线程全量读取arangoDb历史数据，封装到map
+ */
+public class ReadHistoryArangoData<T extends BaseDocument> extends Thread {
+    public static long currentHour = System.currentTimeMillis() / (60 * 60 * 1000) * 60 * 60;
+    private static final Logger LOG = LoggerFactory.getLogger(ReadHistoryArangoData.class);
+    static final Integer RECENT_COUNT_HOUR = ApplicationConfig.RECENT_COUNT_HOUR();
+
+    public static final HashSet<String> PROTOCOL_SET;
+
+    static {
+        PROTOCOL_SET = new HashSet<>();
+        PROTOCOL_SET.add("HTTP");
+        PROTOCOL_SET.add("TLS");
+        PROTOCOL_SET.add("DNS");
+    }
+
+    private ArangoDBConnect arangoConnect;
+    private String query;
+    private ConcurrentHashMap<Integer,ConcurrentHashMap<String, T>> map;
+    private Class<T> type;
+    private String table;
+    private CountDownLatch countDownLatch;
+
+    public ReadHistoryArangoData(ArangoDBConnect arangoConnect,
+                                 String query,
+                                 ConcurrentHashMap<Integer,ConcurrentHashMap<String, T>> map,
+                                 Class<T> type,
+                                 String table,
+                                 CountDownLatch countDownLatch) {
+        this.arangoConnect = arangoConnect;
+        this.query = query;
+        this.map = map;
+        this.type = type;
+        this.table = table;
+        this.countDownLatch = countDownLatch;
+    }
+
+    @Override
+    public void run() {
+        try {
+            long s = System.currentTimeMillis();
+            ArangoCursor<T> docs = arangoConnect.executorQuery(query, type);
+            if (docs != null) {
+                List<T> baseDocuments = docs.asListRemaining();
+                int i = 0;
+                for (T doc : baseDocuments) {
+                    String key = doc.getKey();
+                    switch (table) {
+                        case "R_LOCATE_FQDN2IP":
+                            updateProtocolDocument(doc);
+                            deleteDistinctClientIpByTime(doc);
+                            break;
+                        case "R_VISIT_IP2FQDN":
+                            updateProtocolDocument(doc);
+                            break;
+                        default:
+                    }
+                    int hashCode = Math.abs(key.hashCode()) % ApplicationConfig.THREAD_POOL_NUMBER();
+                    ConcurrentHashMap<String, T> tmpMap = map.get(hashCode);
+                    tmpMap.put(key, doc);
+                    i++;
+                }
+                long l = System.currentTimeMillis();
+                LOG.warn(query + "\n读取" + i + "条数据，运行时间：" + (l - s));
+            }
+        }catch (Exception e){
+            e.printStackTrace();
+        }finally {
+            countDownLatch.countDown();
+            LOG.warn("本线程读取完毕，剩余线程数量："+countDownLatch.getCount());
+        }
+    }
+
+    private void updateProtocolDocument(T doc) {
+        if (doc.getProperties().containsKey("PROTOCOL_TYPE")) {
+            for (String protocol : PROTOCOL_SET) {
+                String protocolRecent = protocol + "_CNT_RECENT";
+                ArrayList<Long> cntRecent = (ArrayList<Long>) doc.getAttribute(protocolRecent);
+                Long[] cntRecentsSrc = cntRecent.toArray(new Long[cntRecent.size()]);
+                Long[] cntRecentsDst = new Long[RECENT_COUNT_HOUR];
+                System.arraycopy(cntRecentsSrc, 0, cntRecentsDst, 1, cntRecentsSrc.length - 1);
+                cntRecentsDst[0] = 0L;
+                doc.addAttribute(protocolRecent, cntRecentsDst);
+            }
+        }
+    }
+
+    private void deleteDistinctClientIpByTime(T doc) {
+        ArrayList<String> distCip = (ArrayList<String>) doc.getAttribute("DIST_CIP");
+        ArrayList<Long> distCipTs = (ArrayList<Long>) doc.getAttribute("DIST_CIP_TS");
+        distCipTs.add(currentHour - RECENT_COUNT_HOUR * 3600);
+        Collections.sort(distCipTs);
+        int index = distCipTs.indexOf(currentHour - RECENT_COUNT_HOUR * 3600);
+        String[] distCipArr = new String[index];
+        long[] disCipTsArr = new long[index];
+        if (distCip.size() + 1 == distCipTs.size()){
+            for (int i = 0; i < index; i++) {
+                distCipArr[i] = distCip.get(i);
+                disCipTsArr[i] = distCipTs.get(i);
+            }
+        }
+        doc.updateAttribute("DIST_CIP", distCipArr);
+        doc.updateAttribute("DIST_CIP_TS", disCipTsArr);
+    }
+
+}

ip-learning-spark/src/main/java/cn/ac/iie/utils/ClickhouseConnect.java

@@ -1,93 +0,0 @@
-package cn.ac.iie.utils;
-
-import cn.ac.iie.config.ApplicationConfig;
-import com.alibaba.druid.pool.DruidDataSource;
-import com.alibaba.druid.pool.DruidPooledConnection;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.sql.Connection;
-import java.sql.SQLException;
-import java.sql.Statement;
-
-public class ClickhouseConnect {
-    private static final Logger LOG = LoggerFactory.getLogger(ClickhouseConnect.class);
-    private static DruidDataSource dataSource = null;
-    private static ClickhouseConnect dbConnect = null;
-
-    static {
-        getDbConnect();
-    }
-
-    private static void getDbConnect() {
-        try {
-            if (dataSource == null) {
-                dataSource = new DruidDataSource();
-                //设置连接参数
-                dataSource.setUrl(ApplicationConfig.SPARK_WRITE_CLICKHOUSE_URL());
-                dataSource.setDriverClassName(ApplicationConfig.SPARK_READ_CLICKHOUSE_DRIVER());
-                dataSource.setUsername(ApplicationConfig.SPARK_READ_CLICKHOUSE_USER());
-                dataSource.setPassword(ApplicationConfig.SPARK_READ_CLICKHOUSE_PASSWORD());
-                //配置初始化大小、最小、最大
-                dataSource.setInitialSize(ApplicationConfig.SPARK_WRITE_CLICKHOUSE_INITIALSIZE());
-                dataSource.setMinIdle(ApplicationConfig.SPARK_WRITE_CLICKHOUSE_MINIDLE());
-                dataSource.setMaxActive(ApplicationConfig.SPARK_WRITE_CLICKHOUSE_MAXACTIVE());
-                //配置获取连接等待超时的时间
-                dataSource.setMaxWait(30000);
-                //配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
-                dataSource.setTimeBetweenEvictionRunsMillis(2000);
-                //防止过期
-                dataSource.setValidationQuery("SELECT 1");
-                dataSource.setTestWhileIdle(true);
-                dataSource.setTestOnBorrow(true);
-                dataSource.setKeepAlive(true);
-            }
-        } catch (Exception e) {
-            LOG.error(e.getMessage());
-
-        }
-    }
-
-    /**
-     * 数据库连接池单例
-     *
-     * @return dbConnect
-     */
-    public static synchronized ClickhouseConnect getInstance() {
-        if (null == dbConnect) {
-            dbConnect = new ClickhouseConnect();
-        }
-        return dbConnect;
-    }
-
-    /**
-     * 返回druid数据库连接
-     *
-     * @return 连接
-     * @throws SQLException sql异常
-     */
-    public DruidPooledConnection getConnection() throws SQLException {
-        return dataSource.getConnection();
-    }
-
-    /**
-     * 清空PreparedStatement、Connection对象，未定义的置空。
-     *
-     * @param pstmt      PreparedStatement对象
-     * @param connection Connection对象
-     */
-    public void clear(Statement pstmt, Connection connection) {
-        try {
-            if (pstmt != null) {
-                pstmt.close();
-            }
-            if (connection != null) {
-                connection.close();
-            }
-        } catch (SQLException e) {
-            LOG.error(e.getMessage());
-        }
-
-    }
-
-}

ip-learning-spark/src/main/resources/application.properties

@@ -1,53 +1,39 @@
 #spark任务配置
-spark.sql.shuffle.partitions=5
+spark.sql.shuffle.partitions=10
 spark.executor.memory=4g
 spark.app.name=test
 spark.network.timeout=300s
-repartitionNumber=36
 spark.serializer=org.apache.spark.serializer.KryoSerializer
 master=local[*]
 #spark读取clickhouse配置
-spark.read.clickhouse.url=jdbc:clickhouse://192.168.40.186:8123/tsg_galaxy_v3
+spark.read.clickhouse.url=jdbc:clickhouse://192.168.44.67:8123/tsg_galaxy_v3
 spark.read.clickhouse.driver=ru.yandex.clickhouse.ClickHouseDriver
 spark.read.clickhouse.user=default
-spark.read.clickhouse.password=111111
-spark.read.clickhouse.numPartitions=10
+spark.read.clickhouse.password=ceiec2019
+spark.read.clickhouse.numPartitions=5
 spark.read.clickhouse.fetchsize=10000
 spark.read.clickhouse.partitionColumn=LAST_FOUND_TIME
-
-spark.write.clickhouse.url=jdbc:clickhouse://192.168.40.194:8123/ip_learning?socket_timeout=3600000
-spark.write.clickhouse.user=default
-spark.write.clickhouse.password=111111
-spark.write.clickhouse.initialsize=1
-spark.write.clickhouse.minidle=1
-spark.write.clickhouse.maxactive=50
-
 clickhouse.socket.timeout=300000
 #arangoDB配置
 arangoDB.host=192.168.40.182
 arangoDB.port=8529
 arangoDB.user=upsert
 arangoDB.password=ceiec2018
-#arangoDB.DB.name=insert_iplearn_index
 arangoDB.DB.name=ip-learning-test-0
+#arangoDB.DB.name=iplearn_media_domain
 arangoDB.ttl=3600
 
-thread.pool.number=5
+thread.pool.number=10
 
 #读取clickhouse时间范围方式，0：读取过去一小时；1：指定时间范围
 clickhouse.time.limit.type=1
-read.clickhouse.max.time=1598246519
-read.clickhouse.min.time=1597161600
+read.clickhouse.max.time=1603785961
+read.clickhouse.min.time=1603354682
 
-#读取arangoDB时间范围方式，0：正常读；1：指定时间范围
-arango.time.limit.type=0
-read.arango.max.time=1571245320
-read.arango.min.time=1571245200
-
-arangoDB.read.limit=
+arangoDB.read.limit=1
 update.arango.batch=10000
 
 distinct.client.ip.num=10000
 recent.count.hour=24
 
-update.interval=10800
+update.interval=3600

ip-learning-spark/src/main/scala/cn/ac/iie/config/ApplicationConfig.scala

@@ -21,13 +21,6 @@ object ApplicationConfig {
   val SPARK_READ_CLICKHOUSE_FETCHSIZE: String = config.getString("spark.read.clickhouse.fetchsize")
   val SPARK_READ_CLICKHOUSE_PARTITIONCOLUMN: String = config.getString("spark.read.clickhouse.partitionColumn")
 
-  val SPARK_WRITE_CLICKHOUSE_URL: String = config.getString("spark.write.clickhouse.url")
-  val SPARK_WRITE_CLICKHOUSE_USER: String = config.getString("spark.write.clickhouse.user")
-  val SPARK_WRITE_CLICKHOUSE_PASSWORD: String = config.getString("spark.write.clickhouse.password")
-  val SPARK_WRITE_CLICKHOUSE_INITIALSIZE: Int = config.getInt("spark.write.clickhouse.initialsize")
-  val SPARK_WRITE_CLICKHOUSE_MINIDLE: Int = config.getInt("spark.write.clickhouse.minidle")
-  val SPARK_WRITE_CLICKHOUSE_MAXACTIVE: Int = config.getInt("spark.write.clickhouse.maxactive")
-
   val ARANGODB_HOST: String= config.getString("arangoDB.host")
   val ARANGODB_PORT: Int = config.getInt("arangoDB.port")
   val ARANGODB_USER: String= config.getString("arangoDB.user")
@@ -43,12 +36,7 @@ object ApplicationConfig {
   val READ_CLICKHOUSE_MAX_TIME: Long = config.getLong("read.clickhouse.max.time")
   val READ_CLICKHOUSE_MIN_TIME: Long = config.getLong("read.clickhouse.min.time")
 
-  val ARANGO_TIME_LIMIT_TYPE: Int = config.getInt("arango.time.limit.type")
-
-  val READ_ARANGO_MAX_TIME: Long = config.getLong("read.arango.max.time")
-  val READ_ARANGO_MIN_TIME: Long = config.getLong("read.arango.min.time")
-
-  val ARANGODB_READ_LIMIT: String = config.getString("arangoDB.read.limit")
+  val ARANGODB_READ_LIMIT: Int = config.getInt("arangoDB.read.limit")
   val UPDATE_ARANGO_BATCH: Int = config.getInt("update.arango.batch")
   val RECENT_COUNT_HOUR: Int = config.getInt("recent.count.hour")
   val DISTINCT_CLIENT_IP_NUM: Int = config.getInt("distinct.client.ip.num")

ip-learning-spark/src/main/scala/cn/ac/iie/dao/BaseClickhouseData.scala

@@ -28,11 +28,12 @@ object BaseClickhouseData {
       .load()
     dataFrame.printSchema()
     dataFrame.createOrReplaceGlobalTempView("dbtable")
+
     dataFrame
   }
 
   def loadConnectionDataFromCk(): Unit ={
-    val where = "common_recv_time >= " + timeLimit._2 + " AND common_recv_time < " + timeLimit._1 + " AND common_schema_type != 'BASE'"
+    val where = "common_recv_time >= " + timeLimit._2 + " AND common_recv_time < " + timeLimit._1
     val sql =
       s"""
         |(SELECT
@@ -69,41 +70,7 @@ object BaseClickhouseData {
     initClickhouseData(sql)
   }
 
-  def getVertexFqdnDf: DataFrame ={
-    loadConnectionDataFromCk()
-    val sql =
-      """
-        |SELECT
-        | FQDN,MAX( LAST_FOUND_TIME ) AS LAST_FOUND_TIME,MIN( FIRST_FOUND_TIME ) AS FIRST_FOUND_TIME
-        |FROM
-        | (
-        |  (SELECT
-        |    ssl_sni AS FQDN,MAX( common_recv_time ) AS LAST_FOUND_TIME,MIN( common_recv_time ) AS FIRST_FOUND_TIME
-        |   FROM
-        |    global_temp.dbtable
-        |   WHERE
-        |    common_schema_type = 'SSL' GROUP BY ssl_sni
-        |  )
-        |  UNION ALL
-        |  (SELECT
-        |    http_host AS FQDN,MAX( common_recv_time ) AS LAST_FOUND_TIME,MIN( common_recv_time ) AS FIRST_FOUND_TIME
-        |   FROM
-        |    global_temp.dbtable
-        |   WHERE
-        |    common_schema_type = 'HTTP' GROUP BY http_host
-        |  )
-        | )
-        |GROUP BY
-        | FQDN
-        |HAVING
-        | FQDN != ''
-      """.stripMargin
-    LOG.warn(sql)
-    val vertexFqdnDf = spark.sql(sql)
-    vertexFqdnDf.printSchema()
-    vertexFqdnDf
-  }
-
+  /*
   def getVertexIpDf: DataFrame ={
     loadConnectionDataFromCk()
     val sql =
@@ -147,30 +114,6 @@ object BaseClickhouseData {
     vertexIpDf
   }
 
-  def getRelationFqdnLocateIpDf(): DataFrame ={
-    val where = "common_end_time >= " + timeLimit._2 + " AND common_end_time < " + timeLimit._1
-    val sql =
-      s"""
-         |(SELECT * FROM
-         |((SELECT ssl_sni AS FQDN,common_server_ip,MAX(common_end_time) AS LAST_FOUND_TIME,MIN(common_end_time) AS FIRST_FOUND_TIME,COUNT(*) AS COUNT_TOTAL,
-         |toString(groupUniqArray(${ApplicationConfig.DISTINCT_CLIENT_IP_NUM})(common_client_ip)) AS DIST_CIP_RECENT,'TLS' AS  schema_type
-         |FROM tsg_galaxy_v3.connection_record_log
-         |WHERE $where and common_schema_type = 'SSL' GROUP BY ssl_sni,common_server_ip)
-         |UNION ALL
-         |(SELECT http_host AS FQDN,common_server_ip,MAX(common_end_time) AS LAST_FOUND_TIME,MIN(common_end_time) AS FIRST_FOUND_TIME,COUNT(*) AS COUNT_TOTAL,
-         |toString(groupUniqArray(${ApplicationConfig.DISTINCT_CLIENT_IP_NUM})(common_client_ip)) AS DIST_CIP_RECENT,'HTTP' AS schema_type
-         |FROM tsg_galaxy_v3.connection_record_log
-         |WHERE $where and common_schema_type = 'HTTP' GROUP BY http_host,common_server_ip))
-         |WHERE FQDN != '') as dbtable
-      """.stripMargin
-    LOG.warn(sql)
-    val frame = initClickhouseData(sql)
-    frame.printSchema()
-    frame
-  }
-
-
-  /*
   def getRelationFqdnLocateIpDf: DataFrame ={
     loadConnectionDataFromCk()
     val sslSql =
@@ -217,6 +160,148 @@ object BaseClickhouseData {
   }
   */
 
+  def getVertexFqdnDf: DataFrame ={
+    val sql =
+      """
+        |(SELECT
+        | FQDN,MAX( LAST_FOUND_TIME ) AS LAST_FOUND_TIME,MIN( FIRST_FOUND_TIME ) AS FIRST_FOUND_TIME
+        |FROM
+        | ((SELECT
+        |    ssl_sni AS FQDN,MAX( common_recv_time ) AS LAST_FOUND_TIME,MIN( common_recv_time ) AS FIRST_FOUND_TIME
+        |   FROM tsg_galaxy_v3.connection_record_log
+        |   WHERE common_schema_type = 'SSL' GROUP BY ssl_sni
+        |  )UNION ALL
+        |  (SELECT
+        |    http_host AS FQDN,MAX( common_recv_time ) AS LAST_FOUND_TIME,MIN( common_recv_time ) AS FIRST_FOUND_TIME
+        |   FROM tsg_galaxy_v3.connection_record_log
+        |   WHERE common_schema_type = 'HTTP' GROUP BY http_host))
+        |GROUP BY FQDN HAVING FQDN != '') as dbtable
+      """.stripMargin
+    LOG.warn(sql)
+    val frame = initClickhouseData(sql)
+    frame.printSchema()
+    frame
+  }
+
+  def getVertexIpDf: DataFrame ={
+    val where = "common_recv_time >= " + timeLimit._2 + " AND common_recv_time < " + timeLimit._1
+    val sql =
+      s"""
+         |(SELECT * FROM
+         |((SELECT common_client_ip AS IP,MIN(common_recv_time) AS FIRST_FOUND_TIME,
+         |MAX(common_recv_time) AS LAST_FOUND_TIME,
+         |count(*) as SESSION_COUNT,
+         |SUM(common_c2s_byte_num+common_s2c_byte_num) as BYTES_SUM,
+         |groupUniqArray(2)(common_link_info_c2s)[2] as common_link_info,
+         |'client' as ip_type
+         |FROM tsg_galaxy_v3.connection_record_log
+         |where $where
+         |group by common_client_ip)
+         |UNION ALL
+         |(SELECT common_server_ip AS IP,
+         |MIN(common_recv_time) AS FIRST_FOUND_TIME,
+         |MAX(common_recv_time) AS LAST_FOUND_TIME,
+         |count(*) as SESSION_COUNT,
+         |SUM(common_c2s_byte_num+common_s2c_byte_num) as BYTES_SUM,
+         |groupUniqArray(2)(common_link_info_s2c)[2] as common_link_info,
+         |'server' as ip_type
+         |FROM tsg_galaxy_v3.connection_record_log
+         |where $where
+         |group by common_server_ip))) as dbtable
+      """.stripMargin
+    LOG.warn(sql)
+    val frame = initClickhouseData(sql)
+    frame.printSchema()
+    frame
+  }
+
+
+  def getRelationFqdnLocateIpDf: DataFrame ={
+    val where = "common_recv_time >= " + timeLimit._2 + " AND common_recv_time < " + timeLimit._1
+    val sql =
+      s"""
+         |(SELECT * FROM
+         |((SELECT ssl_sni AS FQDN,common_server_ip,MAX(common_recv_time) AS LAST_FOUND_TIME,MIN(common_recv_time) AS FIRST_FOUND_TIME,COUNT(*) AS COUNT_TOTAL,
+         |toString(groupUniqArray(${ApplicationConfig.DISTINCT_CLIENT_IP_NUM})(common_client_ip)) AS DIST_CIP_RECENT,'TLS' AS  schema_type
+         |FROM tsg_galaxy_v3.connection_record_log
+         |WHERE $where and common_schema_type = 'SSL' GROUP BY ssl_sni,common_server_ip)
+         |UNION ALL
+         |(SELECT http_host AS FQDN,common_server_ip,MAX(common_recv_time) AS LAST_FOUND_TIME,MIN(common_recv_time) AS FIRST_FOUND_TIME,COUNT(*) AS COUNT_TOTAL,
+         |toString(groupUniqArray(${ApplicationConfig.DISTINCT_CLIENT_IP_NUM})(common_client_ip)) AS DIST_CIP_RECENT,'HTTP' AS schema_type
+         |FROM tsg_galaxy_v3.connection_record_log
+         |WHERE $where and common_schema_type = 'HTTP' GROUP BY http_host,common_server_ip))
+         |WHERE FQDN != '') as dbtable
+      """.stripMargin
+    LOG.warn(sql)
+    val frame = initClickhouseData(sql)
+    frame.printSchema()
+    frame
+  }
+
+  def getRelationSubidLocateIpDf: DataFrame ={
+    val where =
+      s"""
+         | common_recv_time >= ${timeLimit._2}
+         | AND common_recv_time < ${timeLimit._1}
+         | AND common_subscriber_id != ''
+         | AND radius_framed_ip != ''
+      """.stripMargin
+    val sql =
+      s"""
+         |(
+         |SELECT common_subscriber_id,radius_framed_ip,MAX(common_recv_time) as LAST_FOUND_TIME,MIN(common_recv_time) as FIRST_FOUND_TIME
+         |FROM radius_record_log
+         |WHERE $where GROUP BY common_subscriber_id,radius_framed_ip
+         |) as dbtable
+      """.stripMargin
+    LOG.warn(sql)
+    val frame = initClickhouseData(sql)
+    frame.printSchema()
+    frame
+  }
+
+  def getVertexSubidDf: DataFrame ={
+    val where =
+      s"""
+         | common_recv_time >= ${timeLimit._2}
+         | AND common_recv_time < ${timeLimit._1}
+         | AND common_subscriber_id != ''
+         | AND radius_framed_ip != ''
+      """.stripMargin
+    val sql =
+      s"""
+         |(
+         |SELECT common_subscriber_id,MAX(common_recv_time) as LAST_FOUND_TIME,MIN(common_recv_time) as FIRST_FOUND_TIME FROM radius_record_log
+         |WHERE $where GROUP BY common_subscriber_id
+         |)as dbtable
+      """.stripMargin
+    LOG.warn(sql)
+    val frame = initClickhouseData(sql)
+    frame.printSchema()
+    frame
+  }
+
+  def getVertexFramedIpDf: DataFrame ={
+    val where =
+      s"""
+         | common_recv_time >= ${timeLimit._2}
+         | AND common_recv_time < ${timeLimit._1}
+         | AND common_subscriber_id != ''
+         | AND radius_framed_ip != ''
+      """.stripMargin
+    val sql =
+      s"""
+         |(
+         |SELECT DISTINCT radius_framed_ip,common_recv_time as LAST_FOUND_TIME FROM radius_record_log WHERE $where
+         |)as dbtable
+      """.stripMargin
+    LOG.warn(sql)
+    val frame = initClickhouseData(sql)
+    frame.printSchema()
+    frame
+  }
+
+
   private def getTimeLimit: (Long,Long) ={
     var maxTime = 0L
     var minTime = 0L

ip-learning-spark/src/main/scala/cn/ac/iie/service/transform/MergeDataFrame.scala

@@ -4,40 +4,57 @@ import java.util.regex.Pattern
 
 import cn.ac.iie.config.ApplicationConfig
 import cn.ac.iie.dao.BaseClickhouseData
+import cn.ac.iie.spark.ArangoSpark
 import cn.ac.iie.spark.partition.CustomPartitioner
+import cn.ac.iie.spark.rdd.ReadOptions
+import com.arangodb.entity.{BaseDocument, BaseEdgeDocument}
 import org.apache.spark.rdd.RDD
-import org.apache.spark.sql.{DataFrame, Row}
+import org.apache.spark.sql.Row
 import org.apache.spark.sql.functions._
 import org.slf4j.LoggerFactory
-
+import cn.ac.iie.utils.SparkSessionUtil._
 
 object MergeDataFrame {
   private val LOG = LoggerFactory.getLogger(MergeDataFrame.getClass)
   private val pattern = Pattern.compile("^[\\d]*$")
+  private val options = ReadOptions(ApplicationConfig.ARANGODB_DB_NAME)
 
-  private val currentHour: Long = System.currentTimeMillis / (60 * 60 * 1000) * 60 * 60
+  def mergeVertexFqdn(): RDD[(String, (Option[BaseDocument], Option[Row]))] ={
+    val fqdnAccmu = getLongAccumulator("FQDN Accumulator")
+    val fqdnRddRow = BaseClickhouseData.getVertexFqdnDf
+      .rdd.filter(row => isDomain(row.getAs[String](0))).map(row => {
+      fqdnAccmu.add(1)
+      (row.getAs[String]("FQDN"), row)
+    }).partitionBy(new CustomPartitioner(ApplicationConfig.SPARK_SQL_SHUFFLE_PARTITIONS))
+    fqdnRddRow.cache()
+    val fqdnRddDoc = ArangoSpark.load[BaseDocument](sparkContext,"FQDN",options)
 
-  def mergeVertexFqdn(): RDD[Row] ={
-    BaseClickhouseData.getVertexFqdnDf
-      .rdd.filter(row => isDomain(row.getAs[String](0))).map(row => (row.get(0),row))
-      .partitionBy(new CustomPartitioner(ApplicationConfig.SPARK_SQL_SHUFFLE_PARTITIONS)).values
+    fqdnRddDoc.map(doc => (doc.getKey, doc)).fullOuterJoin(fqdnRddRow)
   }
 
-  def mergeVertexIp(): RDD[Row]={
+  def mergeVertexIp(): RDD[(String, (Option[BaseDocument], Option[Row]))]={
+    val ipAccum = getLongAccumulator("IP Accumulator")
     val vertexIpDf = BaseClickhouseData.getVertexIpDf
     val frame = vertexIpDf.groupBy("IP").agg(
       min("FIRST_FOUND_TIME").alias("FIRST_FOUND_TIME"),
       max("LAST_FOUND_TIME").alias("LAST_FOUND_TIME"),
       collect_list("SESSION_COUNT").alias("SESSION_COUNT_LIST"),
       collect_list("BYTES_SUM").alias("BYTES_SUM_LIST"),
-      collect_list("ip_type").alias("ip_type_list")
+      collect_list("ip_type").alias("ip_type_list"),
+      last("common_link_info").alias("common_link_info")
     )
-    val values = frame.rdd.map(row => (row.get(0), row))
-      .partitionBy(new CustomPartitioner(ApplicationConfig.SPARK_SQL_SHUFFLE_PARTITIONS)).values
-    values
+    val ipRddRow = frame.rdd.map(row => {
+      ipAccum.add(1)
+      (row.getAs[String]("IP"), row)
+    }).partitionBy(new CustomPartitioner(ApplicationConfig.SPARK_SQL_SHUFFLE_PARTITIONS))
+    val ipRddDoc = ArangoSpark.load[BaseDocument](sparkContext,"IP",options)
+
+    ipRddDoc.map(doc => (doc.getKey, doc)).fullOuterJoin(ipRddRow)
+
   }
 
-  def mergeRelationFqdnLocateIp(): DataFrame ={
+  def mergeRelationFqdnLocateIp(): RDD[(String, (Option[BaseEdgeDocument], Option[Row]))] ={
+    val fqdnLocIpAccum = getLongAccumulator("R_LOCATE_FQDN2IP Accumulator")
     val frame = BaseClickhouseData.getRelationFqdnLocateIpDf.filter(row => isDomain(row.getAs[String]("FQDN")))
       .groupBy("FQDN", "common_server_ip")
       .agg(
@@ -46,8 +63,62 @@ object MergeDataFrame {
         collect_list("COUNT_TOTAL").alias("COUNT_TOTAL_LIST"),
         collect_list("schema_type").alias("schema_type_list"),
         collect_set("DIST_CIP_RECENT").alias("DIST_CIP_RECENT")
-      ).repartition(ApplicationConfig.SPARK_SQL_SHUFFLE_PARTITIONS)
-    frame
+      )
+    val fqdnLocIpRddRow = frame.rdd.map(row => {
+      val fqdn = row.getAs[String]("FQDN")
+      val serverIp = row.getAs[String]("common_server_ip")
+      val key = fqdn.concat("-" + serverIp)
+      fqdnLocIpAccum.add(1)
+      (key, row)
+    }).partitionBy(new CustomPartitioner(ApplicationConfig.SPARK_SQL_SHUFFLE_PARTITIONS))
+    val fqdnLocIpRddDoc = ArangoSpark.load[BaseEdgeDocument](sparkContext,"R_LOCATE_FQDN2IP",options)
+
+    fqdnLocIpRddDoc.map(doc => (doc.getKey, doc)).fullOuterJoin(fqdnLocIpRddRow)
+
+  }
+
+  def mergeRelationSubidLocateIp(): RDD[(String, (Option[BaseEdgeDocument], Option[Row]))] ={
+    val subidLocIpAccum = getLongAccumulator("R_LOCATE_SUBSCRIBER2IP Accumulator")
+    val subidLocIpRddRow = BaseClickhouseData.getRelationSubidLocateIpDf
+      .repartition(ApplicationConfig.SPARK_SQL_SHUFFLE_PARTITIONS)
+      .rdd.map(row => {
+      val commonSubscriberId = row.getAs[String]("common_subscriber_id")
+      val ip = row.getAs[String]("radius_framed_ip")
+      val key = commonSubscriberId.concat("-" + ip)
+      subidLocIpAccum.add(1)
+      (key, row)
+    }).partitionBy(new CustomPartitioner(ApplicationConfig.SPARK_SQL_SHUFFLE_PARTITIONS))
+    val subidLocIpRddDoc = ArangoSpark.load[BaseEdgeDocument](sparkContext,"R_LOCATE_SUBSCRIBER2IP",options)
+
+    subidLocIpRddDoc.map(doc => (doc.getKey, doc)).fullOuterJoin(subidLocIpRddRow)
+  }
+
+  def mergeVertexSubid(): RDD[(String, (Option[BaseDocument], Option[Row]))] ={
+    val subidAccum = getLongAccumulator("SUBSCRIBER Accumulator")
+    val subidRddRow = BaseClickhouseData.getVertexSubidDf
+      .repartition(ApplicationConfig.SPARK_SQL_SHUFFLE_PARTITIONS)
+      .rdd.map(row => {
+      val commonSubscriberId = row.getAs[String]("common_subscriber_id")
+      subidAccum.add(1)
+      (commonSubscriberId, row)
+    }).partitionBy(new CustomPartitioner(ApplicationConfig.SPARK_SQL_SHUFFLE_PARTITIONS))
+
+    val subidRddDoc = ArangoSpark.load[BaseDocument](sparkContext,"SUBSCRIBER",options)
+
+    subidRddDoc.map(doc => (doc.getKey, doc)).fullOuterJoin(subidRddRow)
+
+  }
+
+  def mergeVertexFrameIp: RDD[Row] ={
+    val framedIpAccum = getLongAccumulator("framed ip Accumulator")
+    val values = BaseClickhouseData.getVertexFramedIpDf
+      .repartition(ApplicationConfig.SPARK_SQL_SHUFFLE_PARTITIONS)
+      .rdd.map(row => {
+      val ip = row.getAs[String]("radius_framed_ip")
+      framedIpAccum.add(1)
+      (ip, row)
+    }).partitionBy(new CustomPartitioner(ApplicationConfig.SPARK_SQL_SHUFFLE_PARTITIONS)).values
+    values
   }
 
   private def isDomain(fqdn: String): Boolean = {
@@ -55,10 +126,10 @@ object MergeDataFrame {
       if (fqdn == null || fqdn.length == 0) {
         return false
       }
-      val domain = fqdn.split(":")(0)
 
-      val fqdnArr = domain.split("\\.")
-      if (fqdnArr.length < 4 || fqdnArr.length > 4){
+      val fqdnArr = fqdn.split(":")(0).split("\\.")
+
+      if (fqdnArr.length != 4){
         return true
       }
       for (f <- fqdnArr) {
@@ -76,6 +147,7 @@ object MergeDataFrame {
         LOG.error("解析域名 " + fqdn + " 失败：\n" + e.toString)
     }
     false
+
   }
 
 }

ip-learning-spark/src/main/scala/cn/ac/iie/service/update/UpdateDocHandler.scala

@@ -1,9 +1,11 @@
 package cn.ac.iie.service.update
 
 
-import java.lang
+import java.util
+import scala.collection.JavaConversions._
 
 import cn.ac.iie.config.ApplicationConfig
+import cn.ac.iie.service.read.ReadHistoryArangoData
 import com.arangodb.entity.{BaseDocument, BaseEdgeDocument}
 
 import scala.collection.mutable
@@ -12,20 +14,26 @@ import scala.collection.mutable.WrappedArray.ofRef
 object UpdateDocHandler {
   val PROTOCOL_SET: Set[String] = Set("HTTP","TLS","DNS")
 
-  private val currentHour: Long = System.currentTimeMillis / (60 * 60 * 1000) * 60 * 60
-
   def updateMaxAttribute(hisDoc: BaseDocument,newAttribute:Long,attributeName:String): Unit ={
+    if(hisDoc.getProperties.containsKey(attributeName)){
       var hisAttritube = hisDoc.getAttribute(attributeName).toString.toLong
       if (newAttribute > hisAttritube){
         hisAttritube = newAttribute
       }
       hisDoc.addAttribute(attributeName,hisAttritube)
     }
+  }
 
   def updateSumAttribute(hisDoc: BaseDocument,newAttribute:Long,attributeName:String): Unit ={
+    if (hisDoc.getProperties.containsKey(attributeName)){
       val hisAttritube = hisDoc.getAttribute(attributeName).toString.toLong
       hisDoc.addAttribute(attributeName,newAttribute+hisAttritube)
     }
+  }
+
+  def replaceAttribute(hisDoc: BaseDocument,newAttribute:String,attributeName:String): Unit ={
+    hisDoc.addAttribute(attributeName,newAttribute)
+  }
 
   def separateAttributeByIpType(ipTypeList:ofRef[String],
                                 sessionCountList:ofRef[AnyRef],
@@ -63,20 +71,22 @@ object UpdateDocHandler {
   }
 
   def updateProtocolAttritube(hisDoc:BaseEdgeDocument, protocolMap: Map[String, Long]): Unit ={
+    if (hisDoc.getProperties.containsKey("PROTOCOL_TYPE")){
       var protocolType = hisDoc.getAttribute("PROTOCOL_TYPE").toString
-    protocolMap.foreach(t => {
+      protocolMap.foreach((t: (String, Long)) => {
         if (t._2 > 0 && !protocolType.contains(t._1)){
           protocolType = protocolType.concat(","+ t._1)
         }
         val cntTotalName = t._1.concat("_CNT_TOTAL")
         val cntRecentName = t._1.concat("_CNT_RECENT")
-      val cntRecent: Array[lang.Long] = hisDoc.getAttribute(cntRecentName).asInstanceOf[Array[java.lang.Long]]
+        val cntRecent = hisDoc.getAttribute(cntRecentName).asInstanceOf[Array[Long]]
         cntRecent.update(0,t._2)
         updateSumAttribute(hisDoc,t._2,cntTotalName)
         hisDoc.addAttribute(cntRecentName,cntRecent)
       })
       hisDoc.addAttribute("PROTOCOL_TYPE",protocolType)
     }
+  }
 
   def putProtocolAttritube(doc:BaseEdgeDocument, protocolMap: Map[String, Long]): Unit ={
     val protocolTypeBuilder = new mutable.StringBuilder()
@@ -94,45 +104,53 @@ object UpdateDocHandler {
     doc.addAttribute("PROTOCOL_TYPE",protocolTypeBuilder.toString().replaceFirst(",",""))
   }
 
-  /*
-  def mergeDistinctIp(distCipRecent:ofRef[ofRef[String]]): Array[String] ={
-     distCipRecent.flatten.distinct.take(ApplicationConfig.DISTINCT_CLIENT_IP_NUM).toArray
+  def updateProtocolDocument(doc: BaseEdgeDocument): Unit = {
+    if (doc.getProperties.containsKey("PROTOCOL_TYPE")) {
+      for (protocol <- PROTOCOL_SET) {
+        val protocolRecent = protocol + "_CNT_RECENT"
+        val cntRecent: util.ArrayList[Long] = doc.getAttribute(protocolRecent).asInstanceOf[util.ArrayList[Long]]
+        val cntRecentsSrc = cntRecent.toArray().map(_.toString.toLong)
+        val cntRecentsDst = new Array[Long](24)
+        System.arraycopy(cntRecentsSrc, 0, cntRecentsDst, 1, cntRecentsSrc.length - 1)
+        cntRecentsDst(0) = 0L
+        doc.addAttribute(protocolRecent, cntRecentsDst)
+      }
+    }
   }
-  */
 
   def mergeDistinctIp(distCipRecent:ofRef[String]): Array[String] ={
     distCipRecent.flatMap(str => {
       str.replaceAll("\\[","")
         .replaceAll("\\]","")
-        .replaceAll("'", "")
+        .replaceAll("\\'","")
         .split(",")
-    }).distinct.toArray
-    //     distCipRecent.flatten.distinct.take(ApplicationConfig.DISTINCT_CLIENT_IP_NUM).toArray
+    }).distinct.take(ApplicationConfig.DISTINCT_CLIENT_IP_NUM).toArray
   }
 
 
-
   def putDistinctIp(doc:BaseEdgeDocument,newDistinctIp:Array[String]): Unit ={
     val map = newDistinctIp.map(ip => {
-      (ip, currentHour)
+      (ip, ReadHistoryArangoData.currentHour)
     }).toMap
     doc.addAttribute("DIST_CIP",map.keys.toArray)
     doc.addAttribute("DIST_CIP_TS",map.values.toArray)
   }
 
   def updateDistinctIp(hisDoc:BaseEdgeDocument,newDistinctIp:Array[String]): Unit ={
-    val hisDistCip = hisDoc.getAttribute("DIST_CIP").asInstanceOf[Array[String]]
-    val hisDistCipTs = hisDoc.getAttribute("DIST_CIP_TS").asInstanceOf[Array[Long]]
+    if (hisDoc.getProperties.containsKey("DIST_CIP") && hisDoc.getProperties.containsKey("DIST_CIP_TS")){
+      val hisDistCip = hisDoc.getAttribute("DIST_CIP").asInstanceOf[util.ArrayList[String]]
+      val hisDistCipTs = hisDoc.getAttribute("DIST_CIP_TS").asInstanceOf[util.ArrayList[Long]]
       if (hisDistCip.length == hisDistCipTs.length){
         val distCipToTsMap: Map[String, Long] = hisDistCip.zip(hisDistCipTs).toMap
         val muDistCipToTsMap: mutable.Map[String, Long] = mutable.Map(distCipToTsMap.toSeq:_*)
         newDistinctIp.foreach(cip => {
-        muDistCipToTsMap.put(cip,currentHour)
+          muDistCipToTsMap.put(cip,ReadHistoryArangoData.currentHour)
         })
         val resultMap = muDistCipToTsMap.toList.sortBy(-_._2).take(ApplicationConfig.DISTINCT_CLIENT_IP_NUM).toMap
         hisDoc.addAttribute("DIST_CIP",resultMap.keys.toArray)
         hisDoc.addAttribute("DIST_CIP_TS",resultMap.values.toArray)
       }
     }
+  }
 
 }

ip-learning-spark/src/main/scala/cn/ac/iie/service/update/UpdateDocument.scala

@@ -1,145 +1,308 @@
 package cn.ac.iie.service.update
 
-import java.sql.PreparedStatement
-import java.util.concurrent.ConcurrentHashMap
+import java.util
 
 import cn.ac.iie.config.ApplicationConfig
-import cn.ac.iie.service.update.UpdateDocHandler._
-import cn.ac.iie.utils.{ClickhouseConnect, SparkSessionUtil}
 import cn.ac.iie.service.transform.MergeDataFrame._
-import com.alibaba.druid.pool.DruidPooledConnection
+import cn.ac.iie.service.update.UpdateDocHandler._
+import cn.ac.iie.utils.{ArangoDBConnect, SparkSessionUtil}
 import com.arangodb.entity.{BaseDocument, BaseEdgeDocument}
-import org.apache.spark.sql.{DataFrame, Row}
+import org.apache.spark.rdd.RDD
+import org.apache.spark.sql.Row
 import org.slf4j.LoggerFactory
-import ru.yandex.clickhouse.ClickHouseArray
 
 import scala.collection.mutable.WrappedArray.ofRef
 
 object UpdateDocument {
+  private val arangoManger: ArangoDBConnect = ArangoDBConnect.getInstance()
   private val LOG = LoggerFactory.getLogger(UpdateDocument.getClass)
 
-  private val manger: ClickhouseConnect = ClickhouseConnect.getInstance()
-  private val currentHour: Long = System.currentTimeMillis / (60 * 60 * 1000) * 60 * 60
-
   def update(): Unit = {
     try {
-      updateDocument("r_locate_fqdn2ip_local", getRelationFqdnLocIpPstm, mergeRelationFqdnLocateIp)
+      updateDocument("FQDN", getVertexFqdnRow, mergeVertexFqdn)
+
+      updateDocument("SUBSCRIBER",getVertexSubidRow,mergeVertexSubid)
+
+      insertFrameIp()
+
+      updateDocument("R_LOCATE_SUBSCRIBER2IP",getRelationSubidLocateIpRow,mergeRelationSubidLocateIp)
+
+      updateDocument("R_LOCATE_FQDN2IP", getRelationFqdnLocateIpRow, mergeRelationFqdnLocateIp)
+
+      updateDocument("IP", getVertexIpRow, mergeVertexIp)
+
     } catch {
       case e: Exception => e.printStackTrace()
     } finally {
+      arangoManger.clean()
       SparkSessionUtil.closeSpark()
+      System.exit(0)
     }
   }
 
-  private def updateDocument[T <: BaseDocument](tableName: String,
-                                                setPstm: (Row, PreparedStatement) => PreparedStatement,
-                                                getNewDataRdd: () => DataFrame): Unit = {
+  private def updateDocument[T <: BaseDocument](collName: String,
+                                                getDocumentRow: ((String, (Option[T], Option[Row]))) => T,
+                                                getJoinRdd: () => RDD[(String, (Option[T], Option[Row]))]
+                                               ): Unit = {
     try {
       val start = System.currentTimeMillis()
-      val newDataFrame = getNewDataRdd()
-
-      newDataFrame.foreachPartition(iter => {
-        val connection: DruidPooledConnection = manger.getConnection
-        val sql = s"INSERT INTO $tableName VALUES(?,?,?,?,?,?,?,?,?)"
-        var pstm: PreparedStatement = connection.prepareStatement(sql)
+      val joinRdd = getJoinRdd()
+      joinRdd.foreachPartition(iter => {
+        val resultDocumentList = new util.ArrayList[T]
         var i = 0
         iter.foreach(row => {
-          pstm = setPstm(row,pstm)
+          val document = getDocumentRow(row)
+          if (document != null){
+            resultDocumentList.add(document)
+          }
           i += 1
-          pstm.addBatch()
           if (i >= ApplicationConfig.UPDATE_ARANGO_BATCH) {
-            pstm.executeBatch()
-            connection.commit()
-            LOG.warn(s"写入$tableName 数据量：" + i)
+            arangoManger.overwrite(resultDocumentList, collName)
+            LOG.warn(s"更新:$collName" + i)
             i = 0
           }
         })
         if (i != 0) {
-          pstm.executeBatch
-          connection.commit()
-          LOG.warn(s"写入$tableName 数据量：" + i)
+          arangoManger.overwrite(resultDocumentList, collName)
+          LOG.warn(s"更新$collName:" + i)
         }
-        manger.clear(pstm,connection)
       })
       val last = System.currentTimeMillis()
-      LOG.warn(s"更新$tableName 时间：${last - start}")
+      LOG.warn(s"更新$collName 时间：${last - start}")
     } catch {
       case e: Exception => e.printStackTrace()
     }
   }
 
-  private def getRelationFqdnLocIpPstm(row: Row,pstm: PreparedStatement): PreparedStatement ={
-    val fqdn = row.getAs[String]("FQDN")
-    val serverIp = row.getAs[String]("common_server_ip")
-    val firstFoundTime = row.getAs[Long]("FIRST_FOUND_TIME")
-    val lastFoundTime = row.getAs[Long]("LAST_FOUND_TIME")
-    val countTotalList = row.getAs[ofRef[AnyRef]]("COUNT_TOTAL_LIST")
-    val schemaTypeList = row.getAs[ofRef[AnyRef]]("schema_type_list")
-
-    val distCipRecent = row.getAs[ofRef[String]]("DIST_CIP_RECENT")
-    val disCips = mergeDistinctIp(distCipRecent)
-
-    val sepAttritubeMap: Map[String, Long] = separateAttributeByProtocol(schemaTypeList, countTotalList)
-
-    pstm.setString(1,fqdn)
-    pstm.setString(2,serverIp)
-    pstm.setLong(3,firstFoundTime)
-    pstm.setLong(4,lastFoundTime)
-    pstm.setLong(5,sepAttritubeMap.getOrElse("HTTP",0L))
-    pstm.setLong(6,sepAttritubeMap.getOrElse("TLS",0L))
-    pstm.setLong(7,sepAttritubeMap.getOrElse("DNS",0L))
-    pstm.setArray(8,new ClickHouseArray(1, disCips))
-    pstm.setLong(9,currentHour)
-
-    pstm
+  private def insertFrameIp(): Unit ={
+    mergeVertexFrameIp.foreachPartition(iter => {
+      val resultDocumentList = new util.ArrayList[BaseDocument]
+      var i = 0
+      iter.foreach(row => {
+        val document = getVertexFrameipRow(row)
+        resultDocumentList.add(document)
+        i += 1
+        if (i >= ApplicationConfig.UPDATE_ARANGO_BATCH) {
+          arangoManger.overwrite(resultDocumentList, "IP")
+          LOG.warn(s"更新:IP" + i)
+          i = 0
+        }
+      })
+      if (i != 0) {
+        arangoManger.overwrite(resultDocumentList, "IP")
+        LOG.warn(s"更新IP:" + i)
+      }
+    })
   }
 
-  private def getVertexFqdnRow(row: Row, dictionaryMap: ConcurrentHashMap[String, BaseDocument]): BaseDocument = {
-    val fqdn = row.getAs[String]("FQDN")
-    val lastFoundTime = row.getAs[Long]("LAST_FOUND_TIME")
-    val firstFoundTime = row.getAs[Long]("FIRST_FOUND_TIME")
-    var document: BaseDocument = dictionaryMap.getOrDefault(fqdn, null)
-    if (document != null) {
-      updateMaxAttribute(document, lastFoundTime, "LAST_FOUND_TIME")
-    } else {
-      document = new BaseDocument
-      document.setKey(fqdn)
-      document.addAttribute("FQDN_NAME", fqdn)
-      document.addAttribute("FIRST_FOUND_TIME", firstFoundTime)
-      document.addAttribute("LAST_FOUND_TIME", lastFoundTime)
-    }
-    document
-  }
-
-  private def getVertexIpRow(row: Row, dictionaryMap: ConcurrentHashMap[String, BaseDocument]): BaseDocument = {
-    val ip = row.getAs[String]("IP")
-    val firstFoundTime = row.getAs[Long]("FIRST_FOUND_TIME")
-    val lastFoundTime = row.getAs[Long]("LAST_FOUND_TIME")
-    val sessionCountList = row.getAs[ofRef[AnyRef]]("SESSION_COUNT_LIST")
-    val bytesSumList = row.getAs[ofRef[AnyRef]]("BYTES_SUM_LIST")
-    val ipTypeList = row.getAs[ofRef[String]]("ip_type_list")
-    val sepAttributeTuple = separateAttributeByIpType(ipTypeList, sessionCountList, bytesSumList)
-
-    var document = dictionaryMap.getOrDefault(ip, null)
-    if (document != null) {
-      updateMaxAttribute(document, lastFoundTime, "LAST_FOUND_TIME")
-      updateSumAttribute(document, sepAttributeTuple._1, "SERVER_SESSION_COUNT")
-      updateSumAttribute(document, sepAttributeTuple._2, "SERVER_BYTES_SUM")
-      updateSumAttribute(document, sepAttributeTuple._3, "CLIENT_SESSION_COUNT")
-      updateSumAttribute(document, sepAttributeTuple._4, "CLIENT_BYTES_SUM")
-    } else {
-      document = new BaseDocument
+  private def getVertexFrameipRow(row: Row): BaseDocument ={
+    val ip = row.getAs[String]("radius_framed_ip")
+    val document = new BaseDocument()
     document.setKey(ip)
     document.addAttribute("IP",ip)
-      document.addAttribute("FIRST_FOUND_TIME", firstFoundTime)
-      document.addAttribute("LAST_FOUND_TIME", lastFoundTime)
-      document.addAttribute("SERVER_SESSION_COUNT", sepAttributeTuple._1)
-      document.addAttribute("SERVER_BYTES_SUM", sepAttributeTuple._2)
-      document.addAttribute("CLIENT_SESSION_COUNT", sepAttributeTuple._3)
-      document.addAttribute("CLIENT_BYTES_SUM", sepAttributeTuple._4)
-      document.addAttribute("COMMON_LINK_INFO", "")
-    }
     document
   }
 
+  private def getRelationSubidLocateIpRow(joinRow: (String, (Option[BaseEdgeDocument], Option[Row]))): BaseEdgeDocument ={
+
+    val subidLocIpDocOpt = joinRow._2._1
+    var subidLocIpDoc = subidLocIpDocOpt match {
+      case Some(doc) => doc
+      case None => null
+    }
+
+    val subidLocIpRowOpt = joinRow._2._2
+
+    val subidLocIpRow = subidLocIpRowOpt match {
+      case Some(r) => r
+      case None => null
+    }
+
+    if (subidLocIpRow != null){
+      val subId = subidLocIpRow.getAs[String]("common_subscriber_id")
+      val ip = subidLocIpRow.getAs[String]("radius_framed_ip")
+      val lastFoundTime = subidLocIpRow.getAs[Long]("LAST_FOUND_TIME")
+      val firstFoundTime = subidLocIpRow.getAs[Long]("FIRST_FOUND_TIME")
+
+      val key = subId.concat("-"+ip)
+      if (subidLocIpDoc != null){
+        updateMaxAttribute(subidLocIpDoc,lastFoundTime,"LAST_FOUND_TIME")
+      } else {
+        subidLocIpDoc = new BaseEdgeDocument()
+        subidLocIpDoc.setKey(key)
+        subidLocIpDoc.setFrom("SUBSCRIBER/" + subId)
+        subidLocIpDoc.setTo("IP/" + ip)
+        subidLocIpDoc.addAttribute("SUBSCRIBER",subId)
+        subidLocIpDoc.addAttribute("IP",ip)
+        subidLocIpDoc.addAttribute("FIRST_FOUND_TIME",firstFoundTime)
+        subidLocIpDoc.addAttribute("LAST_FOUND_TIME",lastFoundTime)
+      }
+    }
+    subidLocIpDoc
+  }
+
+  private def getVertexSubidRow(joinRow: (String, (Option[BaseDocument], Option[Row]))): BaseDocument ={
+    val subidDocOpt = joinRow._2._1
+    var subidDoc = subidDocOpt match {
+      case Some(doc) => doc
+      case None => null
+    }
+
+    val subidRowOpt = joinRow._2._2
+
+    val subidRow = subidRowOpt match {
+      case Some(r) => r
+      case None => null
+    }
+
+    if (subidRow != null){
+      val subId = subidRow.getAs[String]("common_subscriber_id")
+      val subLastFoundTime = subidRow.getAs[Long]("LAST_FOUND_TIME")
+      val subFirstFoundTime = subidRow.getAs[Long]("FIRST_FOUND_TIME")
+      if (subidDoc != null){
+        updateMaxAttribute(subidDoc,subLastFoundTime,"LAST_FOUND_TIME")
+      } else {
+        subidDoc = new BaseDocument()
+        subidDoc.setKey(subId)
+        subidDoc.addAttribute("SUBSCRIBER",subId)
+        subidDoc.addAttribute("FIRST_FOUND_TIME",subFirstFoundTime)
+        subidDoc.addAttribute("LAST_FOUND_TIME",subLastFoundTime)
+      }
+    }
+
+    subidDoc
+  }
+
+  private def getVertexFqdnRow(joinRow: (String, (Option[BaseDocument], Option[Row]))): BaseDocument = {
+    val fqdnDocOpt = joinRow._2._1
+    var fqdnDoc = fqdnDocOpt match {
+      case Some(doc) => doc
+      case None => null
+    }
+
+    val fqdnRowOpt = joinRow._2._2
+
+    val fqdnRow = fqdnRowOpt match {
+      case Some(r) => r
+      case None => null
+    }
+
+    if (fqdnRow != null){
+      val fqdn = fqdnRow.getAs[String]("FQDN")
+      val lastFoundTime = fqdnRow.getAs[Long]("LAST_FOUND_TIME")
+      val firstFoundTime = fqdnRow.getAs[Long]("FIRST_FOUND_TIME")
+      if (fqdnDoc != null) {
+        updateMaxAttribute(fqdnDoc, lastFoundTime, "LAST_FOUND_TIME")
+      } else {
+        fqdnDoc = new BaseDocument
+        fqdnDoc.setKey(fqdn)
+        fqdnDoc.addAttribute("FQDN_NAME", fqdn)
+        fqdnDoc.addAttribute("FIRST_FOUND_TIME", firstFoundTime)
+        fqdnDoc.addAttribute("LAST_FOUND_TIME", lastFoundTime)
+      }
+    }
+
+    fqdnDoc
+  }
+
+  private def getVertexIpRow(joinRow: (String, (Option[BaseDocument], Option[Row]))): BaseDocument = {
+    val ipDocOpt = joinRow._2._1
+    var ipDoc = ipDocOpt match {
+      case Some(doc) => doc
+      case None => null
+    }
+
+    val ipRowOpt = joinRow._2._2
+
+    val ipRow = ipRowOpt match {
+      case Some(r) => r
+      case None => null
+    }
+
+    if (ipRow != null){
+      val ip = ipRow.getAs[String]("IP")
+      val firstFoundTime = ipRow.getAs[Long]("FIRST_FOUND_TIME")
+      val lastFoundTime = ipRow.getAs[Long]("LAST_FOUND_TIME")
+      val sessionCountList = ipRow.getAs[ofRef[AnyRef]]("SESSION_COUNT_LIST")
+      val bytesSumList = ipRow.getAs[ofRef[AnyRef]]("BYTES_SUM_LIST")
+      val ipTypeList = ipRow.getAs[ofRef[String]]("ip_type_list")
+      val linkInfo = ipRow.getAs[String]("common_link_info")
+      val sepAttributeTuple = separateAttributeByIpType(ipTypeList, sessionCountList, bytesSumList)
+
+      if (ipDoc != null) {
+        updateMaxAttribute(ipDoc, lastFoundTime, "LAST_FOUND_TIME")
+        updateSumAttribute(ipDoc, sepAttributeTuple._1, "SERVER_SESSION_COUNT")
+        updateSumAttribute(ipDoc, sepAttributeTuple._2, "SERVER_BYTES_SUM")
+        updateSumAttribute(ipDoc, sepAttributeTuple._3, "CLIENT_SESSION_COUNT")
+        updateSumAttribute(ipDoc, sepAttributeTuple._4, "CLIENT_BYTES_SUM")
+        replaceAttribute(ipDoc,linkInfo,"COMMON_LINK_INFO")
+      } else {
+        ipDoc = new BaseDocument
+        ipDoc.setKey(ip)
+        ipDoc.addAttribute("IP", ip)
+        ipDoc.addAttribute("FIRST_FOUND_TIME", firstFoundTime)
+        ipDoc.addAttribute("LAST_FOUND_TIME", lastFoundTime)
+        ipDoc.addAttribute("SERVER_SESSION_COUNT", sepAttributeTuple._1)
+        ipDoc.addAttribute("SERVER_BYTES_SUM", sepAttributeTuple._2)
+        ipDoc.addAttribute("CLIENT_SESSION_COUNT", sepAttributeTuple._3)
+        ipDoc.addAttribute("CLIENT_BYTES_SUM", sepAttributeTuple._4)
+        ipDoc.addAttribute("COMMON_LINK_INFO", "")
+      }
+    }
+
+    ipDoc
+  }
+
+  private def getRelationFqdnLocateIpRow(joinRow: (String, (Option[BaseEdgeDocument], Option[Row]))): BaseEdgeDocument = {
+
+    val fqdnLocIpDocOpt = joinRow._2._1
+    var fqdnLocIpDoc = fqdnLocIpDocOpt match {
+      case Some(doc) => doc
+      case None => null
+    }
+
+    val fqdnLocIpRowOpt = joinRow._2._2
+
+    val fqdnLocIpRow = fqdnLocIpRowOpt match {
+      case Some(r) => r
+      case None => null
+    }
+
+    if (fqdnLocIpDoc != null){
+      updateProtocolDocument(fqdnLocIpDoc)
+    }
+
+    if (fqdnLocIpRow != null){
+      val fqdn = fqdnLocIpRow.getAs[String]("FQDN")
+      val serverIp = fqdnLocIpRow.getAs[String]("common_server_ip")
+      val firstFoundTime = fqdnLocIpRow.getAs[Long]("FIRST_FOUND_TIME")
+      val lastFoundTime = fqdnLocIpRow.getAs[Long]("LAST_FOUND_TIME")
+      val countTotalList = fqdnLocIpRow.getAs[ofRef[AnyRef]]("COUNT_TOTAL_LIST")
+      val schemaTypeList = fqdnLocIpRow.getAs[ofRef[AnyRef]]("schema_type_list")
+      val distCipRecent = fqdnLocIpRow.getAs[ofRef[String]]("DIST_CIP_RECENT")
+
+      val sepAttritubeMap: Map[String, Long] = separateAttributeByProtocol(schemaTypeList, countTotalList)
+      val distinctIp: Array[String] = mergeDistinctIp(distCipRecent)
+
+      val key = fqdn.concat("-" + serverIp)
+
+      if (fqdnLocIpDoc != null) {
+        updateMaxAttribute(fqdnLocIpDoc, lastFoundTime, "LAST_FOUND_TIME")
+        updateProtocolAttritube(fqdnLocIpDoc, sepAttritubeMap)
+        updateDistinctIp(fqdnLocIpDoc, distinctIp)
+      } else {
+        fqdnLocIpDoc = new BaseEdgeDocument()
+        fqdnLocIpDoc.setKey(key)
+        fqdnLocIpDoc.setFrom("FQDN/" + fqdn)
+        fqdnLocIpDoc.setTo("IP/" + serverIp)
+        fqdnLocIpDoc.addAttribute("FIRST_FOUND_TIME", firstFoundTime)
+        fqdnLocIpDoc.addAttribute("LAST_FOUND_TIME", lastFoundTime)
+        putProtocolAttritube(fqdnLocIpDoc, sepAttritubeMap)
+        putDistinctIp(fqdnLocIpDoc, distinctIp)
+      }
+    }
+
+    fqdnLocIpDoc
+  }
+
 }

ip-learning-spark/src/main/scala/cn/ac/iie/spark/ArangoSpark.scala

@@ -0,0 +1,136 @@
+/*
+ * DISCLAIMER
+ *
+ * Copyright 2016 ArangoDB GmbH, Cologne, Germany
+ *
+ * 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.
+ *
+ * Copyright holder is ArangoDB GmbH, Cologne, Germany
+ *
+ * author Mark - mark at arangodb.com
+ */
+
+package cn.ac.iie.spark
+
+import cn.ac.iie.spark.rdd.{ArangoRdd, ReadOptions, WriteOptions}
+import cn.ac.iie.spark.vpack.VPackUtils
+import com.arangodb.model.DocumentCreateOptions
+import org.apache.spark.SparkContext
+import org.apache.spark.rdd.RDD
+import org.apache.spark.sql.{DataFrame, Dataset, Row}
+
+import scala.collection.JavaConverters.seqAsJavaListConverter
+import scala.reflect.ClassTag
+
+object ArangoSpark {
+
+  /**
+   * Save data from rdd into ArangoDB
+   *
+   * @param rdd the rdd with the data to save
+   * @param collection the collection to save in
+   */
+  def save[T](rdd: RDD[T], collection: String): Unit =
+    save(rdd, collection, WriteOptions())
+
+  /**
+   * Save data from rdd into ArangoDB
+   *
+   * @param rdd the rdd with the data to save
+   * @param collection the collection to save in
+   * @param options additional write options
+   */
+  def save[T](rdd: RDD[T], collection: String, options: WriteOptions): Unit =
+    saveRDD(rdd, collection, options, (x: Iterator[T]) => x)
+
+  /**
+   * Save data from dataset into ArangoDB
+   *
+   * @param dataset the dataset with data to save
+   * @param collection the collection to save in
+   */
+  def save[T](dataset: Dataset[T], collection: String): Unit =
+    saveRDD(dataset.rdd, collection, WriteOptions(), (x: Iterator[T]) => x)
+
+  /**
+   * Save data from dataset into ArangoDB
+   *
+   * @param dataset the dataset with data to save
+   * @param collection the collection to save in
+   * @param options additional write options
+   */
+  def save[T](dataset: Dataset[T], collection: String, options: WriteOptions): Unit =
+    saveRDD(dataset.rdd, collection, options, (x: Iterator[T]) => x)
+
+  /**
+   * Save data from dataframe into ArangoDB
+   *
+   * @param dataframe the dataframe with data to save
+   * @param collection the collection to save in
+   */
+  def saveDF(dataframe: DataFrame, collection: String): Unit =
+    saveRDD[Row](dataframe.rdd, collection, WriteOptions(), (x: Iterator[Row]) => x.map { y => VPackUtils.rowToVPack(y) })
+
+  /**
+   * Save data from dataframe into ArangoDB
+   *
+   * @param dataframe the dataframe with data to save
+   * @param collection the collection to save in
+   * @param options additional write options
+   */
+  def saveDF(dataframe: DataFrame, collection: String, options: WriteOptions): Unit =
+    saveRDD[Row](dataframe.rdd, collection, options, (x: Iterator[Row]) => x.map { y => VPackUtils.rowToVPack(y) })
+
+  private def saveRDD[T](rdd: RDD[T], collection: String, options: WriteOptions, map: Iterator[T] => Iterator[Any]): Unit = {
+    val writeOptions = createWriteOptions(options, rdd.sparkContext.getConf)
+    rdd.foreachPartition { p =>
+      if (p.nonEmpty) {
+        val arangoDB = createArangoBuilder(writeOptions).build()
+        val col = arangoDB.db(writeOptions.database).collection(collection)
+        val docs = map(p).toList.asJava
+        writeOptions.method match {
+          case WriteOptions.INSERT  => col.insertDocuments(docs)
+          case WriteOptions.UPDATE  => col.updateDocuments(docs)
+          case WriteOptions.REPLACE => col.replaceDocuments(docs)
+          case WriteOptions.OVERWRITE =>
+            val documentCreateOptions = new DocumentCreateOptions
+            documentCreateOptions.overwrite(true)
+            documentCreateOptions.silent(true)
+            col.insertDocuments(docs, documentCreateOptions)
+        }
+
+        arangoDB.shutdown()
+      }
+    }
+  }
+
+  /**
+   * Load data from ArangoDB into rdd
+   *
+   * @param sparkContext the sparkContext containing the ArangoDB configuration
+   * @param collection the collection to load data from
+   */
+  def load[T: ClassTag](sparkContext: SparkContext, collection: String): ArangoRdd[T] =
+    load(sparkContext, collection, ReadOptions())
+
+  /**
+   * Load data from ArangoDB into rdd
+   *
+   * @param sparkContext the sparkContext containing the ArangoDB configuration
+   * @param collection the collection to load data from
+   * @param options read options
+   */
+  def load[T: ClassTag](sparkContext: SparkContext, collection: String, options: ReadOptions): ArangoRdd[T] =
+    new ArangoRdd[T](sparkContext, createReadOptions(options, sparkContext.getConf).copy(collection = collection))
+
+}

ip-learning-spark/src/main/scala/cn/ac/iie/spark/partition/QueryArangoPartition.scala

@@ -0,0 +1,7 @@
+package cn.ac.iie.spark.partition
+
+import org.apache.spark.Partition
+
+class QueryArangoPartition(idx: Int, val offset: Long, val separate: Long) extends Partition{
+  override def index: Int = idx
+}

ip-learning-spark/src/main/scala/cn/ac/iie/spark/rdd/ArangoOptions.scala

@@ -0,0 +1,34 @@
+package cn.ac.iie.spark.rdd
+
+import com.arangodb.Protocol
+import com.arangodb.entity.LoadBalancingStrategy
+
+trait ArangoOptions {
+
+  def database: String = "_system"
+
+  def hosts: Option[String] = None
+
+  def user: Option[String] = None
+
+  def password: Option[String] = None
+
+  def useSsl: Option[Boolean] = None
+
+  def sslKeyStoreFile: Option[String] = None
+
+  def sslPassPhrase: Option[String] = None
+
+  def sslProtocol: Option[String] = None
+
+  def protocol: Option[Protocol] = None
+  
+  def maxConnections: Option[Int] = None
+  
+  def acquireHostList: Option[Boolean] = None
+  
+  def acquireHostListInterval: Option[Int] = None
+  
+  def loadBalancingStrategy: Option[LoadBalancingStrategy] = None
+  
+}

ip-learning-spark/src/main/scala/cn/ac/iie/spark/rdd/ArangoRdd.scala

@@ -0,0 +1,81 @@
+package cn.ac.iie.spark.rdd
+
+import scala.collection.JavaConverters.asScalaIteratorConverter
+import cn.ac.iie.config.ApplicationConfig
+import cn.ac.iie.service.update.UpdateDocument
+import cn.ac.iie.spark
+import cn.ac.iie.spark.partition.QueryArangoPartition
+import com.arangodb.ArangoCursor
+import org.apache.spark.{Partition, SparkContext, TaskContext}
+import org.apache.spark.rdd.RDD
+import org.slf4j.LoggerFactory
+
+import scala.collection.mutable.ArrayBuffer
+import scala.reflect.ClassTag
+
+class ArangoRdd[T: ClassTag](@transient override val sparkContext: SparkContext,
+                             val options: ReadOptions
+                            ) extends RDD[T](sparkContext, Nil) {
+
+  private val LOG = LoggerFactory.getLogger(UpdateDocument.getClass)
+
+  override def compute(split: Partition, context: TaskContext): Iterator[T] = {
+
+    createCursor(split.asInstanceOf[QueryArangoPartition]).asScala
+  }
+
+  override protected def getPartitions: Array[Partition] = {
+    val partitions = ArrayBuffer[Partition]()
+    val total = getCountTotal
+    for (i <- 0 until ApplicationConfig.SPARK_SQL_SHUFFLE_PARTITIONS) {
+      val partition = getPartition(i, total)
+      partitions += partition
+    }
+    partitions.toArray
+  }
+
+  private def createCursor(split: QueryArangoPartition)(implicit clazz: ClassTag[T]): ArangoCursor[T] = {
+
+    var arangoCursor:ArangoCursor[T] = null
+    val arangoDB = spark.createArangoBuilder(options).build()
+    try {
+      val offset = split.offset
+      val separate = split.separate
+      val collection = options.collection
+      val sql = s"FOR doc IN $collection limit $offset,$separate RETURN doc"
+      LOG.info(sql)
+      arangoCursor = arangoDB.db(options.database).query(sql,clazz.runtimeClass.asInstanceOf[Class[T]])
+    }catch {
+      case e: Exception => LOG.error(s"创建Cursor异常:${e.getMessage}")
+    }finally {
+      arangoDB.shutdown()
+    }
+    arangoCursor
+  }
+
+  override def repartition(numPartitions: Int)(implicit ord: Ordering[T]): RDD[T] = super.repartition(numPartitions)
+
+  private def getPartition(idx: Int, countTotal: Long): QueryArangoPartition = {
+    val sepNum = countTotal / ApplicationConfig.SPARK_SQL_SHUFFLE_PARTITIONS + 1
+    val offsetNum = idx * sepNum
+    new QueryArangoPartition(idx, offsetNum, sepNum)
+  }
+
+  override def count(): Long = getCountTotal
+
+  private def getCountTotal: Long = {
+    val arangoDB = spark.createArangoBuilder(options).build()
+    var cnt = 0L
+    val sql = s"RETURN LENGTH(${options.collection})"
+    LOG.info(sql)
+    try {
+      val longs = arangoDB.db(options.database).query(sql, classOf[Long])
+      while (longs.hasNext) cnt = longs.next
+    } catch {
+      case e: Exception => LOG.error(sql + s"执行异常:${e.getMessage}")
+    }finally {
+      arangoDB.shutdown()
+    }
+    cnt
+  }
+}

ip-learning-spark/src/main/scala/cn/ac/iie/spark/rdd/ReadOptions.scala

@@ -0,0 +1,93 @@
+/*
+ * DISCLAIMER
+ *
+ * Copyright 2016 ArangoDB GmbH, Cologne, Germany
+ *
+ * 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.
+ *
+ * Copyright holder is ArangoDB GmbH, Cologne, Germany
+ *
+ * author Mark - mark at arangodb.com
+ */
+
+package cn.ac.iie.spark.rdd
+
+import cn.ac.iie.spark.partition.QueryArangoPartition
+import com.arangodb.Protocol
+import com.arangodb.entity.LoadBalancingStrategy
+
+case class ReadOptions(override val database: String = "_system",
+                       val collection: String = null,
+                       partitioner: QueryArangoPartition = new QueryArangoPartition(0,0,0),
+                       override val hosts: Option[String] = None,
+                       override val user: Option[String] = None,
+                       override val password: Option[String] = None,
+                       override val useSsl: Option[Boolean] = None,
+                       override val sslKeyStoreFile: Option[String] = None,
+                       override val sslPassPhrase: Option[String] = None,
+                       override val sslProtocol: Option[String] = None,
+                       override val protocol: Option[Protocol] = None,
+                       override val maxConnections: Option[Int] = None,
+                       override val acquireHostList: Option[Boolean] = None,
+                       override val acquireHostListInterval: Option[Int] = None,
+                       override val loadBalancingStrategy: Option[LoadBalancingStrategy] = None) extends ArangoOptions {
+
+  def this() = this(database = "_system")
+
+  def database(database: String): ReadOptions = copy(database = database)
+
+  def collection(collection: String): ReadOptions = copy(collection = collection)
+
+  def hosts(hosts: String): ReadOptions = copy(hosts = Some(hosts))
+
+  def user(user: String): ReadOptions = copy(user = Some(user))
+
+  def password(password: String): ReadOptions = copy(password = Some(password))
+
+  def useSsl(useSsl: Boolean): ReadOptions = copy(useSsl = Some(useSsl))
+
+  def sslKeyStoreFile(sslKeyStoreFile: String): ReadOptions = copy(sslKeyStoreFile = Some(sslKeyStoreFile))
+
+  def sslPassPhrase(sslPassPhrase: String): ReadOptions = copy(sslPassPhrase = Some(sslPassPhrase))
+
+  def sslProtocol(sslProtocol: String): ReadOptions = copy(sslProtocol = Some(sslProtocol))
+
+  def protocol(protocol: Protocol): ReadOptions = copy(protocol = Some(protocol))
+  
+  def maxConnections(maxConnections: Int): ReadOptions = copy(maxConnections = Some(maxConnections))
+  
+  def acquireHostList(acquireHostList: Boolean): ReadOptions = copy(acquireHostList = Some(acquireHostList))
+  
+  def acquireHostListInterval(acquireHostListInterval: Int): ReadOptions = copy(acquireHostListInterval = Some(acquireHostListInterval))
+  
+  def loadBalancingStrategy(loadBalancingStrategy: LoadBalancingStrategy): ReadOptions = copy(loadBalancingStrategy = Some(loadBalancingStrategy))
+
+  def copy(database: String = database,
+           collection: String = collection,
+           partitioner: QueryArangoPartition = partitioner,
+           hosts: Option[String] = hosts,
+           user: Option[String] = user,
+           password: Option[String] = password,
+           useSsl: Option[Boolean] = useSsl,
+           sslKeyStoreFile: Option[String] = sslKeyStoreFile,
+           sslPassPhrase: Option[String] = sslPassPhrase,
+           sslProtocol: Option[String] = sslProtocol,
+           protocol: Option[Protocol] = protocol,
+           maxConnections: Option[Int] = maxConnections,
+           acquireHostList: Option[Boolean] = acquireHostList,
+           acquireHostListInterval: Option[Int] = acquireHostListInterval,
+           loadBalancingStrategy: Option[LoadBalancingStrategy] = loadBalancingStrategy): ReadOptions = {
+    ReadOptions(database, collection, partitioner, hosts, user, password, useSsl, sslKeyStoreFile, sslPassPhrase, sslProtocol, protocol, maxConnections, acquireHostList, acquireHostListInterval, loadBalancingStrategy)
+  }
+
+}

ip-learning-spark/src/main/scala/cn/ac/iie/spark/rdd/WriteOptions.scala

@@ -0,0 +1,124 @@
+/*
+ * DISCLAIMER
+ *
+ * Copyright 2016 ArangoDB GmbH, Cologne, Germany
+ *
+ * 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.
+ *
+ * Copyright holder is ArangoDB GmbH, Cologne, Germany
+ *
+ * author Mark - mark at arangodb.com
+ */
+
+package cn.ac.iie.spark.rdd
+
+import javax.net.ssl.SSLContext
+import com.arangodb.Protocol
+import com.arangodb.entity.LoadBalancingStrategy
+
+case class WriteOptions(override val database: String = "_system",
+                        val method: WriteOptions.Method = WriteOptions.INSERT,
+                        override val hosts: Option[String] = None,
+                        override val user: Option[String] = None,
+                        override val password: Option[String] = None,
+                        override val useSsl: Option[Boolean] = None,
+                        override val sslKeyStoreFile: Option[String] = None,
+                        override val sslPassPhrase: Option[String] = None,
+                        override val sslProtocol: Option[String] = None,
+                        override val protocol: Option[Protocol] = None,
+                        override val maxConnections: Option[Int] = None,
+                        override val acquireHostList: Option[Boolean] = None,
+                        override val acquireHostListInterval: Option[Int] = None,
+                        override val loadBalancingStrategy: Option[LoadBalancingStrategy] = None) extends ArangoOptions {
+  import WriteOptions._
+
+  def this() = this(database = "_system")
+
+  def database(database: String): WriteOptions = copy(database = database)
+
+  def method(method: Method): WriteOptions = copy(method = method)
+
+  def hosts(hosts: String): WriteOptions = copy(hosts = Some(hosts))
+
+  def user(user: String): WriteOptions = copy(user = Some(user))
+
+  def password(password: String): WriteOptions = copy(password = Some(password))
+
+  def useSsl(useSsl: Boolean): WriteOptions = copy(useSsl = Some(useSsl))
+
+  def sslKeyStoreFile(sslKeyStoreFile: String): WriteOptions = copy(sslKeyStoreFile = Some(sslKeyStoreFile))
+
+  def sslPassPhrase(sslPassPhrase: String): WriteOptions = copy(sslPassPhrase = Some(sslPassPhrase))
+
+  def sslProtocol(sslProtocol: String): WriteOptions = copy(sslProtocol = Some(sslProtocol))
+
+  def protocol(protocol: Protocol): WriteOptions = copy(protocol = Some(protocol))
+
+  def maxConnections(maxConnections: Int): WriteOptions = copy(maxConnections = Some(maxConnections))
+
+  def acquireHostList(acquireHostList: Boolean): WriteOptions = copy(acquireHostList = Some(acquireHostList))
+
+  def acquireHostListInterval(acquireHostListInterval: Int): WriteOptions = copy(acquireHostListInterval = Some(acquireHostListInterval))
+
+  def loadBalancingStrategy(loadBalancingStrategy: LoadBalancingStrategy): WriteOptions = copy(loadBalancingStrategy = Some(loadBalancingStrategy))
+
+  def copy(database: String = database,
+           method: Method = method,
+           hosts: Option[String] = hosts,
+           user: Option[String] = user,
+           password: Option[String] = password,
+           useSsl: Option[Boolean] = useSsl,
+           sslKeyStoreFile: Option[String] = sslKeyStoreFile,
+           sslPassPhrase: Option[String] = sslPassPhrase,
+           sslProtocol: Option[String] = sslProtocol,
+           protocol: Option[Protocol] = protocol,
+           maxConnections: Option[Int] = maxConnections,
+           acquireHostList: Option[Boolean] = acquireHostList,
+           acquireHostListInterval: Option[Int] = acquireHostListInterval,
+           loadBalancingStrategy: Option[LoadBalancingStrategy] = loadBalancingStrategy): WriteOptions = {
+    WriteOptions(database, method, hosts, user, password, useSsl, sslKeyStoreFile, sslPassPhrase, sslProtocol, protocol, maxConnections, acquireHostList, acquireHostListInterval, loadBalancingStrategy)
+  }
+
+}
+
+object WriteOptions {
+
+  /**
+    * method to save documents to arangodb
+    */
+  sealed trait Method
+
+  /**
+    * save documents by inserting
+    * @see [[com.arangodb.ArangoCollection#insertDocuments(java.util.Collection)]]
+    */
+  case object INSERT extends Method
+
+  /**
+    * save documents by updating
+    * @see [[com.arangodb.ArangoCollection#updateDocuments(java.util.Collection)]]
+    */
+  case object UPDATE extends Method
+
+  /**
+    * save documents by replacing
+    * @see [[com.arangodb.ArangoCollection#replaceDocuments(java.util.Collection)]]
+    */
+  case object REPLACE extends Method
+
+  /**
+    * save documents by overwrite
+    */
+  case object OVERWRITE extends Method
+
+}

ip-learning-spark/src/main/scala/cn/ac/iie/spark/spark.scala

@@ -0,0 +1,139 @@
+/*
+ * DISCLAIMER
+ *
+ * Copyright 2016 ArangoDB GmbH, Cologne, Germany
+ *
+ * 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.
+ *
+ * Copyright holder is ArangoDB GmbH, Cologne, Germany
+ *
+ * author Mark - mark at arangodb.com
+ */
+
+package cn.ac.iie
+
+import java.io.FileInputStream
+import java.security.KeyStore
+
+import cn.ac.iie.spark.rdd.{ArangoOptions, ReadOptions, WriteOptions}
+import com.arangodb.{ArangoDB, ArangoDBException, Protocol}
+import com.arangodb.entity.LoadBalancingStrategy
+import com.arangodb.velocypack.module.jdk8.VPackJdk8Module
+import com.arangodb.velocypack.module.scala.VPackScalaModule
+import javax.net.ssl.{KeyManagerFactory, SSLContext, TrustManagerFactory}
+import org.apache.spark.SparkConf
+
+import scala.util.Try
+
+package object spark {
+
+  val PropertyHosts = "arangodb.hosts"
+  val PropertyUser = "arangodb.user"
+  val PropertyPassword = "arangodb.password"
+  val PropertyUseSsl = "arangodb.useSsl"
+  val PropertySslKeyStoreFile = "arangodb.ssl.keyStoreFile"
+  val PropertySslPassPhrase = "arangodb.ssl.passPhrase"
+  val PropertySslProtocol = "arangodb.ssl.protocol"
+  val PropertyProtocol = "arangodb.protocol"
+  val PropertyMaxConnections = "arangodb.maxConnections"
+  val PropertyAcquireHostList = "arangodb.acquireHostList"
+  val PropertyAcquireHostListInterval = "arangodb.acquireHostListInterval"
+  val PropertyLoadBalancingStrategy = "arangodb.loadBalancingStrategy"
+
+  private[spark] def createReadOptions(options: ReadOptions, sc: SparkConf): ReadOptions = {
+    options.copy(
+      hosts = options.hosts.orElse(some(sc.get(PropertyHosts, null))),
+      user = options.user.orElse(some(sc.get(PropertyUser, null))),
+      password = options.password.orElse(some(sc.get(PropertyPassword, null))),
+      useSsl = options.useSsl.orElse(some(Try(sc.get(PropertyUseSsl, null).toBoolean).getOrElse(false))),
+      sslKeyStoreFile = options.sslKeyStoreFile.orElse(some(sc.get(PropertySslKeyStoreFile, null))),
+      sslPassPhrase = options.sslPassPhrase.orElse(some(sc.get(PropertySslPassPhrase, null))),
+      sslProtocol = options.sslProtocol.orElse(some(sc.get(PropertySslProtocol, null))),
+      protocol = options.protocol.orElse(some(Protocol.valueOf(sc.get(PropertyProtocol, "VST")))),
+      maxConnections = options.maxConnections.orElse(some(Try(sc.get(PropertyMaxConnections, null).toInt).getOrElse(1))),
+      acquireHostList = options.acquireHostList.orElse(some(Try(sc.get(PropertyAcquireHostList, null).toBoolean).getOrElse(false))),
+      acquireHostListInterval = options.acquireHostListInterval.orElse(some(Try(sc.get(PropertyAcquireHostListInterval, null).toInt).getOrElse(60000))),
+      loadBalancingStrategy = options.loadBalancingStrategy.orElse(some(LoadBalancingStrategy.valueOf(sc.get(PropertyLoadBalancingStrategy, "NONE")))))
+  }
+
+  private[spark] def createWriteOptions(options: WriteOptions, sc: SparkConf): WriteOptions = {
+    options.copy(
+      hosts = options.hosts.orElse(some(sc.get(PropertyHosts, null))),
+      user = options.user.orElse(some(sc.get(PropertyUser, null))),
+      password = options.password.orElse(some(sc.get(PropertyPassword, null))),
+      useSsl = options.useSsl.orElse(some(Try(sc.get(PropertyUseSsl, null).toBoolean).getOrElse(false))),
+      sslKeyStoreFile = options.sslKeyStoreFile.orElse(some(sc.get(PropertySslKeyStoreFile, null))),
+      sslPassPhrase = options.sslPassPhrase.orElse(some(sc.get(PropertySslPassPhrase, null))),
+      sslProtocol = options.sslProtocol.orElse(some(sc.get(PropertySslProtocol, null))),
+      protocol = options.protocol.orElse(some(Protocol.valueOf(sc.get(PropertyProtocol, "VST")))),
+      maxConnections = options.maxConnections.orElse(some(Try(sc.get(PropertyMaxConnections, null).toInt).getOrElse(1))),
+      acquireHostList = options.acquireHostList.orElse(some(Try(sc.get(PropertyAcquireHostList, null).toBoolean).getOrElse(false))),
+      acquireHostListInterval = options.acquireHostListInterval.orElse(some(Try(sc.get(PropertyAcquireHostListInterval, null).toInt).getOrElse(60000))),
+      loadBalancingStrategy = options.loadBalancingStrategy.orElse(some(LoadBalancingStrategy.valueOf(sc.get(PropertyLoadBalancingStrategy, "NONE")))))
+  }
+
+  private[spark] def createArangoBuilder(options: ArangoOptions): ArangoDB.Builder = {
+    val builder = new ArangoDB.Builder()
+    builder.registerModules(new VPackJdk8Module, new VPackScalaModule)
+    options.hosts.foreach { hosts(_).foreach(host => builder.host(host._1, host._2)) }
+    options.user.foreach { builder.user(_) }
+    options.password.foreach { builder.password(_) }
+    options.useSsl.foreach { builder.useSsl(_) }
+    if (options.sslKeyStoreFile.isDefined && options.sslPassPhrase.isDefined) {
+      builder.sslContext(createSslContext(options.sslKeyStoreFile.get, options.sslPassPhrase.get, options.sslProtocol.getOrElse("TLS")))
+    }
+    options.protocol.foreach { builder.useProtocol(_) }
+    options.maxConnections.foreach { builder.maxConnections(_) }
+    options.acquireHostList.foreach { builder.acquireHostList(_) }
+    options.acquireHostListInterval.foreach { builder.acquireHostListInterval(_) }
+    options.loadBalancingStrategy.foreach { builder.loadBalancingStrategy(_) }
+    builder
+  }
+
+  private def createSslContext(keyStoreFile: String, passPhrase: String, protocol: String): SSLContext = {
+    val ks = KeyStore.getInstance(KeyStore.getDefaultType());
+    val kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
+    ks.load(new FileInputStream(keyStoreFile), passPhrase.toCharArray());
+    kmf.init(ks, passPhrase.toCharArray());
+    val tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+    tmf.init(ks);
+    val sc = SSLContext.getInstance(protocol);
+    sc.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
+    sc
+  }
+
+  private def some(value: String): Option[String] =
+    if (value != null) Some(value) else None
+
+  private def some(value: Int): Option[Int] =
+    Some(value)
+    
+  private def some(value: Boolean): Option[Boolean] =
+    Some(value)
+
+  private def some(value: Protocol): Option[Protocol] =
+    Some(value)
+    
+  private def some(value: LoadBalancingStrategy): Option[LoadBalancingStrategy] =
+    Some(value)
+
+  private def hosts(hosts: String): List[(String, Int)] =
+    hosts.split(",").map({ x =>
+      val s = x.split(":")
+      if (s.length != 2 || !s(1).matches("[0-9]+"))
+        throw new ArangoDBException(s"Could not load property-value arangodb.hosts=${s}. Expected format ip:port,ip:port,...");
+      else
+        (s(0), s(1).toInt)
+    }).toList
+
+}

ip-learning-spark/src/main/scala/cn/ac/iie/spark/vpack/VPackUtils.scala

@@ -0,0 +1,160 @@
+/*
+ * DISCLAIMER
+ *
+ * Copyright 2016 ArangoDB GmbH, Cologne, Germany
+ *
+ * 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.
+ *
+ * Copyright holder is ArangoDB GmbH, Cologne, Germany
+ *
+ * author Mark - mark at arangodb.com
+ */
+
+package cn.ac.iie.spark.vpack
+
+import org.apache.spark.sql.Row
+import org.apache.spark.sql.types.{
+  ArrayType,
+  BooleanType,
+  DataType,
+  DateType,
+  DecimalType,
+  DoubleType,
+  FloatType,
+  IntegerType,
+  LongType,
+  MapType,
+  NullType,
+  ShortType,
+  StringType,
+  StructField,
+  StructType,
+  TimestampType
+}
+import com.arangodb.velocypack.VPackBuilder
+import com.arangodb.velocypack.VPackSlice
+import com.arangodb.velocypack.ValueType
+
+private[spark] object VPackUtils {
+
+  def rowToVPack(row: Row): VPackSlice = {
+    val builder = new VPackBuilder()
+    if (row == null) {
+      builder.add(ValueType.NULL)
+    } else {
+      builder.add(ValueType.OBJECT)
+      row.schema.fields.zipWithIndex.foreach { addField(_, row, builder) }
+      builder.close()
+    }
+    builder.slice()
+  }
+
+  private def addField(field: (StructField, Int), row: Row, builder: VPackBuilder): Unit = {
+    val name = field._1.name
+    val index = field._2
+    if (row.isNullAt(index)) {
+      builder.add(name, ValueType.NULL)
+    } else {
+      field._1.dataType match {
+        case BooleanType    => builder.add(name, java.lang.Boolean.valueOf(row.getBoolean(index)))
+        case DoubleType     => builder.add(name, java.lang.Double.valueOf(row.getDouble(index)))
+        case FloatType      => builder.add(name, java.lang.Float.valueOf(row.getFloat(index)))
+        case LongType       => builder.add(name, java.lang.Long.valueOf(row.getLong(index)))
+        case IntegerType    => builder.add(name, java.lang.Integer.valueOf(row.getInt(index)))
+        case ShortType      => builder.add(name, java.lang.Short.valueOf(row.getShort(index)))
+        case StringType     => builder.add(name, java.lang.String.valueOf(row.getString(index)));
+        case DateType       => builder.add(name, row.getDate(index))
+        case TimestampType  => builder.add(name, row.getTimestamp(index))
+        case t: DecimalType => builder.add(name, row.getDecimal(index))
+        case t: MapType => {
+          builder.add(name, ValueType.OBJECT)
+          row.getMap[String, Any](index).foreach { case (name, value) => addValue(name, value, builder) }
+          builder.close()
+        }
+        case t: ArrayType => {
+          builder.add(name, ValueType.ARRAY)
+          addValues(row, index, builder, t.elementType)
+          builder.close()
+        }
+        case NullType           => builder.add(name, ValueType.NULL)
+        case struct: StructType => builder.add(name, rowToVPack(row.getStruct(index)))
+        case _                  => // TODO
+      }
+    }
+  }
+
+  private def addValues(row: Row, index: Int, builder: VPackBuilder, itemType: DataType): Unit = {
+    itemType match {
+      case BooleanType =>
+        row.getSeq[Boolean](index).foreach { value =>
+          addValue(null, value, builder)
+        }
+      case DoubleType =>
+        row.getSeq[Double](index).foreach { value =>
+          addValue(null, value, builder)
+        }
+      case FloatType =>
+        row.getSeq[Float](index).foreach { value =>
+          addValue(null, value, builder)
+        }
+      case LongType =>
+        row.getSeq[Long](index).foreach { value =>
+          addValue(null, value, builder)
+        }
+      case IntegerType =>
+        row.getSeq[Int](index).foreach { value =>
+          addValue(null, value, builder)
+        }
+      case ShortType =>
+        row.getSeq[Short](index).foreach { value =>
+          addValue(null, value, builder)
+        }
+      case StringType =>
+        row.getSeq[String](index).foreach { value =>
+          addValue(null, value, builder)
+        }
+      case DateType =>
+        row.getSeq[java.sql.Date](index).foreach { value =>
+          addValue(null, value, builder)
+        }
+      case TimestampType =>
+        row.getSeq[java.sql.Timestamp](index).foreach { value =>
+          addValue(null, value, builder)
+        }
+      case s: StructType => {
+        row.getSeq[Row](index).foreach { value =>
+          builder.add(null, rowToVPack(value))
+        }
+      }
+      case t: MapType   => // TODO
+      case t: ArrayType => // TODO
+      case _            => // TODO
+    }
+  }
+
+  private def addValue(name: String, value: Any, builder: VPackBuilder): Unit = {
+    value match {
+      case value: Boolean            => builder.add(name, java.lang.Boolean.valueOf(value))
+      case value: Double             => builder.add(name, java.lang.Double.valueOf(value))
+      case value: Float              => builder.add(name, java.lang.Float.valueOf(value))
+      case value: Long               => builder.add(name, java.lang.Long.valueOf(value))
+      case value: Int                => builder.add(name, java.lang.Integer.valueOf(value))
+      case value: Short              => builder.add(name, java.lang.Short.valueOf(value))
+      case value: String             => builder.add(name, java.lang.String.valueOf(value))
+      case value: java.sql.Date      => builder.add(name, value)
+      case value: java.sql.Timestamp => builder.add(name, value)
+      case _                         => // TODO
+    }
+  }
+
+}

ip-learning-spark/src/main/scala/cn/ac/iie/utils/SparkSessionUtil.scala

@@ -1,7 +1,9 @@
 package cn.ac.iie.utils
 
 import cn.ac.iie.config.ApplicationConfig
+import org.apache.spark.SparkContext
 import org.apache.spark.sql.SparkSession
+import org.apache.spark.util.LongAccumulator
 import org.slf4j.LoggerFactory
 
 object SparkSessionUtil {
@@ -9,6 +11,8 @@ object SparkSessionUtil {
 
   val spark: SparkSession = getSparkSession
 
+  var sparkContext: SparkContext = getContext
+
   private def getSparkSession: SparkSession ={
     val spark: SparkSession = SparkSession
       .builder()
@@ -17,16 +21,36 @@ object SparkSessionUtil {
       .config("spark.network.timeout", ApplicationConfig.SPARK_NETWORK_TIMEOUT)
       .config("spark.sql.shuffle.partitions", ApplicationConfig.SPARK_SQL_SHUFFLE_PARTITIONS)
       .config("spark.executor.memory", ApplicationConfig.SPARK_EXECUTOR_MEMORY)
+      .config("arangodb.hosts", s"${ApplicationConfig.ARANGODB_HOST}:${ApplicationConfig.ARANGODB_PORT}")
+      .config("arangodb.user", ApplicationConfig.ARANGODB_USER)
+      .config("arangodb.password", ApplicationConfig.ARANGODB_PASSWORD)
       .master(ApplicationConfig.MASTER)
       .getOrCreate()
     LOG.warn("sparkession获取成功！！！")
     spark
   }
 
+  def getContext: SparkContext = {
+    @transient var sc: SparkContext = null
+      if (sparkContext == null) sc = spark.sparkContext
+    sc
+  }
+
+  def getLongAccumulator(name: String): LongAccumulator ={
+    if (sparkContext == null){
+      sparkContext = getContext
+    }
+    sparkContext.longAccumulator(name)
+
+  }
+
   def closeSpark(): Unit ={
     if (spark != null){
       spark.stop()
     }
+    if (sparkContext != null){
+      sparkContext.stop()
+    }
   }
 
 }

ip-learning-spark/src/test/scala/cn/ac/iie/dao/BaseClickhouseDataTest.scala

@@ -7,7 +7,7 @@ import org.apache.spark.sql.SparkSession
 object BaseClickhouseDataTest {
   private val spark: SparkSession = SparkSessionUtil.spark
   def main(args: Array[String]): Unit = {
-    BaseClickhouseData loadConnectionDataFromCk()
+//    BaseClickhouseData loadConnectionDataFromCk()
     val sql =
       """
         |SELECT

ip-learning-spark/src/test/scala/cn/ac/iie/spark/RDDTest.scala

@@ -0,0 +1,75 @@
+package cn.ac.iie.spark
+
+import cn.ac.iie.config.ApplicationConfig
+import cn.ac.iie.dao.BaseClickhouseData
+import cn.ac.iie.spark.partition.CustomPartitioner
+import cn.ac.iie.spark.rdd.{ArangoRdd, ReadOptions}
+import cn.ac.iie.utils.SparkSessionUtil
+import com.arangodb.entity.BaseDocument
+import org.apache.spark.rdd.RDD
+import org.apache.spark.sql.Row
+import org.apache.spark.sql.functions.{collect_list, max, min}
+import org.apache.spark.storage.StorageLevel
+
+object RDDTest {
+  def main(args: Array[String]): Unit = {
+
+    val sparkContext = SparkSessionUtil.spark.sparkContext
+
+    println(sparkContext.getConf.get("arangodb.hosts"))
+
+    //    val options = ReadOptions("iplearn_media_domain").copy(collection = "R_LOCATE_FQDN2IP")
+    val options = ReadOptions(ApplicationConfig.ARANGODB_DB_NAME)
+
+    val ipOptions = options.copy(collection = "IP")
+
+    val rdd: ArangoRdd[BaseDocument] = ArangoSpark.load[BaseDocument](sparkContext,"IP",options)
+
+    println(rdd.count())
+    println(rdd.getNumPartitions)
+
+    val ipRDD = mergeVertexIp()
+    val value: RDD[(String, (Option[BaseDocument], Option[Row]))] = rdd.map(doc => {
+      (doc.getKey, doc)
+    }).fullOuterJoin(ipRDD)
+    value.foreach((row: (String, (Option[BaseDocument], Option[Row]))) => {
+      val value = row._2._2
+      val str: String = value match {
+        case Some(r) => r.getAs[String]("IP")
+//        case None => null
+        case _ => null
+      }
+      println(str)
+    })
+
+    /*
+    val value: RDD[BaseDocument] = rdd.filter(doc => doc.getAttribute("CLIENT_SESSION_COUNT").asInstanceOf[Long] > 100).map(doc => {
+      doc.addAttribute("abc", 1)
+      doc
+    })
+    value.map(doc => {(doc.getKey,doc)})
+    value.persist(StorageLevel.MEMORY_AND_DISK)
+    value.foreach(fqdnRow => println(fqdnRow.toString))
+    println(value.count())
+    */
+
+    SparkSessionUtil.spark.close()
+    System.exit(0)
+
+  }
+
+  def mergeVertexIp(): RDD[(String,Row)]={
+    val vertexIpDf = BaseClickhouseData.getVertexIpDf
+    val frame = vertexIpDf.groupBy("IP").agg(
+      min("FIRST_FOUND_TIME").alias("FIRST_FOUND_TIME"),
+      max("LAST_FOUND_TIME").alias("LAST_FOUND_TIME"),
+      collect_list("SESSION_COUNT").alias("SESSION_COUNT_LIST"),
+      collect_list("BYTES_SUM").alias("BYTES_SUM_LIST"),
+      collect_list("ip_type").alias("ip_type_list")
+    )
+    val values = frame.rdd.map(row => (row.getAs[String]("IP"), row))
+      .partitionBy(new CustomPartitioner(ApplicationConfig.SPARK_SQL_SHUFFLE_PARTITIONS))
+    values
+  }
+
+}