VoIP Knowledge Base sip-voip-completion Initial commit 202004291431HEADmaster

1 files changed, 585 insertions, 0 deletions

diff --git a/src/main/java/cn/ac/iie/utils/getjson/GetStrToClickHouseUtils.java b/src/main/java/cn/ac/iie/utils/getjson/GetStrToClickHouseUtils.java
new file mode 100644
index 0000000..3ac5d1e
--- /dev/null
+++ b/src/main/java/cn/ac/iie/utils/getjson/GetStrToClickHouseUtils.java
@@ -0,0 +1,585 @@
+//package cn.ac.iie.utils.getjson;
+//
+//import cn.ac.iie.bean.dk.DK_BEHAVIOR_LOG;
+//import cn.ac.iie.bean.mm.MM_AV_IP_LOG;
+//import cn.ac.iie.bean.mm.MM_VOIP_IP_LOG;
+//import cn.ac.iie.bean.ntc.NTC_CONN_RECORD_LOG;
+//import cn.ac.iie.bean.ntcwidely.NTC_COLLECT_SSL_LOG;
+//import cn.ac.iie.bean.pxy.PXY_HTTP_LOG;
+//import cn.ac.iie.common.FlowWriteConfig;
+//import cn.ac.iie.common.RealtimeCountConfig;
+//import cn.ac.iie.utils.ordinary.DecodeUtils;
+//import com.alibaba.fastjson.JSONObject;
+//import com.alibaba.fastjson.parser.Feature;
+//import com.zdjizhi.utils.IpLookup;
+//import com.zdjizhi.utils.StringUtil;
+//import org.apache.log4j.Logger;
+//
+///**
+// * @author antlee
+// * @date 2018/7/19
+// */
+//public class GetStrToClickHouseUtils {
+//    private static Logger logger = Logger.getLogger(GetStrToClickHouseUtils.class);
+//    private static IpLookup ipLookup = new IpLookup.Builder(false)
+//            .loadDataFileV4(RealtimeCountConfig.IP_LIBRARY)
+//            .loadDataFileV6(RealtimeCountConfig.IP_LIBRARY)
+//            .build();
+//
+//    /**
+//     * NTC topic对准类
+//     *
+//     * @param message 日志
+//     * @param topic   topic名称
+//     * @return 补全日志
+//     */
+//    public static String getData(String message, String topic) {
+//        switch (topic) {
+//            case "NTC-CONN-RECORD-LOG":
+//                return ntcConnLog(message);
+//            case "NTC-COLLECT-MAIL-LOG":
+//                return mailLog(message);
+//            case "NTC-COLLECT-SSL-LOG":
+//                return sslLog(message);
+//            case "NTC-SSL-LOG":
+//                return sslLog(message);
+//            case "NTC-APP-LOG":
+//                return appLog(message);
+//            case "NTC-HTTP-LOG":
+//                return httpLog(message);
+//            case "NTC-IP-LOG":
+//                return ipLog(message);
+//            case "PXY-HTTP-LOG":
+//                return pHttpLog(message);
+//            case "NTC-DNS-LOG":
+//                return dnsLog(message);
+//            case "NTC-BGP-LOG":
+//                return bgpLog(message);
+//            case "NTC-DDOS-LOG":
+//                return ddosLog(message);
+//            case "NTC-FTP-LOG":
+//                return ftpLog(message);
+//            case "NTC-MAIL-LOG":
+//                return mailLog(message);
+//            case "NTC-OPENVPN-LOG":
+//                return openVpnLog(message);
+//            case "NTC-P2P-LOG":
+//                return p2pLog(message);
+//            case "NTC-STREAMING-MEDIA-LOG":
+//                return streamMediaLog(message);
+//            case "NTC-VOIP-LOG":
+//                return voipLog(message);
+//            case "NTC-KEYWORDS-URL-LOG":
+//                return message;
+//            case "MM-SAMPLE-AUDIO-LOG":
+//                return avIpLog(message);
+//            case "MM-SAMPLE-VIDEO-LOG":
+//                return avIpLog(message);
+//            case "MM-PORN-AUDIO-LEVEL-LOG":
+//                return avIpLog(message);
+//            case "MM-PORN-VIDEO-LEVEL-LOG":
+//                return avIpLog(message);
+//            case "MM-SAMPLE-PIC-LOG":
+//                return avIpLog(message);
+//            case "MM-SAMPLE-VOIP-LOG":
+//                return voipIpLog(message);
+//            case "MM-FILE-DIGEST-LOG":
+//                return avIpLog(message);
+//            case "NTC-COLLECT-VOIP-LOG":
+//                return collectVoipLog(message);
+//
+////            case "MM-AV-IP-LOG":
+////                return avIpLog(message);
+////            case "MM-AV-URL-LOG":
+////                return avIpLog(message);
+////            case "MM-PIC-IP-LOG":
+////                return avIpLog(message);
+////            case "MM-PIC-URL-LOG":
+////                return avIpLog(message);
+////            case "MM-VOIP-IP-LOG":
+////                return voipIpLog(message);
+////            case "MM-SPEAKER-RECOGNIZATION-LOG":
+////                return avIpLog(message);
+////            case "MM-LOGO-DETECTION-LOG":
+////                return avIpLog(message);
+////            case "MM-FACE-RECOGNIZATION-LOG":
+////                return avIpLog(message);
+////            case "MM-VOIP-ACCOUNT-LOG":
+////                return voipIpLog(message);
+////            case "NTC-IPSEC-LOG":
+////                return ipsecLog(message);
+////            case "NTC-L2TP-LOG":
+////                return l2tpLog(message);
+////            case "NTC-PPTP-LOG":
+////                return pptpLog(message);
+////            case "NTC-SSH-LOG":
+////                return sshLog(message);
+//
+//            default:
+//                logger.error("There is no corresponding topic! topic name is :" + topic);
+//                break;
+//        }
+//        return null;
+//    }
+//
+//
+//    private static String ntcConnLog(String message) {
+//        try {
+//            NTC_CONN_RECORD_LOG ntcConnRecordLog = JSONObject.parseObject(message, NTC_CONN_RECORD_LOG.class);
+//            String appLabel = ntcConnRecordLog.getApp_label();
+//            String sIp = ntcConnRecordLog.getS_ip();
+//            String dIp = ntcConnRecordLog.getD_ip();
+//            ntcConnRecordLog.setServer_locate(ipLookup.countryLookup(dIp));
+//            ntcConnRecordLog.setClient_locate(ipLookup.cityLookupDetail(sIp));
+//            ntcConnRecordLog.setD_asn(ipLookup.asnLookup(dIp, true));
+//            ntcConnRecordLog.setS_asn(ipLookup.asnLookup(sIp, true));
+//            if (StringUtil.isNotBlank(appLabel)) {
+//                String[] split = ntcConnRecordLog.getApp_label().split(";");
+//                ntcConnRecordLog.setProto_id(Integer.parseInt(split[0].split("=")[1]));
+//                ntcConnRecordLog.setApp_id(Integer.parseInt(split[1].split("=")[1]));
+//                ntcConnRecordLog.setOs_id(Integer.parseInt(split[2].split("=")[1]));
+//                ntcConnRecordLog.setBs_id(Integer.parseInt(split[3].split("=")[1]));
+//                ntcConnRecordLog.setWeb_id(Integer.parseInt(split[4].split("=")[1]));
+//                ntcConnRecordLog.setBehav_id(Integer.parseInt(split[5].split("=")[1]));
+//            } else {
+//                ntcConnRecordLog.setProto_id(0);
+//                ntcConnRecordLog.setApp_id(0);
+//                ntcConnRecordLog.setOs_id(0);
+//                ntcConnRecordLog.setBs_id(0);
+//                ntcConnRecordLog.setWeb_id(0);
+//                ntcConnRecordLog.setBehav_id(0);
+//            }
+//            return JSONObject.toJSONString(ntcConnRecordLog);
+//        } catch (Exception e) {
+//            logger.error("Log parsing error!!! \n" + message);
+//            e.printStackTrace();
+//            return "";
+//        }
+//    }
+//
+//
+//    private static String avIpLog(String message) {
+//        try {
+//            MM_AV_IP_LOG mmAvIpLog = JSONObject.parseObject(message, MM_AV_IP_LOG.class);
+//            String sIp = mmAvIpLog.getS_ip();
+//            String dIp = mmAvIpLog.getD_ip();
+//            mmAvIpLog.setServer_locate(ipLookup.countryLookup(dIp));
+//            mmAvIpLog.setClient_locate(ipLookup.cityLookupDetail(sIp));
+//            mmAvIpLog.setD_asn(ipLookup.asnLookup(dIp, true));
+//            mmAvIpLog.setS_asn(ipLookup.asnLookup(sIp, true));
+////            mmAvIpLog.setS_subscribe_id(TransFormUtils.getSubscribe(mmAvIpLog.getS_ip()));
+////            mmAvIpLog.setD_subscribe_id(TransFormUtils.getSubscribe(mmAvIpLog.getD_ip()));
+//            return JSONObject.toJSONString(mmAvIpLog);
+//        } catch (Exception e) {
+//            logger.error("Log parsing error!!! \n" + message);
+//            e.printStackTrace();
+//            return "";
+//        }
+//    }
+//
+//    private static String voipIpLog(String message) {
+//        try {
+//            MM_VOIP_IP_LOG mmVoipIpLog = JSONObject.parseObject(message, MM_VOIP_IP_LOG.class);
+//            String sIp = mmVoipIpLog.getS_ip();
+//            String dIp = mmVoipIpLog.getD_ip();
+//            mmVoipIpLog.setServer_locate(ipLookup.countryLookup(dIp));
+//            mmVoipIpLog.setClient_locate(ipLookup.cityLookupDetail(sIp));
+//            mmVoipIpLog.setD_asn(ipLookup.asnLookup(dIp, true));
+//            mmVoipIpLog.setS_asn(ipLookup.asnLookup(sIp, true));
+////            mmVoipIpLog.setS_subscribe_id(TransFormUtils.getSubscribe(mmVoipIpLog.getS_ip()));
+////            mmVoipIpLog.setD_subscribe_id(TransFormUtils.getSubscribe(mmVoipIpLog.getD_ip()));
+//            return JSONObject.toJSONString(mmVoipIpLog);
+//        } catch (Exception e) {
+//            logger.error("Log parsing error!!! \n" + message);
+//            e.printStackTrace();
+//            return "";
+//        }
+//    }
+//
+//    private static String collectVoipLog(String message) {
+//        try {
+//            NTC_COLLECT_VOIP_LOG ntcCollectVoipLog = JSONObject.parseObject(message, NTC_COLLECT_VOIP_LOG.class);
+//            return JSONObject.toJSONString(ntcCollectVoipLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//
+//    private static String appLog(String message) {
+//        try {
+//            NTC_APP_LOG ntcAppLog = JSONObject.parseObject(message, NTC_APP_LOG.class);
+//            String sIp = ntcAppLog.getS_ip();
+//            String dIp = ntcAppLog.getD_ip();
+//            ntcAppLog.setServer_locate(ipLookup.countryLookup(dIp));
+//            ntcAppLog.setClient_locate(ipLookup.cityLookupDetail(sIp));
+//            ntcAppLog.setD_asn(ipLookup.asnLookup(dIp, true));
+//            ntcAppLog.setS_asn(ipLookup.asnLookup(sIp, true));
+////            ntcAppLog.setS_subscribe_id(TransFormUtils.getSubscribe(ntcAppLog.getS_ip()));
+////            ntcAppLog.setD_subscribe_id(TransFormUtils.getSubscribe(ntcAppLog.getD_ip()));
+//            return JSONObject.toJSONString(ntcAppLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//    private static String bgpLog(String message) {
+//        try {
+//            NTC_BGP_LOG ntcBgpLog = JSONObject.parseObject(message, NTC_BGP_LOG.class);
+//            String sIp = ntcBgpLog.getS_ip();
+//            String dIp = ntcBgpLog.getD_ip();
+//            ntcBgpLog.setServer_locate(ipLookup.countryLookup(dIp));
+//            ntcBgpLog.setClient_locate(ipLookup.cityLookupDetail(sIp));
+//            ntcBgpLog.setD_asn(ipLookup.asnLookup(dIp, true));
+//            ntcBgpLog.setS_asn(ipLookup.asnLookup(sIp, true));
+////            ntcBgpLog.setS_subscribe_id(TransFormUtils.getSubscribe(ntcBgpLog.getS_ip()));
+////            ntcBgpLog.setD_subscribe_id(TransFormUtils.getSubscribe(ntcBgpLog.getD_ip()));
+//            return JSONObject.toJSONString(ntcBgpLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//    private static String ddosLog(String message) {
+//        try {
+//            NTC_DDOS_LOG ntcDdosLog = JSONObject.parseObject(message, NTC_DDOS_LOG.class);
+//            String sIp = ntcDdosLog.getS_ip();
+//            String dIp = ntcDdosLog.getD_ip();
+//            ntcDdosLog.setServer_locate(ipLookup.countryLookup(dIp));
+//            ntcDdosLog.setClient_locate(ipLookup.cityLookupDetail(sIp));
+//            ntcDdosLog.setD_asn(ipLookup.asnLookup(dIp, true));
+//            ntcDdosLog.setS_asn(ipLookup.asnLookup(sIp, true));
+////            ntcDdosLog.setS_subscribe_id(TransFormUtils.getSubscribe(ntcDdosLog.getS_ip()));
+////            ntcDdosLog.setD_subscribe_id(TransFormUtils.getSubscribe(ntcDdosLog.getD_ip()));
+//            return JSONObject.toJSONString(ntcDdosLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//    private static String dnsLog(String message) {
+//        try {
+//            NTC_DNS_LOG ntcDnsLog = JSONObject.parseObject(message, NTC_DNS_LOG.class);
+//            String sIp = ntcDnsLog.getS_ip();
+//            String dIp = ntcDnsLog.getD_ip();
+//            ntcDnsLog.setServer_locate(ipLookup.countryLookup(dIp));
+//            ntcDnsLog.setClient_locate(ipLookup.cityLookupDetail(sIp));
+//            ntcDnsLog.setD_asn(ipLookup.asnLookup(dIp, true));
+//            ntcDnsLog.setS_asn(ipLookup.asnLookup(sIp, true));
+////            ntcDnsLog.setS_subscribe_id(TransFormUtils.getSubscribe(ntcDnsLog.getS_ip()));
+////            ntcDnsLog.setD_subscribe_id(TransFormUtils.getSubscribe(ntcDnsLog.getD_ip()));
+//            return JSONObject.toJSONString(ntcDnsLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//    private static String ftpLog(String message) {
+//        try {
+//            NTC_FTP_LOG ntcFtpLog = JSONObject.parseObject(message, NTC_FTP_LOG.class);
+//            String sIp = ntcFtpLog.getS_ip();
+//            String dIp = ntcFtpLog.getD_ip();
+//            ntcFtpLog.setServer_locate(ipLookup.countryLookup(dIp));
+//            ntcFtpLog.setClient_locate(ipLookup.cityLookupDetail(sIp));
+//            ntcFtpLog.setD_asn(ipLookup.asnLookup(dIp, true));
+//            ntcFtpLog.setS_asn(ipLookup.asnLookup(sIp, true));
+////            ntcFtpLog.setS_subscribe_id(TransFormUtils.getSubscribe(ntcFtpLog.getS_ip()));
+////            ntcFtpLog.setD_subscribe_id(TransFormUtils.getSubscribe(ntcFtpLog.getD_ip()));
+//            return JSONObject.toJSONString(ntcFtpLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//    private static String httpLog(String message) {
+//        try {
+//            NTC_HTTP_LOG ntcHttpLog = JSONObject.parseObject(message, NTC_HTTP_LOG.class);
+////            if (StringUtil.isBlank(ntcHttpLog.getUrl())) {
+////                TransFormUtils.getUniFlow(ntcHttpLog);
+////            }
+//            String sIp = ntcHttpLog.getS_ip();
+//            String dIp = ntcHttpLog.getD_ip();
+//            ntcHttpLog.setServer_locate(ipLookup.countryLookup(dIp));
+//            ntcHttpLog.setClient_locate(ipLookup.cityLookupDetail(sIp));
+//            ntcHttpLog.setD_asn(ipLookup.asnLookup(dIp, true));
+//            ntcHttpLog.setS_asn(ipLookup.asnLookup(sIp, true));
+////            ntcHttpLog.setS_subscribe_id(TransFormUtils.getSubscribe(ntcHttpLog.getS_ip()));
+////            ntcHttpLog.setD_subscribe_id(TransFormUtils.getSubscribe(ntcHttpLog.getD_ip()));
+//            ntcHttpLog.setWebsite(StringUtil.getDomain(ntcHttpLog.getUrl()));
+//            return JSONObject.toJSONString(ntcHttpLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//    private static String ipLog(String message) {
+//        try {
+//            NTC_IP_LOG ntcIpLog = JSONObject.parseObject(message, NTC_IP_LOG.class);
+//            String sIp = ntcIpLog.getS_ip();
+//            String dIp = ntcIpLog.getD_ip();
+//            ntcIpLog.setServer_locate(ipLookup.countryLookup(dIp));
+//            ntcIpLog.setClient_locate(ipLookup.cityLookupDetail(sIp));
+//            ntcIpLog.setD_asn(ipLookup.asnLookup(dIp, true));
+//            ntcIpLog.setS_asn(ipLookup.asnLookup(sIp, true));
+////            ntcIpLog.setS_subscribe_id(TransFormUtils.getSubscribe(ntcIpLog.getS_ip()));
+////            ntcIpLog.setD_subscribe_id(TransFormUtils.getSubscribe(ntcIpLog.getD_ip()));
+//            return JSONObject.toJSONString(ntcIpLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//
+//    private static String mailLog(String message) {
+//        try {
+//            NTC_MAIL_LOG ntcMailLog = JSONObject.parseObject(message, NTC_MAIL_LOG.class);
+//            String sIp = ntcMailLog.getS_ip();
+//            String dIp = ntcMailLog.getD_ip();
+//            ntcMailLog.setServer_locate(ipLookup.countryLookup(dIp));
+//            ntcMailLog.setClient_locate(ipLookup.cityLookupDetail(sIp));
+//            ntcMailLog.setD_asn(ipLookup.asnLookup(dIp, true));
+//            ntcMailLog.setS_asn(ipLookup.asnLookup(sIp, true));
+////            ntcMailLog.setS_subscribe_id(TransFormUtils.getSubscribe(ntcMailLog.getS_ip()));
+////            ntcMailLog.setD_subscribe_id(TransFormUtils.getSubscribe(ntcMailLog.getD_ip()));
+//            if (StringUtil.isNotBlank(ntcMailLog.getSubject())) {
+//                String subjectCharset = JSONObject.parseObject(message).getString("subject_charset");
+//                ntcMailLog.setSubject(DecodeUtils.base64Str(ntcMailLog.getSubject(), subjectCharset));
+//            }
+//            return JSONObject.toJSONString(ntcMailLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//    private static String openVpnLog(String message) {
+//        try {
+//            NTC_OPENVPN_LOG ntcOpenvpnLog = JSONObject.parseObject(message, NTC_OPENVPN_LOG.class);
+//            String sIp = ntcOpenvpnLog.getS_ip();
+//            String dIp = ntcOpenvpnLog.getD_ip();
+//            ntcOpenvpnLog.setServer_locate(ipLookup.countryLookup(dIp));
+//            ntcOpenvpnLog.setClient_locate(ipLookup.cityLookupDetail(sIp));
+//            ntcOpenvpnLog.setD_asn(ipLookup.asnLookup(dIp, true));
+//            ntcOpenvpnLog.setS_asn(ipLookup.asnLookup(sIp, true));
+////            ntcOpenvpnLog.setS_subscribe_id(TransFormUtils.getSubscribe(ntcOpenvpnLog.getS_ip()));
+////            ntcOpenvpnLog.setD_subscribe_id(TransFormUtils.getSubscribe(ntcOpenvpnLog.getD_ip()));
+//            return JSONObject.toJSONString(ntcOpenvpnLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//    private static String p2pLog(String message) {
+//        try {
+//            NTC_P2P_LOG ntcP2PLog = JSONObject.parseObject(message, NTC_P2P_LOG.class);
+//            String sIp = ntcP2PLog.getS_ip();
+//            String dIp = ntcP2PLog.getD_ip();
+//            ntcP2PLog.setServer_locate(ipLookup.countryLookup(dIp));
+//            ntcP2PLog.setClient_locate(ipLookup.cityLookupDetail(sIp));
+//            ntcP2PLog.setD_asn(ipLookup.asnLookup(dIp, true));
+//            ntcP2PLog.setS_asn(ipLookup.asnLookup(sIp, true));
+////            ntcP2PLog.setS_subscribe_id(TransFormUtils.getSubscribe(ntcP2PLog.getS_ip()));
+////            ntcP2PLog.setD_subscribe_id(TransFormUtils.getSubscribe(ntcP2PLog.getD_ip()));
+//            return JSONObject.toJSONString(ntcP2PLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//
+//    private static String streamMediaLog(String message) {
+//        try {
+//            NTC_STREAMING_MEDIA_LOG ntcStreamingMediaLog = JSONObject.parseObject(message, NTC_STREAMING_MEDIA_LOG.class);
+//            String sIp = ntcStreamingMediaLog.getS_ip();
+//            String dIp = ntcStreamingMediaLog.getD_ip();
+//            ntcStreamingMediaLog.setServer_locate(ipLookup.countryLookup(dIp));
+//            ntcStreamingMediaLog.setClient_locate(ipLookup.cityLookupDetail(sIp));
+//            ntcStreamingMediaLog.setD_asn(ipLookup.asnLookup(dIp, true));
+//            ntcStreamingMediaLog.setS_asn(ipLookup.asnLookup(sIp, true));
+////            ntcStreamingMediaLog.setS_subscribe_id(TransFormUtils.getSubscribe(ntcStreamingMediaLog.getS_ip()));
+////            ntcStreamingMediaLog.setD_subscribe_id(TransFormUtils.getSubscribe(ntcStreamingMediaLog.getD_ip()));
+//            return JSONObject.toJSONString(ntcStreamingMediaLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//    private static String voipLog(String message) {
+//        try {
+//            NTC_VOIP_LOG ntcVoipLog = JSONObject.parseObject(message, NTC_VOIP_LOG.class);
+//            String sIp = ntcVoipLog.getS_ip();
+//            String dIp = ntcVoipLog.getD_ip();
+//            ntcVoipLog.setServer_locate(ipLookup.countryLookup(dIp));
+//            ntcVoipLog.setClient_locate(ipLookup.cityLookupDetail(sIp));
+//            ntcVoipLog.setD_asn(ipLookup.asnLookup(dIp, true));
+//            ntcVoipLog.setS_asn(ipLookup.asnLookup(sIp, true));
+////            ntcVoipLog.setS_subscribe_id(TransFormUtils.getSubscribe(ntcVoipLog.getS_ip()));
+////            ntcVoipLog.setD_subscribe_id(TransFormUtils.getSubscribe(ntcVoipLog.getD_ip()));
+//            return JSONObject.toJSONString(ntcVoipLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//
+//    private static String sslLog(String message) {
+//        try {
+//            NTC_COLLECT_SSL_LOG ntcSslLog = JSONObject.parseObject(message, NTC_COLLECT_SSL_LOG.class);
+//            String sIp = ntcSslLog.getS_ip();
+//            String dIp = ntcSslLog.getD_ip();
+//            ntcSslLog.setServer_locate(ipLookup.countryLookup(dIp));
+//            ntcSslLog.setClient_locate(ipLookup.cityLookupDetail(sIp));
+//            ntcSslLog.setD_asn(ipLookup.asnLookup(dIp, true));
+//            ntcSslLog.setS_asn(ipLookup.asnLookup(sIp, true));
+////            ntcSslLog.setS_subscribe_id(TransFormUtils.getSubscribe(ntcSslLog.getS_ip()));
+////            ntcSslLog.setD_subscribe_id(TransFormUtils.getSubscribe(ntcSslLog.getD_ip()));
+//            return JSONObject.toJSONString(ntcSslLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//    private static String pHttpLog(String message) {
+//        try {
+//            PXY_HTTP_LOG pxyHttpLog = JSONObject.parseObject(message, PXY_HTTP_LOG.class);
+//            String sIp = pxyHttpLog.getS_ip();
+//            String dIp = pxyHttpLog.getD_ip();
+//            pxyHttpLog.setServer_locate(ipLookup.countryLookup(dIp));
+//            pxyHttpLog.setClient_locate(ipLookup.cityLookupDetail(sIp));
+//            pxyHttpLog.setD_asn(ipLookup.asnLookup(dIp, true));
+//            pxyHttpLog.setS_asn(ipLookup.asnLookup(sIp, true));
+//            pxyHttpLog.setWebsite(StringUtil.getDomain(pxyHttpLog.getUrl()));
+//            return JSONObject.toJSONString(pxyHttpLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//
+//    /**
+//     * ---------------------------------删除的topic------------------------------------------------------------
+//     **/
+//
+//
+//    private static String behaviorLog(String message) {
+//        try {
+//            DK_BEHAVIOR_LOG dkBehaviorLog = JSONObject.parseObject(message, DK_BEHAVIOR_LOG.class, Feature.OrderedField);
+//            dkBehaviorLog.setServer_locate(ipLookup.countryLookup(dkBehaviorLog.getD_ip()));
+//            dkBehaviorLog.setClient_locate(ipLookup.cityLookupDetail(dkBehaviorLog.getS_ip()));
+//            dkBehaviorLog.setD_asn(ipLookup.asnLookup(dkBehaviorLog.getD_ip()).trim());
+//            dkBehaviorLog.setS_asn(ipLookup.asnLookup(dkBehaviorLog.getS_ip()).trim());
+////            dkBehaviorLog.setS_subscribe_id(TransFormUtils.getSubscribe(dkBehaviorLog.getS_ip()));
+////            dkBehaviorLog.setD_subscribe_id(TransFormUtils.getSubscribe(dkBehaviorLog.getD_ip()));
+//            return JSONObject.toJSONString(dkBehaviorLog);
+//        } catch (Exception e) {
+//            logger.error("Log parsing error!!! \n" + message);
+//            e.printStackTrace();
+//            return "";
+//        }
+//    }
+//
+//    private static String sshLog(String message) {
+//        try {
+//            NTC_SSH_LOG ntcSshLog = JSONObject.parseObject(message, NTC_SSH_LOG.class, Feature.OrderedField);
+//            ntcSshLog.setServer_locate(ipLookup.countryLookup(ntcSshLog.getD_ip()));
+//            ntcSshLog.setClient_locate(ipLookup.cityLookupDetail(ntcSshLog.getS_ip()));
+//            ntcSshLog.setD_asn(ipLookup.asnLookup(ntcSshLog.getD_ip()).trim());
+//            ntcSshLog.setS_asn(ipLookup.asnLookup(ntcSshLog.getS_ip()).trim());
+//            try {
+//                ntcSshLog.setVersion(ntcSshLog.getVersion().replaceAll("\n", "\\\\n"));
+//                ntcSshLog.setVersion(ntcSshLog.getVersion().replaceAll("\r", "\\\\r"));
+//            } catch (Exception e) {
+//                ntcSshLog.setVersion("");
+//            }
+////            ntcSshLog.setS_subscribe_id(TransFormUtils.getSubscribe(ntcSshLog.getS_ip()));
+////            ntcSshLog.setD_subscribe_id(TransFormUtils.getSubscribe(ntcSshLog.getD_ip()));
+//            return JSONObject.toJSONString(ntcSshLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//    private static String pptpLog(String message) {
+//        try {
+//            NTC_PPTP_LOG ntcPptpLog = JSONObject.parseObject(message, NTC_PPTP_LOG.class, Feature.OrderedField);
+//            ntcPptpLog.setServer_locate(ipLookup.countryLookup(ntcPptpLog.getD_ip()));
+//            ntcPptpLog.setClient_locate(ipLookup.cityLookupDetail(ntcPptpLog.getS_ip()));
+//            ntcPptpLog.setD_asn(ipLookup.asnLookup(ntcPptpLog.getD_ip()).trim());
+//            ntcPptpLog.setS_asn(ipLookup.asnLookup(ntcPptpLog.getS_ip()).trim());
+////            ntcPptpLog.setS_subscribe_id(TransFormUtils.getSubscribe(ntcPptpLog.getS_ip()));
+////            ntcPptpLog.setD_subscribe_id(TransFormUtils.getSubscribe(ntcPptpLog.getD_ip()));
+//            return JSONObject.toJSONString(ntcPptpLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//    private static String l2tpLog(String message) {
+//        try {
+//            NTC_L2TP_LOG ntcL2TPLog = JSONObject.parseObject(message, NTC_L2TP_LOG.class, Feature.OrderedField);
+//            ntcL2TPLog.setServer_locate(ipLookup.countryLookup(ntcL2TPLog.getD_ip()));
+//            ntcL2TPLog.setClient_locate(ipLookup.cityLookupDetail(ntcL2TPLog.getS_ip()));
+//            ntcL2TPLog.setD_asn(ipLookup.asnLookup(ntcL2TPLog.getD_ip()).trim());
+//            ntcL2TPLog.setS_asn(ipLookup.asnLookup(ntcL2TPLog.getS_ip()).trim());
+////            ntcL2TPLog.setS_subscribe_id(TransFormUtils.getSubscribe(ntcL2TPLog.getS_ip()));
+////            ntcL2TPLog.setD_subscribe_id(TransFormUtils.getSubscribe(ntcL2TPLog.getD_ip()));
+//            return JSONObject.toJSONString(ntcL2TPLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//    private static String ipsecLog(String message) {
+//        try {
+//            NTC_IPSEC_LOG ntcIpsecLog = JSONObject.parseObject(message, NTC_IPSEC_LOG.class, Feature.OrderedField);
+//            ntcIpsecLog.setServer_locate(ipLookup.countryLookup(ntcIpsecLog.getD_ip()));
+//            ntcIpsecLog.setClient_locate(ipLookup.cityLookupDetail(ntcIpsecLog.getS_ip()));
+//            ntcIpsecLog.setD_asn(ipLookup.asnLookup(ntcIpsecLog.getD_ip()).trim());
+//            ntcIpsecLog.setS_asn(ipLookup.asnLookup(ntcIpsecLog.getS_ip()).trim());
+////            ntcIpsecLog.setS_subscribe_id(TransFormUtils.getSubscribe(ntcIpsecLog.getS_ip()));
+////            ntcIpsecLog.setD_subscribe_id(TransFormUtils.getSubscribe(ntcIpsecLog.getD_ip()));
+//            return JSONObject.toJSONString(ntcIpsecLog);
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            logger.error("Log parsing error!!! \n" + message);
+//            return "";
+//        }
+//    }
+//
+//
+//}