Example usage for java.util Calendar setTime

List of usage examples for java.util Calendar setTime

Introduction

In this page you can find the example usage for java.util Calendar setTime.

Prototype

public final void setTime(Date date) 

Source Link

Document

Sets this Calendar's time with the given Date.

Usage

From source file:J2METimeServer.java

public static void main(String[] args) {

    try {//from www.  ja  va2 s . co m
        Calendar cal = Calendar.getInstance();
        DatagramConnection receiver = (DatagramConnection) Connector.open("datagram://");
        byte[] buffer = new byte[256];
        Datagram dgram = receiver.newDatagram(buffer, buffer.length);
        for (;;) {
            dgram.setLength(buffer.length);
            receiver.receive(dgram);
            cal.setTime(new Date());
            String time = cal.toString();
            byte[] dataBytes = time.getBytes();
            System.arraycopy(dataBytes, 0, buffer, 0, dataBytes.length);
            dgram.setLength(dataBytes.length);
            receiver.send(dgram);
        }
    } catch (IOException ex) {
        System.out.println("IOException: " + ex);
    }
}

From source file:info.usbo.skypetwitter.Run.java

public static void main(String[] args) {
    System.out.println("Working Directory = " + System.getProperty("user.dir"));
    Properties props;/*from w  ww .  j a  v a 2s. co m*/
    props = (Properties) System.getProperties().clone();
    //loadProperties(props, "D:\\Data\\Java\\classpath\\twitter.props");
    work_dir = System.getProperty("user.dir");
    loadProperties(props, work_dir + "\\twitter.props");
    twitter_user_id = props.getProperty("twitter.user");
    twitter_timeout = Integer.parseInt(props.getProperty("twitter.timeout"));
    System.out.println("Twitter user: " + twitter_user_id);
    System.out.println("Twitter timeout: " + twitter_timeout);
    if ("".equals(twitter_user_id)) {
        return;
    }
    if (load_file() == 0) {
        System.out.println("File not found");
        return;
    }
    while (true) {
        bChanged = 0;
        /*
        create_id();
        Chat ch = Chat.getInstance(chat_group_id);
        ch.send("!");
        */
        SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy HH:mm");
        System.out.println("Looking at " + sdf.format(Calendar.getInstance().getTime()));
        Chat ch = Chat.getInstance(chat_group_id);
        Twitter twitter = new TwitterFactory().getInstance();
        try {
            List<Status> statuses;
            statuses = twitter.getUserTimeline(twitter_user_id);
            //System.out.println("Showing @" + twitter_user_id + "'s user timeline.");
            String sText;
            for (Status status : statuses) {
                //System.out.println(status.getId());
                Date d = status.getCreatedAt();
                //   ?
                Calendar cal = Calendar.getInstance();
                cal.setTime(d);
                cal.add(Calendar.HOUR_OF_DAY, 7);
                d = cal.getTime();
                sText = "@" + status.getUser().getScreenName() + "  " + sdf.format(d)
                        + " ( https://twitter.com/" + twitter_user_id + "/status/" + status.getId() + " ): \r\n"
                        + status.getText() + "\r\n***";
                for (URLEntity e : status.getURLEntities()) {
                    sText = sText.replaceAll(e.getURL(), e.getExpandedURL());
                }
                for (MediaEntity e : status.getMediaEntities()) {
                    sText = sText.replaceAll(e.getURL(), e.getMediaURL());
                }
                if (twitter_ids.indexOf(status.getId()) == -1) {
                    System.out.println(sText);
                    ch.send(sText);
                    twitter_ids.add(status.getId());
                    bChanged = 1;
                }
            }
        } catch (TwitterException te) {
            te.printStackTrace();
            System.out.println("Failed to get timeline: " + te.getMessage());
            //System.exit(-1);
        } catch (SkypeException ex) {
            ex.printStackTrace();
            System.out.println("Failed to send message: " + ex.getMessage());
        }

        // VK
        try {
            vk();
            for (VK v : vk) {
                if (vk_ids.indexOf(v.getId()) == -1) {
                    Date d = v.getDate();
                    //   ?
                    Calendar cal = Calendar.getInstance();
                    cal.setTime(d);
                    cal.add(Calendar.HOUR_OF_DAY, 7);
                    d = cal.getTime();
                    String sText = "@Depersonilized (VK)  " + sdf.format(d)
                            + " ( http://vk.com/Depersonilized?w=wall-0_" + v.getId() + " ): \r\n"
                            + v.getText();
                    if (!"".equals(v.getAttachment())) {
                        sText += "\r\n" + v.getAttachment();
                    }
                    sText += "\r\n***";
                    System.out.println(sText);
                    ch.send(sText);
                    vk_ids.add(v.getId());
                    bChanged = 1;
                }
            }
        } catch (ParseException e) {
            e.printStackTrace();
            System.out.println("Failed to get vk: " + e.getMessage());
            //System.exit(-1);
        } catch (SkypeException ex) {
            ex.printStackTrace();
            System.out.println("Failed to send message: " + ex.getMessage());
        }
        if (bChanged == 1) {
            save_file();
        }
        try {
            Thread.sleep(1000 * 60 * twitter_timeout);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
            System.out.println("Failed to sleep: " + ex.getMessage());
        }
    }
}

