Java tutorial
package com.oneapm.base; import base.Analysis; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; import com.google.common.collect.ImmutableMap; import com.oneapm.base.alertbean.AlertLevel; import com.oneapm.base.alertbean.Rule; import com.oneapm.base.alertbean.RuleRecover; import com.oneapm.base.basebean.*; import com.oneapm.base.convert.LinkConvertImpl; import com.oneapm.base.convert.NetConvertImpl; import com.oneapm.base.convert.SiteConvertImpl; import com.oneapm.base.convert.SubnetConvertImpl; import com.oneapm.base.tools.*; import com.oneapm.base.watcher.ZookeeperConfigWatcher; import org.apache.commons.lang3.StringUtils; import org.apache.spark.api.java.JavaPairRDD; import org.apache.spark.api.java.JavaRDD; import org.apache.spark.api.java.function.Function; import org.apache.spark.api.java.function.Function2; import org.apache.spark.api.java.function.PairFunction; import org.apache.spark.broadcast.Broadcast; import org.apache.spark.streaming.Durations; import org.apache.spark.streaming.api.java.JavaPairDStream; import org.apache.spark.streaming.api.java.JavaPairReceiverInputDStream; import org.elasticsearch.hadoop.cfg.ConfigurationOptions; import org.elasticsearch.spark.rdd.api.java.JavaEsSpark; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import scala.Tuple2; import java.io.IOException; import java.io.Serializable; import java.lang.reflect.Field; import java.net.InetAddress; import java.net.Socket; import java.net.UnknownHostException; import java.text.DecimalFormat; import java.text.SimpleDateFormat; import java.util.*; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ThreadFactory; import java.util.concurrent.TimeUnit; /** * 60s aggregation and alert * Created by tianjin on 3/23/16. */ @SuppressWarnings("all") public class SparkAggregation extends Analysis { public static final Logger LOG = LoggerFactory.getLogger(SparkAggregation.class); private final static ZookeeperClient zookeeperClient = ZookeeperClient.getInstance(); private final static EsGet esGet = EsGet.getInstance(); private static final SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm", Locale.CHINA); private static final SimpleDateFormat esFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.CHINA); private static final DecimalFormat df = new DecimalFormat("###.000"); static SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd", Locale.CHINA); private static List<RuleRecover> rules; public static void main(String[] args) throws IOException { String configfile = "alert.cnf"; final FlowConstant flowConstant = new FlowConstant(); Properties config = null; try { config = getConfig(configfile); } catch (IOException e) { LOG.error(configfile + " doesnt exist in /etc/analysis/... exit" + e); System.exit(-1); } final int window = Integer.parseInt(config.getProperty("time.window", "60")); final List<String> percent = Arrays.asList("tryConnectPer", "cBitpacketAccount", "abortConntionCount", "unidirectionalTrafficPer"); final List<String> jsonList = new ArrayList<>(); final Map<String, Tuple2<String, Integer>> stats = new HashMap<String, Tuple2<String, Integer>>(); final Map<ClientKey, BaseData> broadClient = new HashMap<ClientKey, BaseData>(); final Map<HostKey, BaseData> broadHost = new HashMap<HostKey, BaseData>(); final Map<ServiceKey, BaseData> broadService = new HashMap<ServiceKey, BaseData>(); final Map<SubnetKey, BaseData> broadSubnet = new HashMap<SubnetKey, BaseData>(); final Map<VlanKey, BaseData> broadVlan = new HashMap<VlanKey, BaseData>(); final String URL = config.getProperty("alert.url"); final String HEART_BEAT = config.getProperty("alert.heartbeat"); final String RECOVER = config.getProperty("alert.recover"); ZookeeperConfigWatcher.startZookeeperWatcherService(getConfig("alert.cnf").getProperty("kafaka.zoo"), "/ni/site", new SiteConvertImpl(flowConstant)); ZookeeperConfigWatcher.startZookeeperWatcherService(getConfig("alert.cnf").getProperty("kafaka.zoo"), "/ni/net", new NetConvertImpl(flowConstant)); ZookeeperConfigWatcher.startZookeeperWatcherService(getConfig("alert.cnf").getProperty("kafaka.zoo"), "/ni/vlan_sflow", new LinkConvertImpl(flowConstant)); ZookeeperConfigWatcher.startZookeeperWatcherService(getConfig("alert.cnf").getProperty("kafaka.zoo"), "/ni/subnet", new SubnetConvertImpl(flowConstant)); zookeeperClient.connectZookeeper(config.getProperty("kafaka.zoo")); esGet.setNodeClient(); startZookeeperService(flowConstant, zookeeperClient); zookeeperClient.setRules("/ni/caution"); JavaPairReceiverInputDStream<String, byte[]> rawStream = setupRawStreamFromKafka(config, config.getProperty("group.id", "oneapm-alert")); LOG.info("alert config:" + config.toString()); final Broadcast<IPDataInfo> ipDataBroadcastInfo = getJsc().sparkContext().broadcast(new IPDataInfo()); final Broadcast<ProtocalTypeInfo> protocalTypeBroadcastInfo = getJsc().sparkContext() .broadcast(new ProtocalTypeInfo()); JavaPairDStream<TimeAgg, BeforeAgg> aggJavaPairDStream = rawStream .mapToPair(new PairFunction<Tuple2<String, byte[]>, TimeAgg, BeforeAgg>() { private static final long serialVersionUID = -2751318332921803477L; @Override public Tuple2<TimeAgg, BeforeAgg> call(Tuple2<String, byte[]> stringTuple2) throws Exception { String[] s = TAB.split(new String(stringTuple2._2)); String clientIP = s[1]; String serverIP = s[2]; TimeAgg timeAgg = new TimeAgg(); BeforeAgg beforeAgg = new BeforeAgg(); timeAgg.setServer_ip(serverIP); if (s.length >= 60) { //setProtocal_type if (!"-".equals(s[11]) && !"".equals(s[11])) { timeAgg.setProtocal_type(s[11]); } else { if ("TCP".equals(s[12])) { ProtocalTypeInfo protocalTypeInfo = protocalTypeBroadcastInfo.value(); String protocalType = protocalTypeInfo.config.getProperty(s[4]); if (protocalType != null) { timeAgg.setProtocal_type(protocalType); } else { timeAgg.setProtocal_type("TCP_" + s[4]); } } else { timeAgg.setProtocal_type(s[12]); } } timeAgg.setType("tcp"); //setVlan_id String vlanLinkAlias = flowConstant.VLAN_LINK.get(s[13]); String portLinkAlias = flowConstant.PROBE_POTR_MAP.get(s[0] + "_" + s[15]); if (flowConstant.PROBE_HOST_ENABLE) { if (portLinkAlias != null) { timeAgg.setVlan_id(portLinkAlias); } else { timeAgg.setVlan_id(s[0] + "-nic" + s[15]); } } else if (flowConstant.VLAN_LINK_ENABLE) { if (vlanLinkAlias != null) { timeAgg.setVlan_id(vlanLinkAlias); } else { timeAgg.setVlan_id(s[13]); } } else { timeAgg.setVlan_id("Vlan" + s[13]); } if (!"-".equals(s[6])) { timeAgg.setTimestamp(format.format((long) Double.parseDouble(s[6]) * 1000)); } else { timeAgg.setTimestamp(s[6]); } if (!"-".equals(s[7])) { timeAgg.setTimeEnd(format.format((long) Double.parseDouble(s[7]) * 1000)); } else { timeAgg.setTimeEnd(s[7]); } beforeAgg.setPacket_size(Double.parseDouble(s[55]) + Double.parseDouble(s[56])); beforeAgg.setC_packet_size(Double.parseDouble(s[55])); beforeAgg.setS_packet_size(Double.parseDouble(s[56])); beforeAgg.setPacket_count(Double.parseDouble(s[59]) + Double.parseDouble(s[60])); beforeAgg.setLosspacket_count(Double.parseDouble(s[33]) + Double.parseDouble(s[39]) + Double.parseDouble(s[35]) + Double.parseDouble(s[41])); double cRto = (Double.valueOf(s[19]) + Double.valueOf(s[21]) + Double.valueOf(s[23])) * 1000; double sRto = (Double.valueOf(s[20]) + Double.valueOf(s[22]) + Double.valueOf(s[24])) * 1000; beforeAgg.setTotal_rto(cRto + sRto); // ?/TCP????/TCP????/TCP?MTU?MTU/TCP? beforeAgg.setInt_ZWIN_COUNT(Double.parseDouble(s[43])); beforeAgg.setInt_OOR_COUNT(Double.parseDouble(s[46])); beforeAgg.setInt_CONGEST_COUNT(Double.parseDouble(s[47])); beforeAgg.setMTU(Double.parseDouble(s[61]) + Double.parseDouble(s[62])); Boolean hasSynFlag = Boolean.valueOf(s[5]); timeAgg.setHasSyn(hasSynFlag); timeAgg.setBool_FIN(Boolean.valueOf(s[25])); timeAgg.setBool_RST(Boolean.valueOf(s[26])); if (hasSynFlag && "-".equals(s[9])) { beforeAgg.setAbort(1); } else { beforeAgg.setAbort(0); } beforeAgg.setTcpTurns(Integer.parseInt(s[30])); //int_TURN_COUNT beforeAgg.setConnrequest_count(Double.parseDouble(s[48])); beforeAgg.setsAbortConnCount(Integer.valueOf(s[50])); Long cPayLoad = Long.valueOf(s[53]); Long sPayLoad = Long.valueOf(s[54]); long payLoad = cPayLoad + sPayLoad; double sessionJlRtt = 0; if (!"-".equals(s[9])) { sessionJlRtt = Double.valueOf(s[9]) * 1000; beforeAgg.setRtt(sessionJlRtt); beforeAgg.setServerJlRttCount(1); beforeAgg.setClientJlRttCount(1); } if (hasSynFlag && !"-".equals(s[9])) { beforeAgg.setCount(1); if ("true".equals(s[26]) && payLoad == 0) { beforeAgg.setCount(0); } } if (!"-".equals(s[10])) { double clientJlRtt = Double.valueOf(s[10]) * 1000; double serverJlRtt = sessionJlRtt - clientJlRtt; if (clientJlRtt < sessionJlRtt) { beforeAgg.setServer_rtt(clientJlRtt); beforeAgg.setClient_rtt(serverJlRtt); } else { beforeAgg.setServer_rtt(sessionJlRtt / 2); beforeAgg.setClient_rtt(sessionJlRtt / 2); } } if (beforeAgg.tcpTurns > 0) { beforeAgg.setSessionCount(1); if (Double.parseDouble(s[18]) > 0) { beforeAgg.setServer_reponsetime( Double.parseDouble(s[18]) / beforeAgg.tcpTurns * 1000); } if (Double.parseDouble(s[16]) > 0) { beforeAgg.setResponseTransmissionTime( Double.parseDouble(s[16]) / beforeAgg.tcpTurns * 1000); } if (Double.parseDouble(s[17]) > 0) { beforeAgg.setRequestTransmissionTime( Double.parseDouble(s[17]) / beforeAgg.tcpTurns * 1000); } if (beforeAgg.total_rto > 0) { beforeAgg.setTotal_rto(beforeAgg.getTotal_rto() / beforeAgg.tcpTurns); } beforeAgg.setUserResponseTime( beforeAgg.getRtt() + beforeAgg.getRequestTransmissionTime() + beforeAgg.getResponseTransmissionTime() + beforeAgg.getServer_reponsetime() + beforeAgg.total_rto); } else { beforeAgg.setServer_reponsetime(0); beforeAgg.setResponseTransmissionTime(0); beforeAgg.setRequestTransmissionTime(0); beforeAgg.setTotal_rto(0); beforeAgg.setUserResponseTime(0); } beforeAgg.setC_bitpacket_account(Double.parseDouble(s[57]) + Double.parseDouble(s[58])); } else if (s.length <= 28) { if (!"-".equals(s[8]) && !"".equals(s[8])) { timeAgg.setProtocal_type(s[8]); } else { if ("UDP".equals(s[9])) { ProtocalTypeInfo protocalTypeInfo = protocalTypeBroadcastInfo.value(); String protocalType = protocalTypeInfo.config.getProperty(s[4]); if (protocalType != null) { timeAgg.setProtocal_type(protocalType); } else { timeAgg.setProtocal_type("UDP"); } } else { timeAgg.setProtocal_type(s[9]); } } beforeAgg.setCount(0); timeAgg.setType("udp"); timeAgg.setHasSyn(false); timeAgg.setBool_FIN(false); timeAgg.setBool_RST(false); //setVlan_id String vlanLinkAlias = flowConstant.VLAN_LINK.get(s[12]); String portLinkAlias = flowConstant.PROBE_POTR_MAP.get(s[0] + "_" + s[10]); if (flowConstant.PROBE_HOST_ENABLE) { if (portLinkAlias != null) { timeAgg.setVlan_id(portLinkAlias); } else { timeAgg.setVlan_id(s[0] + "-nic" + s[10]); } } else if (flowConstant.VLAN_LINK_ENABLE) { if (vlanLinkAlias != null) { timeAgg.setVlan_id(vlanLinkAlias); } else { timeAgg.setVlan_id(s[12]); } } else { timeAgg.setVlan_id("Vlan" + s[12]); } if (!"-".equals(s[5])) { timeAgg.setTimestamp(format.format((long) Double.parseDouble(s[5]) * 1000)); } else { timeAgg.setTimestamp(s[5]); } if (!"-".equals(s[6])) { timeAgg.setTimeEnd(format.format((long) Double.parseDouble(s[6]) * 1000)); } else { timeAgg.setTimeEnd(s[6]); } beforeAgg.setPacket_size(Double.parseDouble(s[20]) + Double.parseDouble(s[21])); beforeAgg.setPacket_count(Double.parseDouble(s[24]) + Double.parseDouble(s[25])); beforeAgg.setC_packet_size(Double.parseDouble(s[20])); beforeAgg.setS_packet_size(Double.parseDouble(s[21])); beforeAgg.setInt_ZWIN_COUNT(0); beforeAgg.setInt_OOR_COUNT(0); beforeAgg.setInt_CONGEST_COUNT(0); beforeAgg.setMTU(0); beforeAgg.setC_bitpacket_account(Double.parseDouble(s[22]) + Double.parseDouble(s[23])); beforeAgg.setAbort(0); beforeAgg.setClient_rtt(0); beforeAgg.setServer_rtt(0); beforeAgg.setRtt(0); beforeAgg.setServerJlRttCount(0); beforeAgg.setClientJlRttCount(0); beforeAgg.setLosspacket_count(0); beforeAgg.setServer_reponsetime(0); beforeAgg.setTcpTurns(0); beforeAgg.setConnrequest_count(0); beforeAgg.setTotal_rto(0); beforeAgg.setUserResponseTime(0); beforeAgg.setResponseTransmissionTime(0); beforeAgg.setRequestTransmissionTime(0); beforeAgg.setServer_reponsetime(0); beforeAgg.setsAbortConnCount(0); beforeAgg.setSessionCount(0); } String sInOutFlag = IPUtils.isInHomeNet(serverIP, flowConstant.HOMENET); String cInOutFlag = IPUtils.isInHomeNet(clientIP, flowConstant.HOMENET); //setSubnet if ("IN".equals(sInOutFlag)) { String sSubNet = IPUtils.getSubNet(serverIP, flowConstant.NETMASK); timeAgg.setSubnet(sSubNet + "/" + flowConstant.MASKBITS); } else { timeAgg.setSubnet("-"); } if ("255.255.255.255".equals(clientIP)) { timeAgg.setClient_site("-"); } else { String clientSiteInfo = IPUtils.getSiteInfo(clientIP, flowConstant.SITEINFO_MAP); IPDataInfo ipDataInfo = ipDataBroadcastInfo.getValue(); if (clientSiteInfo != null) { String[] clientSiteInfos = clientSiteInfo.split("_", 3); timeAgg.setClient_site(clientSiteInfos[2]); } else { if ("IN".equals(cInOutFlag)) { timeAgg.setClient_site(""); } else { if (ipDataInfo != null) { String[] ipinfo = ipDataInfo.find(clientIP); // if (ipinfo.length < 3) { timeAgg.setClient_site(""); } else { if ("".equals(ipinfo[0])) { timeAgg.setClient_site(""); } else { //,areasite if ("".equals(ipinfo[1])) { ipinfo[1] = ipinfo[0]; } if ("".equals(ipinfo[2])) { ipinfo[2] = ipinfo[1]; } timeAgg.setClient_site(ipinfo[2]); } } } else { timeAgg.setClient_site("?"); } } } } return new Tuple2<>(timeAgg, beforeAgg); } }).filter(new Function<Tuple2<TimeAgg, BeforeAgg>, Boolean>() { @Override public Boolean call(Tuple2<TimeAgg, BeforeAgg> v1) throws Exception { return !v1._1.getTimestamp().equals("-") && !v1._1.getTimestamp().equals(""); } }); // aggJavaPairDStream.foreachRDD(new Function<JavaPairRDD<TimeAgg, BeforeAgg>, Void>() { // @Override // public Void call(JavaPairRDD<TimeAgg, BeforeAgg> v1) throws Exception { // if (Boolean.parseBoolean(getConfig("alert.cnf").getProperty("save.es")) && v1 != null) { // JavaRDD<Map<String, ?>> es = v1.map(new Function<Tuple2<TimeAgg, BeforeAgg>, Map<String, // ?>>() { // // @Override // public Map<String, ?> call(Tuple2<TimeAgg, BeforeAgg> v1) throws Exception { // ImmutableMap.Builder<String, Object> builder = ImmutableMap.builder(); // // TimeAgg a = v1._1; // BeforeAgg b = v1._2; // String todayStr = sdf.format(format.parse(a.getTimestamp())); // builder.put("server_ip", a.server_ip); // builder.put("protocal_type", a.protocal_type); // builder.put("client_site", a.client_site); // builder.put("vlan_id", a.vlan_id); // builder.put("subnet", a.subnet); // builder.put("timestamp", format.parse(a.timestamp)); // if (b.packet_size > 0) { // builder.put("packet_size", b.packet_size); // } // if (b.c_packet_size > 0) { // builder.put("c_packet_size", b.c_packet_size); // } // // if (b.packet_count > 0) { // builder.put("packet_count", b.packet_count); // } // // if (b.losspacket_count > 0) { // builder.put("losspacket_count", b.losspacket_count); // } // if (b.total_rto > 0) { // builder.put("total_rto", b.total_rto); // builder.put("rtoCount", b.rtoCount); // } // // // if (b.tcpTurns > 0) { // builder.put("tcpTurns", b.tcpTurns); // } // if (b.connrequest_count > 0) { // builder.put("connrequest_count", b.connrequest_count); // } // if (b.abort > 0) { // builder.put("abort", b.abort); // } // if (b.client_rtt > 0) { // builder.put("client_rtt", b.client_rtt); // builder.put("clientJlRttCount", b.clientJlRttCount); // } // if (b.server_rtt > 0) { // builder.put("server_rtt", b.server_rtt); // builder.put("serverJlRttCount", b.serverJlRttCount); // } // // if (b.server_reponsetime > 0) { // builder.put("server_reponsetime", b.server_reponsetime); // builder.put("server_reponsetime_count", b.server_reponsetime_count); // } // // if (b.responseTransmissionTime > 0) { // builder.put("responseTransmissionTime", b.responseTransmissionTime); // builder.put("responseTransmissionTimeCount", b.responseTransmissionTimeCount); // } // if (b.requestTransmissionTime > 0) { // builder.put("requestTransmissionTime", b.requestTransmissionTime); // builder.put("requestTransmissionTimeCount", b.requestTransmissionTimeCount); // // } // // if (b.sAbortConnCount > 0) { // builder.put("sAbortConnCount", b.sAbortConnCount); // } // // if (b.userResponseTime > 0) { // builder.put("userResponseTime", b.userResponseTime); // builder.put("userResponseTimeCount", b.userResponseTimeCount); // } // if (b.c_bitpacket_account > 0) { // builder.put("c_bitpacket_account", b.c_bitpacket_account); // } // builder.put("index_name", todayStr); // // return builder.build(); // } // }).cache(); // if (es != null) { // JavaEsSpark.saveToEs(es, "ni-alert-session-{index_name}/alert", ImmutableMap.of // (ConfigurationOptions.ES_MAPPING_EXCLUDE, "index_name")); // } // } // return null; // } // }); JavaPairDStream<TimeAgg, BeforeAgg> reduceByWindow = aggJavaPairDStream .reduceByKeyAndWindow(new Function2<BeforeAgg, BeforeAgg, BeforeAgg>() { @Override public BeforeAgg call(BeforeAgg v1, BeforeAgg v2) throws Exception { BeforeAgg sum = new BeforeAgg(); sum.setPacket_size(v1.getPacket_size() + v2.getPacket_size()); sum.setC_packet_size(v1.getC_packet_size() + v2.getC_packet_size()); sum.setS_packet_size(v1.getS_packet_size() + v2.getS_packet_size()); sum.setPacket_count(v1.getPacket_count() + v2.getPacket_count()); sum.setC_packet_count(v1.getC_packet_count() + v2.getC_packet_count()); sum.setS_packet_count(v1.getS_packet_count() + v2.getS_packet_count()); sum.setLosspacket_count(v1.getLosspacket_count() + v2.getLosspacket_count()); sum.setTotal_rto(v1.getTotal_rto() + v2.getTotal_rto()); sum.setAbort(v1.getAbort() + v2.getAbort()); sum.setRequestTransmissionTime( v1.getRequestTransmissionTime() + v2.getRequestTransmissionTime()); sum.setResponseTransmissionTime( v1.getResponseTransmissionTime() + v2.getResponseTransmissionTime()); sum.setTcpTurns(v1.getTcpTurns() + v2.getTcpTurns()); sum.setConnrequest_count(v1.getConnrequest_count() + v2.getConnrequest_count()); sum.setRtt(v1.getRtt() + v2.getRtt()); sum.setClient_rtt(v1.getClient_rtt() + v2.getClient_rtt()); sum.setServer_rtt(v1.getServer_rtt() + v2.getServer_rtt()); sum.setServer_reponsetime(v1.getServer_reponsetime() + v2.getServer_reponsetime()); sum.setC_bitpacket_account(v1.getC_bitpacket_account() + v2.getC_bitpacket_account()); sum.setClientJlRttCount(v1.getClientJlRttCount() + v2.getClientJlRttCount()); sum.setServerJlRttCount(v1.getServerJlRttCount() + v2.getServerJlRttCount()); sum.setUserResponseTime(v1.getUserResponseTime() + v2.getUserResponseTime()); sum.setSessionCount(v1.sessionCount + v2.sessionCount); sum.setsAbortConnCount(v1.sAbortConnCount + v2.sAbortConnCount); sum.setCount(v1.getCount() + v2.getCount()); sum.setInt_CONGEST_COUNT(v1.int_CONGEST_COUNT + v2.int_CONGEST_COUNT); sum.setInt_OOR_COUNT(v1.int_OOR_COUNT + v2.int_OOR_COUNT); sum.setInt_ZWIN_COUNT(v1.int_ZWIN_COUNT + v2.int_ZWIN_COUNT); sum.setMTU(v1.MTU + v2.MTU); return sum; } }, Durations.seconds(300), Durations.seconds(60)).cache(); reduceByWindow.foreachRDD(new Function<JavaPairRDD<TimeAgg, BeforeAgg>, Void>() { private static final long serialVersionUID = -4144342491397135515L; @Override public Void call(JavaPairRDD<TimeAgg, BeforeAgg> v1) throws Exception { if (v1.count() > 0) { /** * getStartTime */ List<Long> timeList = v1.map(new Function<Tuple2<TimeAgg, BeforeAgg>, Long>() { @Override public Long call(Tuple2<TimeAgg, BeforeAgg> v1) throws Exception { return format.parse(v1._1.getTimestamp()).getTime(); } }).distinct().collect(); Collections.sort(timeList, new MyComparator()); long a = timeList.get(3); final String time = format.format(new Date(a)); long b = timeList.get(1); final String endTime = format.format(new Date(b)); if (b > 0) { JavaRDD<Map<String, ?>> active = v1 .filter(new Function<Tuple2<TimeAgg, BeforeAgg>, Boolean>() { @Override public Boolean call(Tuple2<TimeAgg, BeforeAgg> v1) throws Exception { String sInOutFlag = IPUtils.isInHomeNet(v1._1.getServer_ip(), flowConstant.HOMENET); return v1._1.getType().equals("tcp") && "IN".equals(sInOutFlag); } }).mapToPair( new PairFunction<Tuple2<TimeAgg, BeforeAgg>, Tuple2<String, String>, ConnectStatus>() { @Override public Tuple2<Tuple2<String, String>, ConnectStatus> call( Tuple2<TimeAgg, BeforeAgg> timeAggBeforeAggTuple2) throws Exception { ConnectStatus connectStatus = new ConnectStatus(); String serverIp = timeAggBeforeAggTuple2._1.getServer_ip(); String protoType = timeAggBeforeAggTuple2._1.getProtocal_type(); TimeAgg a = timeAggBeforeAggTuple2._1; BeforeAgg b = timeAggBeforeAggTuple2._2; // if (format.parse(a.timestamp).getTime() == format.parse(endTime) .getTime() && a.hasSyn) { connectStatus.setNewCreate(b.getCount()); } else { connectStatus.setNewCreate(0); } //?breakreset?break if (format.parse(a.timeEnd).getTime() == format.parse(endTime) .getTime() && (a.bool_FIN || a.bool_RST)) { connectStatus.setCloseConn(b.getCount()); } else { connectStatus.setCloseConn(0); } if (format.parse(a.timestamp).getTime() <= format.parse(endTime) .getTime() && format.parse(a.timeEnd).getTime() > format.parse(endTime) .getTime() && a.hasSyn) { connectStatus.setActiveConn(b.getCount()); } else if (format.parse(a.timestamp).getTime() == format .parse(endTime).getTime() && format.parse(a.timeEnd).getTime() == format .parse(endTime).getTime() && a.hasSyn) { connectStatus.setActiveConn(b.getCount()); } return new Tuple2<>(new Tuple2<>(serverIp, protoType), connectStatus); } }) .reduceByKey(new Function2<ConnectStatus, ConnectStatus, ConnectStatus>() { @Override public ConnectStatus call(ConnectStatus v1, ConnectStatus v2) throws Exception { ConnectStatus connectStatus = new ConnectStatus(); connectStatus.setNewCreate(v1.newCreate + v2.newCreate); connectStatus.setActiveConn(v1.activeConn + v2.activeConn); connectStatus.setCloseConn(v1.closeConn + v2.closeConn); return connectStatus; } }) .map(new Function<Tuple2<Tuple2<String, String>, ConnectStatus>, Map<String, ?>>() { @Override public Map<String, ?> call(Tuple2<Tuple2<String, String>, ConnectStatus> v1) throws Exception { ImmutableMap.Builder<String, Object> builder = ImmutableMap.builder(); String todayStr = sdf.format(format.parse(endTime)); builder.put("server_ip", v1._1._1); builder.put("protocal_type", v1._1._2); builder.put("newCreateConn", v1._2.getNewCreate()); builder.put("closeConn", v1._2.getCloseConn()); builder.put("activeConn", v1._2.getActiveConn()); builder.put("index_name", todayStr); builder.put("timestamp", format.parse(endTime)); return builder.build(); } }).cache(); if (active != null) { JavaEsSpark.saveToEs(active, "ni-active-conn-{index_name}/active", ImmutableMap.of(ConfigurationOptions.ES_MAPPING_EXCLUDE, "index_name")); } } JavaPairRDD<TimeAgg, BeforeAgg> before = v1 .filter(new Function<Tuple2<TimeAgg, BeforeAgg>, Boolean>() { @Override public Boolean call(Tuple2<TimeAgg, BeforeAgg> v1) throws Exception { return v1._1.getTimestamp().equals(time); } }); if (Boolean.parseBoolean(getConfig("alert.cnf").getProperty("save.es")) && before != null) { JavaRDD<Map<String, ?>> es = before .map(new Function<Tuple2<TimeAgg, BeforeAgg>, Map<String, ?>>() { @Override public Map<String, ?> call(Tuple2<TimeAgg, BeforeAgg> v1) throws Exception { ImmutableMap.Builder<String, Object> builder = ImmutableMap.builder(); TimeAgg a = v1._1; BeforeAgg b = v1._2; String todayStr = sdf.format(format.parse(a.getTimestamp())); builder.put("server_ip", a.server_ip); builder.put("protocal_type", a.protocal_type); builder.put("client_site", a.client_site); builder.put("vlan_id", a.vlan_id); builder.put("subnet", a.subnet); builder.put("timestamp", format.parse(a.timestamp)); if (b.packet_size > 0) { builder.put("packet_size", b.packet_size); } if (b.c_packet_size > 0) { builder.put("c_packet_size", b.c_packet_size); } builder.put("count", b.count); if (b.packet_count > 0) { builder.put("packet_count", b.packet_count); } if (b.losspacket_count > 0) { builder.put("losspacket_count", b.losspacket_count); } if (b.total_rto > 0) { builder.put("total_rto", b.total_rto); } if (b.tcpTurns > 0) { builder.put("tcpTurns", b.tcpTurns); builder.put("sessionCount", b.sessionCount); } if (b.connrequest_count > 0) { builder.put("connrequest_count", b.connrequest_count); } if (b.abort > 0) { builder.put("abort", b.abort); } if (b.client_rtt > 0) { builder.put("client_rtt", b.client_rtt); builder.put("clientJlRttCount", b.clientJlRttCount); } if (b.server_rtt > 0) { builder.put("server_rtt", b.server_rtt); builder.put("serverJlRttCount", b.serverJlRttCount); } if (b.server_reponsetime > 0) { builder.put("server_reponsetime", b.server_reponsetime); } if (b.responseTransmissionTime > 0) { builder.put("responseTransmissionTime", b.responseTransmissionTime); } if (b.requestTransmissionTime > 0) { builder.put("requestTransmissionTime", b.requestTransmissionTime); } if (b.sAbortConnCount > 0) { builder.put("sAbortConnCount", b.sAbortConnCount); } if (b.userResponseTime > 0) { builder.put("userResponseTime", b.userResponseTime); } if (b.c_bitpacket_account > 0) { builder.put("c_bitpacket_account", b.c_bitpacket_account); } builder.put("index_name", todayStr); return builder.build(); } }).cache(); if (es != null) { JavaEsSpark.saveToEs(es, "ni-alert-session-{index_name}/alert", ImmutableMap.of(ConfigurationOptions.ES_MAPPING_EXCLUDE, "index_name")); } } UrlPostMethod.urlPostMethod(HEART_BEAT, "frequency=" + window); rules = zookeeperClient.getRules(); if (rules != null) { ArrayList<String> flagRules = new ArrayList<String>(); //?ruleType for (final RuleRecover ruleRecover : rules) { final Rule rule = ruleRecover.getRule(); if (rule.isEnable() && !flagRules.contains(rule.getType())) { //ruleType? flagRules.add(rule.getType()); //ruleType? JavaPairRDD<String, AggResult> alert = before.mapToPair( new PairFunction<Tuple2<TimeAgg, BeforeAgg>, String, BeforeAgg>() { @Override public Tuple2<String, BeforeAgg> call( Tuple2<TimeAgg, BeforeAgg> timeAggBeforeAggTuple2) throws Exception { Field field1 = timeAggBeforeAggTuple2._1.getClass() .getDeclaredField(rule.getType()); field1.setAccessible(true); String result1 = (String) field1.get(timeAggBeforeAggTuple2._1); if (rule.getType().equals("server_ip")) { String sInOutFlag = IPUtils.isInHomeNet( timeAggBeforeAggTuple2._1.getServer_ip(), flowConstant.HOMENET); if ("IN".equals(sInOutFlag)) { return new Tuple2<>(result1, timeAggBeforeAggTuple2._2); } else { return new Tuple2<>(result1, null); } } else { return new Tuple2<>(result1, timeAggBeforeAggTuple2._2); } } }).filter(new Function<Tuple2<String, BeforeAgg>, Boolean>() { @Override public Boolean call(Tuple2<String, BeforeAgg> v1) throws Exception { return v1._2 != null && !v1._1.equals("") && !v1._1.equals("-"); } }).reduceByKey(new Function2<BeforeAgg, BeforeAgg, BeforeAgg>() { @Override public BeforeAgg call(BeforeAgg v1, BeforeAgg v2) throws Exception { BeforeAgg sum = new BeforeAgg(); sum.setPacket_size(v1.getPacket_size() + v2.getPacket_size()); sum.setC_packet_size(v1.getC_packet_size() + v2.getC_packet_size()); sum.setS_packet_size(v1.getS_packet_size() + v2.getS_packet_size()); sum.setPacket_count(v1.getPacket_count() + v2.getPacket_count()); sum.setC_packet_count( v1.getC_packet_count() + v2.getC_packet_count()); sum.setS_packet_count( v1.getS_packet_count() + v2.getS_packet_count()); sum.setLosspacket_count( v1.getLosspacket_count() + v2.getLosspacket_count()); sum.setTotal_rto(v1.getTotal_rto() + v2.getTotal_rto()); sum.setAbort(v1.getAbort() + v2.getAbort()); sum.setRequestTransmissionTime(v1.getRequestTransmissionTime() + v2.getRequestTransmissionTime()); sum.setResponseTransmissionTime(v1.getResponseTransmissionTime() + v2.getResponseTransmissionTime()); sum.setTcpTurns(v1.getTcpTurns() + v2.getTcpTurns()); sum.setConnrequest_count( v1.getConnrequest_count() + v2.getConnrequest_count()); sum.setRtt(v1.getRtt() + v2.getRtt()); sum.setClient_rtt(v1.getClient_rtt() + v2.getClient_rtt()); sum.setServer_rtt(v1.getServer_rtt() + v2.getServer_rtt()); sum.setServer_reponsetime( v1.getServer_reponsetime() + v2.getServer_reponsetime()); sum.setC_bitpacket_account( v1.getC_bitpacket_account() + v2.getC_bitpacket_account()); sum.setClientJlRttCount( v1.getClientJlRttCount() + v2.getClientJlRttCount()); sum.setServerJlRttCount( v1.getServerJlRttCount() + v2.getServerJlRttCount()); sum.setUserResponseTime( v1.getUserResponseTime() + v2.getUserResponseTime()); sum.setSessionCount(v1.sessionCount + v2.sessionCount); sum.setsAbortConnCount(v1.sAbortConnCount + v2.sAbortConnCount); return sum; } }).mapToPair( new PairFunction<Tuple2<String, BeforeAgg>, String, AggResult>() { @Override public Tuple2<String, AggResult> call( Tuple2<String, BeforeAgg> stringBeforeAggTuple2) throws Exception { BeforeAgg before = stringBeforeAggTuple2._2; AggResult result = new AggResult(); result.setTimestamp(time); result.setThroughput(before.packet_size * 8 / window); result.setS_throughput(before.s_packet_size * 8 / window); result.setC_throughput( before.c_bitpacket_account * 8 / window); result.setPacketThroughput(before.packet_count / window); result.setLossRate(before.losspacket_count / before.packet_count * 100); if (before.sessionCount > 0) { result.setRetransferTime( before.total_rto / before.sessionCount); } else { result.setRetransferTime(0); } if (before.clientJlRttCount > 0) { result.setClientRoundTripTime( before.client_rtt / before.clientJlRttCount); result.setRtt(before.rtt / before.clientJlRttCount); } else { result.setClientRoundTripTime(0); result.setRtt(0); } if (before.serverJlRttCount > 0) { result.setServerRoundTripTime( before.server_rtt / before.serverJlRttCount); } else { result.setServerRoundTripTime(0); } if (before.sessionCount > 0) { result.setUserRespTime(before.getUserResponseTime() / before.sessionCount); result.setTransmissionTime( (before.requestTransmissionTime + before.responseTransmissionTime) / before.sessionCount); } else { result.setUserRespTime(0); result.setTransmissionTime(0); } if (before.sessionCount > 0) { result.setServerRespTime(before.server_reponsetime / before.sessionCount); } else { result.setServerRespTime(0); } result.setConnectFailedRate(before.abort / window); //@Deprecates result.setTryConnectPer(0); result.setCongest_pre(before.getInt_CONGEST_COUNT() / before.getCount() * 100); result.setOutoforder_pre(before.getInt_OOR_COUNT() / before.getCount() * 100); result.setZerowindow_pre(before.getInt_ZWIN_COUNT() / before.getCount() * 100); result.setMTU_pre( before.getMTU() / before.getCount() * 100); if (before.packet_count > 0) { result.setcBitpacketAccount(before.c_bitpacket_account / before.packet_count * 100); } else { result.setcBitpacketAccount(0); } if (before.connrequest_count - before.abort > 0) { result.setAbortConntionCount(before.sAbortConnCount / (before.connrequest_count - before.abort) * 100); } else { result.setAbortConntionCount(0); } return new Tuple2<>(stringBeforeAggTuple2._1, result); } }) .cache(); if (alert.count() > 0) { List<String> alertList = new ArrayList<>(); for (final RuleRecover newRule : rules) { final Rule sameRule = newRule.getRule(); if (Boolean.parseBoolean(getConfig("alert.cnf").getProperty("save.es"))) { System.out.println( "rule:" + sameRule.toString() + "--------------"); } final int recover = newRule.getRecover(); if (sameRule.isEnable() && sameRule.getType().equals(flagRules.get(flagRules.size() - 1))) { if (!sameRule.getThresholdErrType().equals("absolute")) { if (esGet.getClient() == null) { esGet.setNodeClient(); } final Calendar now = Calendar.getInstance(); now.setTime(format.parse(time)); int minute = now.get(Calendar.MINUTE); Key key = null; switch (sameRule.getType()) { case "server_ip": if (minute % 5 != 0) { now.set(Calendar.MINUTE, minute / 5 * 5); if (broadHost.isEmpty()) { Map<HostKey, BaseData> service = esGet .setHost(now.getTime(), "ni-base-hostname"); broadHost.putAll(service); } } else { Map<HostKey, BaseData> service = esGet .setHost(now.getTime(), "ni-base-hostname"); broadHost.clear(); broadHost.putAll(service); } key = new HostKey(); // baseData = broadHost.get(key); break; case "protocal_type": if (minute % 5 != 0) { now.set(Calendar.MINUTE, minute / 5 * 5); if (broadService.isEmpty()) { Map<ServiceKey, BaseData> service = esGet .setService(now.getTime(), "ni-base-service"); broadService.putAll(service); } } else { Map<ServiceKey, BaseData> service = esGet .setService(now.getTime(), "ni-base-service"); broadService.clear(); broadService.putAll(service); } key = new ServiceKey(); // key.setKeyWord(stringAggResultTuple2._1); // key.setStart_timestamp(now.getTime()); // baseData = broadService.get(key); break; case "client_site": if (minute % 5 != 0) { now.set(Calendar.MINUTE, minute / 5 * 5); if (broadClient.isEmpty()) { Map<ClientKey, BaseData> service = esGet .setClient(now.getTime(), "ni-base-clientsite"); broadClient.putAll(service); } } else { Map<ClientKey, BaseData> service = esGet .setClient(now.getTime(), "ni-base-clientsite"); broadClient.clear(); broadClient.putAll(service); } key = new ClientKey(); // key.setKeyWord(stringAggResultTuple2._1); // key.setStart_timestamp(now.getTime()); // baseData = broadClient.get(key); break; case "vlan_id": if (minute % 5 != 0) { now.set(Calendar.MINUTE, minute / 5 * 5); if (broadVlan.isEmpty()) { Map<VlanKey, BaseData> service = esGet .setVlan(now.getTime(), "ni-base-link"); broadVlan.putAll(service); } } else { Map<VlanKey, BaseData> service = esGet .setVlan(now.getTime(), "ni-base-link"); broadVlan.clear(); broadVlan.putAll(service); } key = new VlanKey(); // key.setKeyWord(stringAggResultTuple2._1); // key.setStart_timestamp(now.getTime()); // baseData = broadVlan.get(key); break; case "subnet": if (minute % 5 != 0) { now.set(Calendar.MINUTE, minute / 5 * 5); if (broadSubnet.isEmpty()) { Map<SubnetKey, BaseData> service = esGet .setSubnet(now.getTime(), "ni-base-subnet"); broadSubnet.putAll(service); } } else { Map<SubnetKey, BaseData> service = esGet .setSubnet(now.getTime(), "ni-base-subnet"); broadSubnet.clear(); broadSubnet.putAll(service); } key = new SubnetKey(); // key.setKeyWord(stringAggResultTuple2._1); // key.setStart_timestamp(now.getTime()); // baseData = broadSubnet.get(key); break; } final Key finalKey = key; alertList = alert .filter(new Function<Tuple2<String, AggResult>, Boolean>() { @Override public Boolean call(Tuple2<String, AggResult> v1) throws Exception { Field field2 = v1._2.getClass() .getDeclaredField(sameRule.getValue()); field2.setAccessible(true); double result2 = (double) field2.get(v1._2); if (result2 == 0) { return false; } String contain = sameRule.getContain(); if (contain.equals("") && !v1._1.equals("")) { return true; } if (v1._1 == null || v1._1.equals("")) { return false; } return v1._1.contains(sameRule.getContain()); } }).mapToPair( new PairFunction<Tuple2<String, AggResult>, String, String>() { @Override public Tuple2<String, String> call( Tuple2<String, AggResult> stringAggResultTuple2) throws Exception { Field field2 = stringAggResultTuple2._2 .getClass().getDeclaredField( sameRule.getValue()); field2.setAccessible(true); double alertCursor = (double) field2 .get(stringAggResultTuple2._2); JSONObject json = new JSONObject(); BaseData baseData = new BaseData(); finalKey.setKeyWord( stringAggResultTuple2._1); finalKey.setStart_timestamp(now.getTime()); baseData = broadService.get(finalKey); if (baseData != null) { Field field = baseData.getClass() .getDeclaredField( sameRule.getValue()); field.setAccessible(true); double result = (double) field .get(baseData); AlertLevel alertLevel = new AlertLevel(); if (sameRule.getThresholdErrOp() .equals("ge")) { if (alertCursor - result >= sameRule .getMax_cardinality()) { alertLevel.setWarningLevel( "levelBad"); } else if (alertCursor - result >= sameRule .getMin_cardinality()) { alertLevel.setWarningLevel( "levelWarn"); } else { alertLevel.setWarningLevel( "levelNormal"); } } if (sameRule.getThresholdErrOp() .equals("le")) { if (result - alertCursor <= sameRule .getMax_cardinality()) { alertLevel.setWarningLevel( "levelBad"); } else if (result - alertCursor <= sameRule .getMin_cardinality()) { alertLevel.setWarningLevel( "levelWarn"); } else { alertLevel.setWarningLevel( "levelNormal"); } } alertLevel.setResourceName( stringAggResultTuple2._1); if (sameRule.getType() .equals("server_ip")) { alertLevel.setIpAddress( stringAggResultTuple2._1); } else { alertLevel.setIpAddress(""); } alertLevel.setOccureTime( esFormat.format(format.parse( stringAggResultTuple2._2 .getTimestamp()))); alertLevel.setResourceType( sameRule.getType()); alertLevel.setMetricId( sameRule.getValue()); alertLevel.setResourceInstanceId( stringAggResultTuple2._1); // top2 d?>10%? Map<String, Double> top2 = new HashMap<String, Double>(); top2.put("MTU?", stringAggResultTuple2._2 .getMTU_pre()); top2.put("?", stringAggResultTuple2._2 .getCongest_pre()); top2.put("??", stringAggResultTuple2._2 .getOutoforder_pre()); top2.put("??", stringAggResultTuple2._2 .getZerowindow_pre()); List<Map.Entry<String, Double>> list = SortHashMap .sortHashMap(top2); if ("lossRate" .equals(sameRule.getValue())) { if (list.get(0).getValue() > 10 && list.get(1) .getValue() > 10) { alertLevel.setWarningContent( alertLevel.getMetricId() + "" + df.format( alertCursor) + "%25," + list.get(0) .getKey() + "" + list.get(0) .getValue() + "%25," + list.get(1) .getKey() + "" + list.get(1) .getValue() + "%25." + result + "." + sameRule .getMin_cardinality() + "," + sameRule .getMax_cardinality()); } else { alertLevel.setWarningContent( alertLevel.getMetricId() + "" + df.format( alertCursor) + "%25," + result + "." + sameRule .getMin_cardinality() + "," + sameRule .getMax_cardinality()); } } else { if ("userRespTime".equals( sameRule.getValue())) { if (list.get(0).getValue() > 10 && list.get(1) .getValue() > 10) { alertLevel .setWarningContent( alertLevel .getMetricId() + "" + millToSec( (long) alertCursor) + "," + millToSec( (long) stringAggResultTuple2._2 .getRtt()) + "ms,?" + millToSec( (long) stringAggResultTuple2._2 .getServerRespTime()) + "ms," + millToSec( (long) stringAggResultTuple2._2 .getTransmissionTime()) + "ms,?" + millToSec( (long) stringAggResultTuple2._2 .getRetransferTime()) + "." + list.get( 0) .getKey() + "" + list.get( 0) .getValue() + "%25," + list.get( 1) .getKey() + "" + list.get( 1) .getValue() + "%25." + result + "." + sameRule .getMin_cardinality() + "," + sameRule .getMax_cardinality()); } else { alertLevel .setWarningContent( alertLevel .getMetricId() + "" + millToSec( (long) alertCursor) + "," + millToSec( (long) stringAggResultTuple2._2 .getRtt()) + "ms,?" + millToSec( (long) stringAggResultTuple2._2 .getServerRespTime()) + "ms," + millToSec( (long) stringAggResultTuple2._2 .getTransmissionTime()) + "ms,?" + millToSec( (long) stringAggResultTuple2._2 .getRetransferTime()) + "." + result + "." + sameRule .getMin_cardinality() + "," + sameRule .getMax_cardinality()); } } else if ("rtt".equals( sameRule.getValue())) { alertLevel.setWarningContent( "RTT" + millToSec( (long) alertCursor) + ",RTT" + millToSec( (long) stringAggResultTuple2._2 .getClientRoundTripTime()) + "ms,?RTT" + millToSec( (long) stringAggResultTuple2._2 .getServerRoundTripTime()) + "ms." + result + "." + sameRule .getMin_cardinality() + "," + sameRule .getMax_cardinality()); } else if ("throughput".equals( sameRule.getType())) { alertLevel.setWarningContent( alertLevel.getMetricId() + "" + convertUnit( (long) alertCursor) + ",????" + convertUnit( (long) stringAggResultTuple2._2 .getS_throughput()) + ",????" + convertUnit( (long) stringAggResultTuple2._2 .getC_throughput()) + "." + convertUnit( (long) result) + "." + sameRule .getMin_cardinality() + "," + sameRule .getMax_cardinality()); } else if ("packetThroughput" .equals(sameRule .getValue())) { alertLevel.setWarningContent( alertLevel.getMetricId() + "" + df.format( alertCursor) + ",????" + stringAggResultTuple2._2 .getS_packetThroughput() + ",????" + stringAggResultTuple2._2 .getC_packetThroughput() + "." + result + "." + sameRule .getMin_cardinality() + "," + sameRule .getMax_cardinality()); } else if (percent.contains( sameRule.getValue())) { alertLevel.setWarningContent( alertLevel.getMetricId() + "" + df.format( alertCursor) + "%25," + sameRule .getMin_cardinality() + "." + result + "." + sameRule .getMax_cardinality()); } else { alertLevel.setWarningContent( alertLevel.getMetricId() + "" + df.format( alertCursor) + "." + result + "." + sameRule .getMin_cardinality() + "," + sameRule .getMax_cardinality()); } } alertLevel.setRuleId( sameRule.getRuleName()); alertLevel.setUniqueMark(sameRule .getRuleName() + "-" + stringAggResultTuple2._1 + "-" + sameRule.getValue()); if (stats.containsKey( alertLevel.getUniqueMark())) { String preLevel = stats .get(alertLevel .getUniqueMark())._1; int num = stats.get(alertLevel .getUniqueMark())._2; boolean preWarning = preLevel .equals("levelWarn") || preLevel .equals("levelBad"); boolean newWarning = alertLevel .getWarningLevel() .equals("levelWarn") || alertLevel .getWarningLevel() .equals("levelBad"); if (preWarning && !newWarning) { num = 1 - num; stats.put(alertLevel .getUniqueMark(), new Tuple2<String, Integer>( alertLevel .getWarningLevel(), num)); } else if (!preWarning && newWarning) { stats.put(alertLevel .getUniqueMark(), new Tuple2<String, Integer>( alertLevel .getWarningLevel(), 0 - recover)); } else if (!preWarning && !preWarning) { num = 1 - num; stats.put(alertLevel .getUniqueMark(), new Tuple2<String, Integer>( alertLevel .getWarningLevel(), num)); } else { num = 0 - num; stats.put(alertLevel .getUniqueMark(), new Tuple2<String, Integer>( alertLevel .getWarningLevel(), num)); } } else { if (alertLevel.getWarningLevel() .equals("levelWarn") || alertLevel .getWarningLevel() .equals("levelBad")) { stats.put(alertLevel .getUniqueMark(), new Tuple2<String, Integer>( alertLevel .getWarningLevel(), 0 - recover)); json = (JSONObject) JSON .toJSON(alertLevel); return new Tuple2<>( stringAggResultTuple2._1, json.toString()); } } } return new Tuple2<>( stringAggResultTuple2._1, ""); } }) .filter(new Function<Tuple2<String, String>, Boolean>() { @Override public Boolean call(Tuple2<String, String> v1) throws Exception { return !v1._2.equals("") && v1._2 != null; } }).map(new Function<Tuple2<String, String>, String>() { @Override public String call(Tuple2<String, String> v1) throws Exception { return v1._2; } }).collect(); } else { alertList = alert .filter(new Function<Tuple2<String, AggResult>, Boolean>() { @Override public Boolean call(Tuple2<String, AggResult> v1) throws Exception { Field field2 = v1._2.getClass() .getDeclaredField(sameRule.getValue()); field2.setAccessible(true); double result2 = (double) field2.get(v1._2); if (result2 == 0.0) { return false; } String contain = sameRule.getContain(); if (contain.equals("") && !v1._1.equals("")) { return true; } if (v1._1 == null || v1._1.equals("")) { return false; } return v1._1.contains(sameRule.getContain()); } }).mapToPair( new PairFunction<Tuple2<String, AggResult>, String, String>() { @Override public Tuple2<String, String> call( Tuple2<String, AggResult> stringAggResultTuple2) throws Exception { Field field2 = stringAggResultTuple2._2 .getClass().getDeclaredField( sameRule.getValue()); field2.setAccessible(true); double alertCursor = (double) field2 .get(stringAggResultTuple2._2); JSONObject json = new JSONObject(); AlertLevel alertLevel = new AlertLevel(); if (alertCursor >= sameRule .getMax_cardinality()) { alertLevel.setWarningLevel("levelBad"); } else if (alertCursor >= sameRule .getMin_cardinality()) { alertLevel.setWarningLevel("levelWarn"); } else { alertLevel .setWarningLevel("levelNormal"); } alertLevel.setResourceName( stringAggResultTuple2._1); if (sameRule.getType() .equals("server_ip")) { alertLevel.setIpAddress( stringAggResultTuple2._1); } else { alertLevel.setIpAddress(""); } alertLevel.setResourceType( sameRule.getType()); alertLevel.setOccureTime( esFormat.format(format.parse( stringAggResultTuple2._2 .getTimestamp()))); alertLevel.setMetricId(sameRule.getValue()); alertLevel.setResourceInstanceId( stringAggResultTuple2._1); // top2 d?>10%? Map<String, Double> top2 = new HashMap<String, Double>(); top2.put("MTU?", stringAggResultTuple2._2 .getMTU_pre()); top2.put("?", stringAggResultTuple2._2 .getCongest_pre()); top2.put("??", stringAggResultTuple2._2 .getOutoforder_pre()); top2.put("??", stringAggResultTuple2._2 .getZerowindow_pre()); List<Map.Entry<String, Double>> list = SortHashMap .sortHashMap(top2); if ("lossRate" .equals(sameRule.getValue())) { if (list.get(0).getValue() > 10 && list .get(1).getValue() > 10) { alertLevel.setWarningContent( alertLevel.getMetricId() + "" + df.format( alertCursor) + "%25," + list.get(0) .getKey() + "" + list.get(0) .getValue() + "%25," + list.get(1) .getKey() + "" + list.get(1) .getValue() + "%25." + "" + sameRule .getMin_cardinality() + "," + sameRule .getMax_cardinality()); } else { alertLevel.setWarningContent( alertLevel.getMetricId() + "" + df.format( alertCursor) + "%25," + "," + sameRule .getMin_cardinality() + "," + sameRule .getMax_cardinality()); } } else if ("userRespTime" .equals(sameRule.getValue())) { if (list.get(0).getValue() > 10 && list .get(1).getValue() > 10) { alertLevel.setWarningContent( alertLevel.getMetricId() + "" + millToSec( (long) alertCursor) + "," + millToSec( (long) stringAggResultTuple2._2 .getRtt()) + ",?" + millToSec( (long) stringAggResultTuple2._2 .getServerRespTime()) + "," + millToSec( (long) stringAggResultTuple2._2 .getTransmissionTime()) + "?" + millToSec( (long) stringAggResultTuple2._2 .getRetransferTime()) + "." + list.get(0) .getKey() + "" + list.get(0) .getValue() + "%25," + list.get(1) .getKey() + "" + list.get(1) .getValue() + "%25." + "" + sameRule .getMin_cardinality() + "," + sameRule .getMax_cardinality()); } else { alertLevel.setWarningContent( alertLevel.getMetricId() + "" + millToSec( (long) alertCursor) + "," + millToSec( (long) stringAggResultTuple2._2 .getRtt()) + ",?" + millToSec( (long) stringAggResultTuple2._2 .getServerRespTime()) + "," + millToSec( (long) stringAggResultTuple2._2 .getTransmissionTime()) + "?" + millToSec( (long) stringAggResultTuple2._2 .getRetransferTime()) + "." + sameRule .getMin_cardinality() + "," + sameRule .getMax_cardinality()); } } else if ("rtt" .equals(sameRule.getValue())) { alertLevel.setWarningContent("RTT" + millToSec((long) alertCursor) + ",RTT" + millToSec( (long) stringAggResultTuple2._2 .getClientRoundTripTime()) + ",?RTT" + millToSec( (long) stringAggResultTuple2._2 .getServerRoundTripTime()) + "." + sameRule.getMin_cardinality() + "," + sameRule .getMax_cardinality()); } else if ("throughput" .equals(sameRule.getType())) { alertLevel.setWarningContent(alertLevel .getMetricId() + "" + convertUnit( (long) alertCursor) + ",????" + convertUnit( (long) stringAggResultTuple2._2 .getS_throughput()) + ",????" + convertUnit( (long) stringAggResultTuple2._2 .getC_throughput()) + "." + sameRule.getMin_cardinality() + "," + sameRule .getMax_cardinality()); } else if ("packetThroughput" .equals(sameRule.getValue())) { alertLevel.setWarningContent(alertLevel .getMetricId() + "" + df.format(alertCursor) + ",????" + stringAggResultTuple2._2 .getS_packetThroughput() + ",????" + stringAggResultTuple2._2 .getC_packetThroughput() + "." + sameRule.getMin_cardinality() + "," + sameRule .getMax_cardinality()); } else if (percent .contains(sameRule.getValue())) { alertLevel.setWarningContent(alertLevel .getMetricId() + "" + df.format(alertCursor) + "%25," + sameRule.getMin_cardinality() + "," + sameRule .getMax_cardinality()); } else { alertLevel.setWarningContent(alertLevel .getMetricId() + "" + df.format(alertCursor) + "," + sameRule.getMin_cardinality() + "," + sameRule .getMax_cardinality()); } alertLevel .setRuleId(sameRule.getRuleName()); alertLevel.setUniqueMark( sameRule.getRuleName() + "-" + stringAggResultTuple2._1 + "-" + sameRule.getValue()); if (stats.containsKey( alertLevel.getUniqueMark())) { String preLevel = stats.get( alertLevel.getUniqueMark())._1; int num = stats.get( alertLevel.getUniqueMark())._2; boolean preWarning = preLevel .equals("levelWarn") || preLevel.equals("levelBad"); boolean newWarning = alertLevel .getWarningLevel() .equals("levelWarn") || alertLevel.getWarningLevel() .equals("levelBad"); if (preWarning && !newWarning) { num = 1 - num; stats.put( alertLevel.getUniqueMark(), new Tuple2<String, Integer>( alertLevel .getWarningLevel(), num)); } else if (!preWarning && newWarning) { stats.put( alertLevel.getUniqueMark(), new Tuple2<String, Integer>( alertLevel .getWarningLevel(), 0 - recover)); } else if (!preWarning && !preWarning) { num = 1 - num; stats.put( alertLevel.getUniqueMark(), new Tuple2<String, Integer>( alertLevel .getWarningLevel(), num)); } else { num = 0 - num; stats.put( alertLevel.getUniqueMark(), new Tuple2<String, Integer>( alertLevel .getWarningLevel(), num)); } } else { if (alertLevel.getWarningLevel() .equals("levelWarn") || alertLevel.getWarningLevel() .equals("levelBad")) { stats.put( alertLevel.getUniqueMark(), new Tuple2<String, Integer>( alertLevel .getWarningLevel(), 0 - recover)); json = (JSONObject) JSON .toJSON(alertLevel); return new Tuple2<>( stringAggResultTuple2._1, json.toString()); } } return new Tuple2<>( stringAggResultTuple2._1, ""); } }) .filter(new Function<Tuple2<String, String>, Boolean>() { private static final long serialVersionUID = 662946729452638751L; @Override public Boolean call(Tuple2<String, String> v1) throws Exception { return !v1._2.equals("") && v1._2 != null; } }).map(new Function<Tuple2<String, String>, String>() { @Override public String call(Tuple2<String, String> v1) throws Exception { return v1._2; } }).collect(); } } jsonList.addAll(alertList); alertList.clear(); } } } } flagRules.clear(); } Iterator<Map.Entry<String, Tuple2<String, Integer>>> iterator = stats.entrySet().iterator(); while (iterator.hasNext()) { Map.Entry<String, Tuple2<String, Integer>> entry = iterator.next(); int num = entry.getValue()._2; if (num == 0) { UrlPostMethod.urlPostMethod(RECOVER, entry.getValue()._1); iterator.remove(); } else if (num < 0) { num = 0 - num; entry.setValue(new Tuple2<String, Integer>(entry.getValue()._1, num)); } else { num = 1 - num; if (num == 0) { UrlPostMethod.urlPostMethod(RECOVER, entry.getValue()._1); iterator.remove(); } else { entry.setValue(new Tuple2<String, Integer>(entry.getValue()._1, num)); } } } if (stats.size() > 200000) { stats.clear(); } if (jsonList.size() > 0) { if (Boolean.parseBoolean(getConfig("alert.cnf").getProperty("save.es"))) { System.out.println( "-------------------" + jsonList.toString() + "-----------------------"); } for (int i = 0; i <= jsonList.size() / 2000; i++) { UrlPostMethod.urlPostMethod(URL, "warnings=" + Arrays.asList(Arrays.copyOfRange( jsonList.toArray(), i * 2000, (i + 1) * 2000 - 1 > jsonList.size() ? jsonList.size() : (i + 1) * 2000 - 1)) .toString()); } jsonList.clear(); } } return null; } }); rawStream.context().start(); rawStream.context().awaitTermination(); } private static String convertUnit(long size) { if (size < 1024) { return size + "B"; } else { size = size / 1024; } //1024?1024?KB?? //???? // if (size < 1024) { return String.valueOf(size) + "KB"; } else { size = size / 1024; } if (size < 1024) { //MB??????1?? //100??? size = size * 100; return String.valueOf((size / 100)) + "." + String.valueOf((size % 100)) + "MB"; } else { //??GB??1024??? size = size * 100 / 1024; return String.valueOf((size / 100)) + "." + String.valueOf((size % 100)) + "GB"; } } private static String millToSec(long time) { if (time < 1000) { return time + "ms"; } else { time = time / 1000; } time = time * 100; return String.valueOf((time / 100)) + "." + String.valueOf((time % 100)) + "s"; } private static void startZookeeperService(final FlowConstant flowConstant, final ZookeeperClient zookeeperClient) throws IOException { final Date startTime = new Date(); ScheduledExecutorService service = Executors.newScheduledThreadPool(3, new ThreadFactory() { @Override public Thread newThread(Runnable r) { return new Thread(r, "Zookeeper-Writer-ThreadPool"); } }); final String zookeeper = Config.getConfig("alert.cnf").getProperty("kafaka.zoo", "127.0.0.1:2181"); final String kafaka = Config.getConfig("alert.cnf").getProperty("kafaka.zoo", "127.0.0.1:9092"); zookeeperClient.setLicense("/ni/license"); zookeeperClient.createNode("/ni", "", true); zookeeperClient.createNode("/ni/process", "", true); zookeeperClient.createNode("/ni/process/Alarm", "", false); service.scheduleAtFixedRate(new Runnable() { @Override public void run() { try { //? checkComponent(); writeData(); } catch (Exception e) { LOG.warn("zookeeper?:" + e.getMessage()); } } //? private void checkComponent() { Socket clientSocket = null; try { String[] zookeeperInfo = zookeeper.split(":"); clientSocket = new Socket(zookeeperInfo[0], Integer.valueOf(zookeeperInfo[1])); flowConstant.isZookeeperOkFlag = true; flowConstant.isKafkaOkFlag = true; } catch (Exception e) { flowConstant.isZookeeperOkFlag = false; flowConstant.isKafkaOkFlag = false; } finally { if (clientSocket != null) { try { clientSocket.close(); } catch (IOException e) { LOG.warn("socket:" + e.getMessage()); } } } // //kafka? // try { // String[] kafakaInfo = kafaka.split(":"); // clientSocket = new Socket(kafakaInfo[0], Integer.valueOf(kafakaInfo[1])); // // flowConstant.isKafkaOkFlag = true; // } catch (Exception e) { // flowConstant.isKafkaOkFlag = false; // } finally { // try { // clientSocket.close(); // } catch (IOException e) { // LOG.warn("socket:" + e.getMessage()); // } // } } private void writeData() { Map<String, String> processInfoMap = new HashMap<String, String>(); try { processInfoMap.put("host", String.valueOf(InetAddress.getLocalHost())); } catch (UnknownHostException e) { e.printStackTrace(); } processInfoMap.put("setupLocation", System.getProperty("user.dir")); processInfoMap.put("startupTime", String.valueOf(startTime.getTime())); String licence = "no license"; if (Integer.parseInt(zookeeperClient.getLicense().split("\n")[2].split("=")[1]) == 1) { licence = "ok"; } processInfoMap.put("licence", licence); if (flowConstant.isEsOKFlag && flowConstant.isKafkaOkFlag && flowConstant.isZookeeperOkFlag) { processInfoMap.put("status", "ok"); } else { List<String> components = new ArrayList<String>(); if (!flowConstant.isEsOKFlag) { components.add("es is not available!"); } if (!flowConstant.isZookeeperOkFlag) { components.add("zookeeper is not available!"); } if (!flowConstant.isKafkaOkFlag) { components.add("kafka is not available!"); } processInfoMap.put("status", StringUtils.join(components, ";")); } String processInfo = JSON.toJSONString(processInfoMap); if (zookeeperClient.isExists("/ni/process/Alarm")) { zookeeperClient.writeData("/ni/process/Alarm", processInfo); } else { zookeeperClient.createNode("/ni", "", true); zookeeperClient.createNode("/ni/process", "", true); zookeeperClient.createNode("/ni/process/Alarm", "", false); zookeeperClient.writeData("/ni/process/Alarm", processInfo); } } }, 10, 60, TimeUnit.SECONDS); } static class MyComparator implements Serializable, Comparator<Long> { public MyComparator() { super(); } @Override public int compare(Long o1, Long o2) { return (int) (o2 - o1); } } static class ConnectStatus implements Serializable { private long newCreate; private long closeConn; private long activeConn; public ConnectStatus() { super(); } public long getNewCreate() { return newCreate; } public void setNewCreate(long newCreate) { this.newCreate = newCreate; } public long getCloseConn() { return closeConn; } public void setCloseConn(long closeConn) { this.closeConn = closeConn; } public long getActiveConn() { return activeConn; } public void setActiveConn(long activeConn) { this.activeConn = activeConn; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; ConnectStatus that = (ConnectStatus) o; if (newCreate != that.newCreate) return false; if (closeConn != that.closeConn) return false; if (activeConn != that.activeConn) return false; return true; } @Override public int hashCode() { int result = (int) (newCreate ^ (newCreate >>> 32)); result = 31 * result + (int) (closeConn ^ (closeConn >>> 32)); result = 31 * result + (int) (activeConn ^ (activeConn >>> 32)); return result; } @Override public String toString() { return "ConnectStatus{" + "newCreate=" + newCreate + ", closeConn=" + closeConn + ", activeConn=" + activeConn + '}'; } } static class TimeAgg implements Serializable { private static final long serialVersionUID = -3478231009579163625L; private String server_ip; //2 private String protocal_type; //13 private String client_site; //24 private String vlan_id; //4 private String subnet; //56 private String timestamp; private String timeEnd; private boolean hasSyn; private boolean bool_FIN; private boolean bool_RST; private String type; public TimeAgg() { super(); } public String getServer_ip() { return server_ip; } public void setServer_ip(String server_ip) { this.server_ip = server_ip; } public String getProtocal_type() { return protocal_type; } public void setProtocal_type(String protocal_type) { this.protocal_type = protocal_type; } public String getClient_site() { return client_site; } public void setClient_site(String client_site) { this.client_site = client_site; } public String getVlan_id() { return vlan_id; } public void setVlan_id(String vlan_id) { this.vlan_id = vlan_id; } public String getSubnet() { return subnet; } public void setSubnet(String subnet) { this.subnet = subnet; } public String getTimestamp() { return timestamp; } public void setTimestamp(String timestamp) { this.timestamp = timestamp; } public String getTimeEnd() { return timeEnd; } public void setTimeEnd(String timeEnd) { this.timeEnd = timeEnd; } public boolean isHasSyn() { return hasSyn; } public void setHasSyn(boolean hasSyn) { this.hasSyn = hasSyn; } public boolean isBool_FIN() { return bool_FIN; } public void setBool_FIN(boolean bool_FIN) { this.bool_FIN = bool_FIN; } public boolean isBool_RST() { return bool_RST; } public void setBool_RST(boolean bool_RST) { this.bool_RST = bool_RST; } public String getType() { return type; } public void setType(String type) { this.type = type; } @Override public String toString() { return "TimeAgg{" + "server_ip='" + server_ip + '\'' + ", protocal_type='" + protocal_type + '\'' + ", client_site='" + client_site + '\'' + ", vlan_id='" + vlan_id + '\'' + ", subnet='" + subnet + '\'' + ", timestamp='" + timestamp + '\'' + ", timeEnd='" + timeEnd + '\'' + ", hasSyn=" + hasSyn + ", bool_FIN=" + bool_FIN + ", bool_RST=" + bool_RST + ", type='" + type + '\'' + '}'; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; TimeAgg timeAgg = (TimeAgg) o; if (hasSyn != timeAgg.hasSyn) return false; if (bool_FIN != timeAgg.bool_FIN) return false; if (bool_RST != timeAgg.bool_RST) return false; if (server_ip != null ? !server_ip.equals(timeAgg.server_ip) : timeAgg.server_ip != null) return false; if (protocal_type != null ? !protocal_type.equals(timeAgg.protocal_type) : timeAgg.protocal_type != null) return false; if (client_site != null ? !client_site.equals(timeAgg.client_site) : timeAgg.client_site != null) return false; if (vlan_id != null ? !vlan_id.equals(timeAgg.vlan_id) : timeAgg.vlan_id != null) return false; if (subnet != null ? !subnet.equals(timeAgg.subnet) : timeAgg.subnet != null) return false; if (timestamp != null ? !timestamp.equals(timeAgg.timestamp) : timeAgg.timestamp != null) return false; if (timeEnd != null ? !timeEnd.equals(timeAgg.timeEnd) : timeAgg.timeEnd != null) return false; if (type != null ? !type.equals(timeAgg.type) : timeAgg.type != null) return false; return true; } @Override public int hashCode() { int result = server_ip != null ? server_ip.hashCode() : 0; result = 31 * result + (protocal_type != null ? protocal_type.hashCode() : 0); result = 31 * result + (client_site != null ? client_site.hashCode() : 0); result = 31 * result + (vlan_id != null ? vlan_id.hashCode() : 0); result = 31 * result + (subnet != null ? subnet.hashCode() : 0); result = 31 * result + (timestamp != null ? timestamp.hashCode() : 0); result = 31 * result + (timeEnd != null ? timeEnd.hashCode() : 0); result = 31 * result + (hasSyn ? 1 : 0); result = 31 * result + (bool_FIN ? 1 : 0); result = 31 * result + (bool_RST ? 1 : 0); result = 31 * result + (type != null ? type.hashCode() : 0); return result; } } static class BeforeAgg implements Serializable { private static final long serialVersionUID = 5799018864016955338L; private double packet_size; //56+55 private double c_packet_size; //55 private double s_packet_size; //56 private double packet_count; //60+59 private double c_packet_count; //59 private double s_packet_count; //60 private double losspacket_count; //33+39 private double total_rto; private int tcpTurns; // private double connrequest_count; //48 private int abort; private double rtt; private double client_rtt; private double server_rtt; private int clientJlRttCount; //client RTT:clientrtt count private int serverJlRttCount; //server RTT:serverrtt count private double server_reponsetime; private double c_bitpacket_account; // 57+58 private double responseTransmissionTime; private double requestTransmissionTime; private double userResponseTime; private int sAbortConnCount; private int sessionCount; private int count; private double int_ZWIN_COUNT; //? 43 private double int_OOR_COUNT; //? 46 private double int_CONGEST_COUNT; // 47 private double MTU; //MTU 61+62 public BeforeAgg() { super(); } public double getPacket_size() { return packet_size; } public void setPacket_size(double packet_size) { this.packet_size = packet_size; } public double getC_packet_size() { return c_packet_size; } public void setC_packet_size(double c_packet_size) { this.c_packet_size = c_packet_size; } public double getPacket_count() { return packet_count; } public void setPacket_count(double packet_count) { this.packet_count = packet_count; } public double getLosspacket_count() { return losspacket_count; } public void setLosspacket_count(double losspacket_count) { this.losspacket_count = losspacket_count; } public double getTotal_rto() { return total_rto; } public void setTotal_rto(double total_rto) { this.total_rto = total_rto; } public int getTcpTurns() { return tcpTurns; } public void setTcpTurns(int tcpTurns) { this.tcpTurns = tcpTurns; } public double getConnrequest_count() { return connrequest_count; } public void setConnrequest_count(double connrequest_count) { this.connrequest_count = connrequest_count; } public int getAbort() { return abort; } public void setAbort(int abort) { this.abort = abort; } public double getClient_rtt() { return client_rtt; } public void setClient_rtt(double client_rtt) { this.client_rtt = client_rtt; } public double getServer_rtt() { return server_rtt; } public void setServer_rtt(double server_rtt) { this.server_rtt = server_rtt; } public int getClientJlRttCount() { return clientJlRttCount; } public void setClientJlRttCount(int clientJlRttCount) { this.clientJlRttCount = clientJlRttCount; } public int getServerJlRttCount() { return serverJlRttCount; } public void setServerJlRttCount(int serverJlRttCount) { this.serverJlRttCount = serverJlRttCount; } public double getServer_reponsetime() { return server_reponsetime; } public void setServer_reponsetime(double server_reponsetime) { this.server_reponsetime = server_reponsetime; } public double getC_bitpacket_account() { return c_bitpacket_account; } public void setC_bitpacket_account(double c_bitpacket_account) { this.c_bitpacket_account = c_bitpacket_account; } public double getResponseTransmissionTime() { return responseTransmissionTime; } public void setResponseTransmissionTime(double responseTransmissionTime) { this.responseTransmissionTime = responseTransmissionTime; } public double getRequestTransmissionTime() { return requestTransmissionTime; } public void setRequestTransmissionTime(double requestTransmissionTime) { this.requestTransmissionTime = requestTransmissionTime; } public double getUserResponseTime() { return userResponseTime; } public void setUserResponseTime(double userResponseTime) { this.userResponseTime = userResponseTime; } public int getsAbortConnCount() { return sAbortConnCount; } public void setsAbortConnCount(int sAbortConnCount) { this.sAbortConnCount = sAbortConnCount; } public int getSessionCount() { return sessionCount; } public void setSessionCount(int sessionCount) { this.sessionCount = sessionCount; } public int getCount() { return count; } public void setCount(int count) { this.count = count; } public double getInt_ZWIN_COUNT() { return int_ZWIN_COUNT; } public void setInt_ZWIN_COUNT(double int_ZWIN_COUNT) { this.int_ZWIN_COUNT = int_ZWIN_COUNT; } public double getInt_OOR_COUNT() { return int_OOR_COUNT; } public void setInt_OOR_COUNT(double int_OOR_COUNT) { this.int_OOR_COUNT = int_OOR_COUNT; } public double getInt_CONGEST_COUNT() { return int_CONGEST_COUNT; } public void setInt_CONGEST_COUNT(double int_CONGEST_COUNT) { this.int_CONGEST_COUNT = int_CONGEST_COUNT; } public double getMTU() { return MTU; } public void setMTU(double MTU) { this.MTU = MTU; } public double getS_packet_size() { return s_packet_size; } public void setS_packet_size(double s_packet_size) { this.s_packet_size = s_packet_size; } public double getRtt() { return rtt; } public void setRtt(double rtt) { this.rtt = rtt; } public double getC_packet_count() { return c_packet_count; } public void setC_packet_count(double c_packet_count) { this.c_packet_count = c_packet_count; } public double getS_packet_count() { return s_packet_count; } public void setS_packet_count(double s_packet_count) { this.s_packet_count = s_packet_count; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; BeforeAgg beforeAgg = (BeforeAgg) o; if (Double.compare(beforeAgg.packet_size, packet_size) != 0) return false; if (Double.compare(beforeAgg.c_packet_size, c_packet_size) != 0) return false; if (Double.compare(beforeAgg.s_packet_size, s_packet_size) != 0) return false; if (Double.compare(beforeAgg.packet_count, packet_count) != 0) return false; if (Double.compare(beforeAgg.c_packet_count, c_packet_count) != 0) return false; if (Double.compare(beforeAgg.s_packet_count, s_packet_count) != 0) return false; if (Double.compare(beforeAgg.losspacket_count, losspacket_count) != 0) return false; if (Double.compare(beforeAgg.total_rto, total_rto) != 0) return false; if (tcpTurns != beforeAgg.tcpTurns) return false; if (Double.compare(beforeAgg.connrequest_count, connrequest_count) != 0) return false; if (abort != beforeAgg.abort) return false; if (Double.compare(beforeAgg.rtt, rtt) != 0) return false; if (Double.compare(beforeAgg.client_rtt, client_rtt) != 0) return false; if (Double.compare(beforeAgg.server_rtt, server_rtt) != 0) return false; if (clientJlRttCount != beforeAgg.clientJlRttCount) return false; if (serverJlRttCount != beforeAgg.serverJlRttCount) return false; if (Double.compare(beforeAgg.server_reponsetime, server_reponsetime) != 0) return false; if (Double.compare(beforeAgg.c_bitpacket_account, c_bitpacket_account) != 0) return false; if (Double.compare(beforeAgg.responseTransmissionTime, responseTransmissionTime) != 0) return false; if (Double.compare(beforeAgg.requestTransmissionTime, requestTransmissionTime) != 0) return false; if (Double.compare(beforeAgg.userResponseTime, userResponseTime) != 0) return false; if (sAbortConnCount != beforeAgg.sAbortConnCount) return false; if (sessionCount != beforeAgg.sessionCount) return false; if (count != beforeAgg.count) return false; if (Double.compare(beforeAgg.int_ZWIN_COUNT, int_ZWIN_COUNT) != 0) return false; if (Double.compare(beforeAgg.int_OOR_COUNT, int_OOR_COUNT) != 0) return false; if (Double.compare(beforeAgg.int_CONGEST_COUNT, int_CONGEST_COUNT) != 0) return false; if (Double.compare(beforeAgg.MTU, MTU) != 0) return false; return true; } @Override public int hashCode() { int result; long temp; temp = Double.doubleToLongBits(packet_size); result = (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(c_packet_size); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(s_packet_size); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(packet_count); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(c_packet_count); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(s_packet_count); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(losspacket_count); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(total_rto); result = 31 * result + (int) (temp ^ (temp >>> 32)); result = 31 * result + tcpTurns; temp = Double.doubleToLongBits(connrequest_count); result = 31 * result + (int) (temp ^ (temp >>> 32)); result = 31 * result + abort; temp = Double.doubleToLongBits(rtt); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(client_rtt); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(server_rtt); result = 31 * result + (int) (temp ^ (temp >>> 32)); result = 31 * result + clientJlRttCount; result = 31 * result + serverJlRttCount; temp = Double.doubleToLongBits(server_reponsetime); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(c_bitpacket_account); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(responseTransmissionTime); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(requestTransmissionTime); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(userResponseTime); result = 31 * result + (int) (temp ^ (temp >>> 32)); result = 31 * result + sAbortConnCount; result = 31 * result + sessionCount; result = 31 * result + count; temp = Double.doubleToLongBits(int_ZWIN_COUNT); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(int_OOR_COUNT); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(int_CONGEST_COUNT); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(MTU); result = 31 * result + (int) (temp ^ (temp >>> 32)); return result; } @Override public String toString() { return "BeforeAgg{" + "packet_size=" + packet_size + ", c_packet_size=" + c_packet_size + ", s_packet_size=" + s_packet_size + ", packet_count=" + packet_count + ", c_packet_count=" + c_packet_count + ", s_packet_count=" + s_packet_count + ", losspacket_count=" + losspacket_count + ", total_rto=" + total_rto + ", tcpTurns=" + tcpTurns + ", connrequest_count=" + connrequest_count + ", abort=" + abort + ", rtt=" + rtt + ", client_rtt=" + client_rtt + ", server_rtt=" + server_rtt + ", clientJlRttCount=" + clientJlRttCount + ", serverJlRttCount=" + serverJlRttCount + ", server_reponsetime=" + server_reponsetime + ", c_bitpacket_account=" + c_bitpacket_account + ", responseTransmissionTime=" + responseTransmissionTime + ", requestTransmissionTime=" + requestTransmissionTime + ", userResponseTime=" + userResponseTime + ", sAbortConnCount=" + sAbortConnCount + ", sessionCount=" + sessionCount + ", count=" + count + ", int_ZWIN_COUNT=" + int_ZWIN_COUNT + ", int_OOR_COUNT=" + int_OOR_COUNT + ", int_CONGEST_COUNT=" + int_CONGEST_COUNT + ", MTU=" + MTU + '}'; } } static class AggResult implements Serializable { private static final long serialVersionUID = -3168170970750233185L; private double throughput; // packet_size+*8/ 9 private double c_throughput; private double s_throughput; private double packetThroughput; //packet_count+/ 14 private double c_packetThroughput; private double s_packetThroughput; private double lossRate; //losspacket_count+ /packet_count+ 27/14 private double retransferTime; //total_rto+ 34 private double clientRoundTripTime; //client_rtt 57 private double serverRoundTripTime; //server_rtt 58 private double rtt; private double transmissionTime; private double userRespTime; //total_roundtime+ 37 private double serverRespTime; //server_reponsetime+ 61 private double connectFailedRate; //failedconnction_count+ /10s 50 /10s private double tryConnectPer; // connrequest_count+/(connrequest_count-failedconnction_count) 49 private double cBitpacketAccount; //c_bitpacket_account+/packet_count+ 64/9 private double abortConntionCount; //abortconntion_count/(connrequest_count-failedconnction_count) 51/ // private double unidirectionalTrafficPer; // c_packet_size+/packet_size+ 10/9 private String timestamp; private double congest_pre; private double zerowindow_pre; private double outoforder_pre; private double MTU_pre; public AggResult() { super(); } public double getThroughput() { return throughput; } public void setThroughput(double throughput) { this.throughput = throughput; } public double getPacketThroughput() { return packetThroughput; } public void setPacketThroughput(double packetThroughput) { this.packetThroughput = packetThroughput; } public double getLossRate() { return lossRate; } public void setLossRate(double lossRate) { this.lossRate = lossRate; } public double getRetransferTime() { return retransferTime; } public void setRetransferTime(double retransferTime) { this.retransferTime = retransferTime; } public double getClientRoundTripTime() { return clientRoundTripTime; } public void setClientRoundTripTime(double clientRoundTripTime) { this.clientRoundTripTime = clientRoundTripTime; } public double getServerRoundTripTime() { return serverRoundTripTime; } public void setServerRoundTripTime(double serverRoundTripTime) { this.serverRoundTripTime = serverRoundTripTime; } public double getUserRespTime() { return userRespTime; } public void setUserRespTime(double userRespTime) { this.userRespTime = userRespTime; } public double getServerRespTime() { return serverRespTime; } public void setServerRespTime(double serverRespTime) { this.serverRespTime = serverRespTime; } public double getConnectFailedRate() { return connectFailedRate; } public void setConnectFailedRate(double connectFailedRate) { this.connectFailedRate = connectFailedRate; } public double getTryConnectPer() { return tryConnectPer; } public void setTryConnectPer(double tryConnectPer) { this.tryConnectPer = tryConnectPer; } public double getcBitpacketAccount() { return cBitpacketAccount; } public void setcBitpacketAccount(double cBitpacketAccount) { this.cBitpacketAccount = cBitpacketAccount; } public double getAbortConntionCount() { return abortConntionCount; } public void setAbortConntionCount(double abortConntionCount) { this.abortConntionCount = abortConntionCount; } public String getTimestamp() { return timestamp; } public void setTimestamp(String timestamp) { this.timestamp = timestamp; } public double getCongest_pre() { return congest_pre; } public void setCongest_pre(double congest_pre) { this.congest_pre = congest_pre; } public double getZerowindow_pre() { return zerowindow_pre; } public void setZerowindow_pre(double zerowindow_pre) { this.zerowindow_pre = zerowindow_pre; } public double getOutoforder_pre() { return outoforder_pre; } public void setOutoforder_pre(double outoforder_pre) { this.outoforder_pre = outoforder_pre; } public double getMTU_pre() { return MTU_pre; } public void setMTU_pre(double MTU_pre) { this.MTU_pre = MTU_pre; } public double getC_throughput() { return c_throughput; } public void setC_throughput(double c_throughput) { this.c_throughput = c_throughput; } public double getS_throughput() { return s_throughput; } public void setS_throughput(double s_throughput) { this.s_throughput = s_throughput; } public double getRtt() { return rtt; } public void setRtt(double rtt) { this.rtt = rtt; } public double getTransmissionTime() { return transmissionTime; } public void setTransmissionTime(double transmissionTime) { this.transmissionTime = transmissionTime; } public double getC_packetThroughput() { return c_packetThroughput; } public void setC_packetThroughput(double c_packetThroughput) { this.c_packetThroughput = c_packetThroughput; } public double getS_packetThroughput() { return s_packetThroughput; } public void setS_packetThroughput(double s_packetThroughput) { this.s_packetThroughput = s_packetThroughput; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; AggResult aggResult = (AggResult) o; if (Double.compare(aggResult.throughput, throughput) != 0) return false; if (Double.compare(aggResult.c_throughput, c_throughput) != 0) return false; if (Double.compare(aggResult.s_throughput, s_throughput) != 0) return false; if (Double.compare(aggResult.packetThroughput, packetThroughput) != 0) return false; if (Double.compare(aggResult.c_packetThroughput, c_packetThroughput) != 0) return false; if (Double.compare(aggResult.s_packetThroughput, s_packetThroughput) != 0) return false; if (Double.compare(aggResult.lossRate, lossRate) != 0) return false; if (Double.compare(aggResult.retransferTime, retransferTime) != 0) return false; if (Double.compare(aggResult.clientRoundTripTime, clientRoundTripTime) != 0) return false; if (Double.compare(aggResult.serverRoundTripTime, serverRoundTripTime) != 0) return false; if (Double.compare(aggResult.rtt, rtt) != 0) return false; if (Double.compare(aggResult.transmissionTime, transmissionTime) != 0) return false; if (Double.compare(aggResult.userRespTime, userRespTime) != 0) return false; if (Double.compare(aggResult.serverRespTime, serverRespTime) != 0) return false; if (Double.compare(aggResult.connectFailedRate, connectFailedRate) != 0) return false; if (Double.compare(aggResult.tryConnectPer, tryConnectPer) != 0) return false; if (Double.compare(aggResult.cBitpacketAccount, cBitpacketAccount) != 0) return false; if (Double.compare(aggResult.abortConntionCount, abortConntionCount) != 0) return false; if (Double.compare(aggResult.congest_pre, congest_pre) != 0) return false; if (Double.compare(aggResult.zerowindow_pre, zerowindow_pre) != 0) return false; if (Double.compare(aggResult.outoforder_pre, outoforder_pre) != 0) return false; if (Double.compare(aggResult.MTU_pre, MTU_pre) != 0) return false; if (timestamp != null ? !timestamp.equals(aggResult.timestamp) : aggResult.timestamp != null) return false; return true; } @Override public int hashCode() { int result; long temp; temp = Double.doubleToLongBits(throughput); result = (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(c_throughput); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(s_throughput); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(packetThroughput); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(c_packetThroughput); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(s_packetThroughput); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(lossRate); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(retransferTime); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(clientRoundTripTime); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(serverRoundTripTime); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(rtt); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(transmissionTime); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(userRespTime); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(serverRespTime); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(connectFailedRate); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(tryConnectPer); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(cBitpacketAccount); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(abortConntionCount); result = 31 * result + (int) (temp ^ (temp >>> 32)); result = 31 * result + (timestamp != null ? timestamp.hashCode() : 0); temp = Double.doubleToLongBits(congest_pre); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(zerowindow_pre); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(outoforder_pre); result = 31 * result + (int) (temp ^ (temp >>> 32)); temp = Double.doubleToLongBits(MTU_pre); result = 31 * result + (int) (temp ^ (temp >>> 32)); return result; } @Override public String toString() { return "AggResult{" + "throughput=" + throughput + ", c_throughput=" + c_throughput + ", s_throughput=" + s_throughput + ", packetThroughput=" + packetThroughput + ", c_packetThroughput=" + c_packetThroughput + ", s_packetThroughput=" + s_packetThroughput + ", lossRate=" + lossRate + ", retransferTime=" + retransferTime + ", clientRoundTripTime=" + clientRoundTripTime + ", serverRoundTripTime=" + serverRoundTripTime + ", rtt=" + rtt + ", transmissionTime=" + transmissionTime + ", userRespTime=" + userRespTime + ", serverRespTime=" + serverRespTime + ", connectFailedRate=" + connectFailedRate + ", tryConnectPer=" + tryConnectPer + ", cBitpacketAccount=" + cBitpacketAccount + ", abortConntionCount=" + abortConntionCount + ", timestamp='" + timestamp + '\'' + ", congest_pre=" + congest_pre + ", zerowindow_pre=" + zerowindow_pre + ", outoforder_pre=" + outoforder_pre + ", MTU_pre=" + MTU_pre + '}'; } } }