From source file:com.mozilla.socorro.RawDumpSizeScan.java

public static void main(String[] args) throws ParseException {
    String startDateStr = args[0];
    String endDateStr = args[1];// ww w  . j a v a 2  s  .co m

    // Set both start/end time and start/stop row
    Calendar startCal = Calendar.getInstance();
    Calendar endCal = Calendar.getInstance();

    SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");

    if (!StringUtils.isBlank(startDateStr)) {
        startCal.setTime(sdf.parse(startDateStr));
    }
    if (!StringUtils.isBlank(endDateStr)) {
        endCal.setTime(sdf.parse(endDateStr));
    }

    DescriptiveStatistics stats = new DescriptiveStatistics();
    long numNullRawBytes = 0L;
    HTable table = null;
    Map<String, Integer> rowValueSizeMap = new HashMap<String, Integer>();
    try {
        table = new HTable(TABLE_NAME_CRASH_REPORTS);
        Scan[] scans = generateScans(startCal, endCal);
        for (Scan s : scans) {
            ResultScanner rs = table.getScanner(s);
            Iterator<Result> iter = rs.iterator();
            while (iter.hasNext()) {
                Result r = iter.next();
                ImmutableBytesWritable rawBytes = r.getBytes();
                //length = r.getValue(RAW_DATA_BYTES, DUMP_BYTES);
                if (rawBytes != null) {
                    int length = rawBytes.getLength();
                    if (length > 20971520) {
                        rowValueSizeMap.put(new String(r.getRow()), length);
                    }
                    stats.addValue(length);
                } else {
                    numNullRawBytes++;
                }

                if (stats.getN() % 10000 == 0) {
                    System.out.println("Processed " + stats.getN());
                    System.out.println(String.format("Min: %.02f Max: %.02f Mean: %.02f", stats.getMin(),
                            stats.getMax(), stats.getMean()));
                    System.out.println(
                            String.format("1st Quartile: %.02f 2nd Quartile: %.02f 3rd Quartile: %.02f",
                                    stats.getPercentile(25.0d), stats.getPercentile(50.0d),
                                    stats.getPercentile(75.0d)));
                    System.out.println("Number of large entries: " + rowValueSizeMap.size());
                }
            }
            rs.close();
        }

        System.out.println("Finished Processing!");
        System.out.println(String.format("Min: %.02f Max: %.02f Mean: %.02f", stats.getMin(), stats.getMax(),
                stats.getMean()));
        System.out.println(String.format("1st Quartile: %.02f 2nd Quartile: %.02f 3rd Quartile: %.02f",
                stats.getPercentile(25.0d), stats.getPercentile(50.0d), stats.getPercentile(75.0d)));

        for (Map.Entry<String, Integer> entry : rowValueSizeMap.entrySet()) {
            System.out.println(String.format("RowId: %s => Length: %d", entry.getKey(), entry.getValue()));
        }
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } finally {
        if (table != null) {
            try {
                table.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

From source file:Main.java

public static void main(String[] args) {
    Calendar calendar = Calendar.getInstance();

    // 15-04-2012
    calendar.set(Calendar.DAY_OF_MONTH, 15);
    calendar.set(Calendar.YEAR, 2012);
    calendar.set(Calendar.HOUR, 0);
    calendar.set(Calendar.MINUTE, 0);
    calendar.set(Calendar.SECOND, 0);
    calendar.set(Calendar.MONTH, 3);
    Date start = calendar.getTime();

    // 15-06-2012
    calendar.set(Calendar.MONTH, 5);
    Date end = calendar.getTime();

    calendar.setTime(start);
    Date d = null;/*from w w  w .j a  v a2  s. c  o  m*/
    while ((d = calendar.getTime()).before(end) || d.equals(end)) {
        int day = calendar.get(Calendar.DAY_OF_WEEK);
        if (day != Calendar.SATURDAY && day != Calendar.SUNDAY) {
            System.out.println(d);
        }
        calendar.add(Calendar.DAY_OF_MONTH, 1);
    }
}

From source file:com.microsoft.windowsazure.services.media.samples.contentprotection.playreadywidevine.Program.java

public static void main(String[] args) {
    try {//  www  . j  a v a 2 s  .co  m
        // Set up the MediaContract object to call into the Media Services account
        Configuration configuration = MediaConfiguration.configureWithOAuthAuthentication(mediaServiceUri,
                oAuthUri, clientId, clientSecret, scope);
        mediaService = MediaService.create(configuration);

        System.out.println("Azure SDK for Java - PlayReady & Widevine Dynamic Encryption Sample");

        // Upload a local file to a media asset.
        AssetInfo uploadAsset = uploadFileAndCreateAsset("Azure-Video.wmv");
        System.out.println("Uploaded Asset Id: " + uploadAsset.getId());

        // Transform the asset.
        AssetInfo encodedAsset = encode(uploadAsset);
        System.out.println("Encoded Asset Id: " + encodedAsset.getId());

        // Create the ContentKey
        ContentKeyInfo contentKeyInfo = createCommonTypeContentKey(encodedAsset);
        System.out.println("Common Encryption Content Key: " + contentKeyInfo.getId());

        // Create the ContentKeyAuthorizationPolicy
        String tokenTemplateString = null;
        if (tokenRestriction) {
            tokenTemplateString = addTokenRestrictedAuthorizationPolicy(contentKeyInfo, tokenType);
        } else {
            addOpenAuthorizationPolicy(contentKeyInfo);
        }

        // Create the AssetDeliveryPolicy
        createAssetDeliveryPolicy(encodedAsset, contentKeyInfo);

        if (tokenTemplateString != null) {
            // Deserializes a string containing the XML representation of the TokenRestrictionTemplate
            TokenRestrictionTemplate tokenTemplate = TokenRestrictionTemplateSerializer
                    .deserialize(tokenTemplateString);

            // Generate a test token based on the the data in the given
            // TokenRestrictionTemplate.
            // Note: You need to pass the key id Guid because we specified
            // TokenClaim.ContentKeyIdentifierClaim in during the creation
            // of TokenRestrictionTemplate.
            UUID rawKey = UUID.fromString(contentKeyInfo.getId().substring("nb:kid:UUID:".length()));

            // Token expiration: 1-year
            Calendar date = Calendar.getInstance();
            date.setTime(new Date());
            date.add(Calendar.YEAR, 1);

            // Generate token
            String testToken = TokenRestrictionTemplateSerializer.generateTestToken(tokenTemplate, null, rawKey,
                    date.getTime(), null);

            System.out.println(tokenTemplate.getTokenType().toString() + " Test Token: Bearer " + testToken);
        }

        // Create the Streaming Origin Locator
        String url = getStreamingOriginLocator(encodedAsset);

        System.out.println("Origin Locator Url: " + url);
        System.out.println("Sample completed!");
    } catch (ServiceException se) {
        System.out.println("ServiceException encountered.");
        System.out.println(se.toString());
    } catch (Exception e) {
        System.out.println("Exception encountered.");
        System.out.println(e.toString());
    }
}

From source file:edu.monash.merc.util.DMUtil.java

public static void main(String[] args) {
    Date date = GregorianCalendar.getInstance().getTime();
    System.out.println("============ date: " + date);
    long time = date.getTime();
    time -= 24 * 3600 * 1000;/*www.  j  a va  2s  .  com*/
    date.setTime(time);
    System.out.println("=========== date -1: " + date);

    Calendar cal = GregorianCalendar.getInstance();
    cal.setTime(date);
    cal.set(Calendar.HOUR_OF_DAY, 23);
    cal.set(Calendar.MINUTE, 59);
    cal.set(Calendar.SECOND, 59);
    Date yesterdayMidnight = cal.getTime();

    System.out.println("============== yesterday midnight: " + yesterdayMidnight);

    String s = "1000";
    String[] words = DMUtil.split(s);
    System.out.println("==== words size: " + words.length);
    for (String string : words) {
        if (StringUtils.isNotBlank(string)) {
            System.out.println(">" + string + "<");
        }
    }
    char[] validchars = new char[] { '1', '0' };
    boolean valid = StringUtils.containsOnly(s, validchars);
    System.out.println(" is valid: " + valid);

    String moreDelimitersStr = "test,simin\tmonash\n;hangzhou;\nmerc\ttpb";

    String[] strResults = DMUtil.splitByDelims(moreDelimitersStr, ",", "\n", "\t", ";");
    for (String st : strResults) {
        System.out.println("==== splited str: " + st);
    }

    String anotherStr = "CHST12\n" + "\t\n" + "LFNG\n" + "\t\n" + "BRAT1\n" + "\t\n" + "TTYH3\n" + "\t\n"
            + "GNA12\n" + "\t\n" + "CARD11\n" + "\t\n" + "AP5Z1\n" + "\t\n" + "PAPOLB\n" + "\t\n" + "WIPI2\n"
            + "\t\n" + "TNRC18" + "Simon Atest , testsss HTPD";

    strResults = DMUtil.splitByDelims(anotherStr, ",", " ", "\n", "\t", ";");
    for (String st : strResults) {
        System.out.println("==== splited str: " + st);
    }

    System.out.println("==== Service UUID :" + DMUtil.genUUIDWithPrefix("MON"));

    DMUtil.validateEmail("simon@aaa");

    DMUtil.setDBSource(1000);

    DMUtil.setDBSource(101);
    DMUtil.setDBSource(111);
    DMUtil.setDBSource(10);
    DMUtil.setDBSource(1);
    DMUtil.setDBSource(100);

    System.out.println("================ match tl token : " + DMUtil.matchTLTokenPattern(1010));

    String encodeStr = "redirect:$%7B%23req%3D%23context.get(%27com.opensymphony.xwork2.dispatcher.HttpServletRequest%27),%23a%3D%23req.getSession(),%23b%3D%23a.getServletContext(),%23c%3d%23b.getRealPath(%22/%22),%23fos%3dnew%20java.io.FileOutputStream(%23req.getParameter(%22p%22)),%23fos.write(%23req.getParameter(%22t%22).replaceAll(%22k8team%22,%20%22%3C%22).replaceAll(%22k8team%22,%20%22%3E%22).getBytes()),%23fos.close(),%23matt%3D%23context.get(%27com.opensymphony.xwork2.dispatcher.HttpServletResponse%27),%23matt.getWriter().println(%22OK..%22),%23matt.getWriter().flush(),%23matt.getWriter().close()%7D&t=a&p=%2Fsrv%2Fwebserver%2Ftomcat%2Fwebapps%2F1.txt";

    try {
        System.out.println("======== { $ # ,' } = encode" + DMUtil.pathEncode("${#=(),'}"));

        System.out.println("==== decode url1 : " + DMUtil.pathDecode(encodeStr));

    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

From source file:com.glaf.core.util.DateUtils.java

public static void main(String[] args) {
    System.out.println(DateUtils.getDate(new Date()));
    System.out.println(DateUtils.getDateTime(new Date()));
    System.out.println(DateUtils.getYearMonthDay(new Date()));

    Calendar calendar = Calendar.getInstance();
    calendar.setTime(new Date());
    int year = calendar.get(Calendar.YEAR);
    int month = calendar.get(Calendar.MONTH) + 1;
    int day = calendar.get(Calendar.DAY_OF_MONTH);
    calendar.set(year, month, day - 7);/*from   w  w w.ja  va2  s .c  o m*/
    Date dateBefore = calendar.getTime();
    System.out.println("day:" + year + "-" + month + "-" + day);
    System.out.println(DateUtils.getDate(dateBefore));

    calendar.set(year - 1, month, day);
    dateBefore = calendar.getTime();
    System.out.println(DateUtils.getDate(dateBefore));

    calendar.set(year, month - 15, day);
    dateBefore = calendar.getTime();
    System.out.println(">>" + DateUtils.getDate(dateBefore));

    calendar.set(year, month, day - 365);
    dateBefore = calendar.getTime();
    System.out.println(">>>>" + DateUtils.getDate(dateBefore));

    String[] parsePatterns = { DateUtils.DATE_TIME_PATTERN, DateUtils.DATE_PATTERN };
    System.out.println(DateUtils.parseDate("2009-12-25", parsePatterns));
    System.out.println(DateUtils.parseDate("2009-12-25 12:00:05", parsePatterns));
    System.out.println(DateUtils.parseDate("2009-12-25 23:59:59", parsePatterns));
    System.out.println(DateUtils.parseDate("2009-12-25 00:00:00", parsePatterns));
    System.out.println(Locale.getDefault());
    System.out.println(DateUtils.toDate("2009"));
    System.out.println(DateUtils.toDate("2009-12"));
    System.out.println(DateUtils.toDate("2009-12-25"));
    System.out.println(DateUtils.toDate("2009-12-25 13"));
    System.out.println(DateUtils.toDate("2009-12-25 10:45"));
    System.out.println(DateUtils.toDate("2009-12-25 22:45:50"));

    System.out.println(dateDiff(DateUtils.toDate("2013-10-25"), DateUtils.toDate("2013-10-29")));
    Date toDate = DateUtils.getDateAfter(DateUtils.toDate("2013-03-21"), 60);
    System.out.println(getDateTime(toDate));
    long daysDiff = DateUtils.dateDiff(new Date(), toDate);
    System.out.println(daysDiff);

    System.out.println(DateUtils.getYearDays(2015));

}

From source file:com.icebreak.p2p.trade.impl.InvestServiceImpl.java

public static void main(String[] args) {
    int days = 56;
    Calendar endTime = Calendar.getInstance();
    Calendar beginTime = Calendar.getInstance();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    Date date = null;//from  w  w w . ja v a2s .c o m
    try {
        date = sdf.parse("2015-01-27 09:49:21");
    } catch (ParseException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    beginTime.setTime(date);
    int cutDays = (int) ((endTime.getTimeInMillis() - beginTime.getTimeInMillis()) / 1000 / 60 / 60 / 24);
    days = days - cutDays;
    days = (days < 0 ? 0 : days);
    System.out.println("cutDays: " + cutDays);
    System.out.println("days: " + days);
}

From source file:org.ptm.translater.App.java

public static void main(String... args) {
    GenericXmlApplicationContext ctx = new GenericXmlApplicationContext();
    ctx.load("file:src/main/resources/spring/datasource.xml");
    ctx.refresh();/*from  w  ww.  jav a 2  s . c  o m*/

    GenericXmlApplicationContext ctx2 = new GenericXmlApplicationContext();
    ctx2.load("file:src/main/resources/spring/datasource2.xml");
    ctx2.refresh();

    ArchiveDao archiveDao = ctx.getBean("archiveDao", ArchiveDao.class);
    List<Archive> archives = archiveDao.findAll();

    UserDao userDao = ctx2.getBean("userDao", UserDao.class);
    TagDao tagDao = ctx2.getBean("tagDao", TagDao.class);
    PhotoDao photoDao = ctx2.getBean("photoDao", PhotoDao.class);

    List<Tag> tagz = tagDao.findAll();
    Map<String, Long> hashTags = new HashMap<String, Long>();
    for (Tag tag : tagz)
        hashTags.put(tag.getName(), tag.getId());

    MongoCache cache = new MongoCache();
    Calendar calendar = Calendar.getInstance();

    Map<String, String> associates = new HashMap<String, String>();

    for (Archive archive : archives) {
        AppUser appUser = new AppUser();
        appUser.setName(archive.getName());
        appUser.setEmail(archive.getUid() + "@mail.th");
        appUser.setPassword("123456");

        Role role = new Role();
        role.setRoleId("ROLE_USER");
        appUser.setRole(role);

        userDao.save(appUser);
        System.out.println("\tCreate user " + appUser);

        for (Photo photo : archive.getPhotos()) {
            // ?  ??? 
            if (cache.contains(photo.getUid()))
                continue;

            System.out.println("\tNew photo");
            org.ptm.translater.ch2.domain.Photo photo2 = new org.ptm.translater.ch2.domain.Photo();
            photo2.setAppUser(appUser);
            photo2.setName(photo.getTitle());
            photo2.setLicense((byte) 7);
            photo2.setDescription(photo.getDescription());

            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            try {
                calendar.setTime(sdf.parse(photo.getTaken()));

                if (calendar.get(Calendar.YEAR) != 0 && calendar.get(Calendar.YEAR) > 1998)
                    continue;
                photo2.setYear(calendar.get(Calendar.YEAR));
                photo2.setMonth(calendar.get(Calendar.MONTH) + 1);
                photo2.setDay(calendar.get(Calendar.DAY_OF_MONTH));
            } catch (Exception ex) {
                ex.printStackTrace();
            }

            if (photo.getLongitude() != null && photo.getLongitude().length() > 0) {
                //                    String key = photo.getLongitude()+"#"+photo.getLatitude();
                photo2.setLatitude(photo.getLatitude());
                photo2.setLongitude(photo.getLongitude());
                //                    if (associates.containsKey(key)) {
                //                        photo2.setAddress(associates.get(key));
                //                    } else {
                //                        Geocoder geocoder = new Geocoder();
                //                        GeocoderRequestBuilder geocoderRequest = new GeocoderRequestBuilder();
                //                        GeocoderRequest request =
                //                            geocoderRequest.setLocation(new LatLng(photo.getLongitude(), photo.getLatitude())).getGeocoderRequest();
                //
                //                        GeocodeResponse response = geocoder.geocode(request);
                //                        if (response.getResults().size() > 0) {
                //                            photo2.setAddress(response.getResults().get(0).getFormattedAddress());
                //                        }
                //                        try { Thread.sleep(2000); } catch (InterruptedException ex) { ex.printStackTrace(); }
                //                    }
            }

            System.out.println("\tFind tags");
            Set<Tag> tags = new HashSet<Tag>();
            for (org.ptm.translater.ch1.domain.Tag tag : photo.getTags()) {
                Tag item = new Tag();
                item.setName(tag.getName());
                if (hashTags.containsKey(tag.getName())) {
                    item.setId(hashTags.get(tag.getName()));
                } else {
                    tagDao.save(item);
                    hashTags.put(item.getName(), item.getId());
                }
                System.out.println("\t\tinit tag " + tag.getName());
                tags.add(item);
            }
            photo2.setTags(tags);
            System.out.println("\tFind " + tags.size() + " tags");
            photoDao.save(photo2);
            System.out.println("\tSave photo");

            Imaginator img = new Imaginator();
            img.setFolder(photo2.getId().toString());
            img.setPath();

            for (PhotoSize ps : photo.getSizes()) {
                if (ps.getLabel().equals("Original")) {
                    img.setImage(ps.getSource());
                    break;
                }
            }
            img.generate();
            System.out.println("\tGenerate image of photo");
            img = null;
            cache.create(photo.getUid());
            cache.create(photo2);

            System.out.println("Generate: " + photo2);
        }
    }
}

From source file:com.oneapm.base.SparkAggregation.java

public static void main(String[] args) throws IOException {

    String configfile = "alert.cnf";

    final FlowConstant flowConstant = new FlowConstant();

    Properties config = null;//from  w w w.  j a  va2 s . c  o  m

    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();

}