Example usage for java.lang String split

Introduction

In this page you can find the example usage for java.lang String split.

Prototype

public String[] split(String regex, int limit) 

Source Link

Document

Splits this string around matches of the given regular expression.

Usage

From source file:com.termmed.sampling.ConceptsWithMoreThanThreeRoleGroups.java

/**
 * The main method.//  w  w w . j a v  a 2 s .  c o m
 *
 * @param args the arguments
 * @throws Exception the exception
 */
public static void main(String[] args) throws Exception {
    System.out.println("Starting...");
    Map<String, Set<String>> groupsMap = new HashMap<String, Set<String>>();
    File relsFile = new File(
            "/Users/alo/Downloads/SnomedCT_RF2Release_INT_20160131-1/Snapshot/Terminology/sct2_Relationship_Snapshot_INT_20160131.txt");
    BufferedReader br2 = new BufferedReader(new FileReader(relsFile));
    String line2;
    int count2 = 0;
    while ((line2 = br2.readLine()) != null) {
        // process the line.
        count2++;
        if (count2 % 10000 == 0) {
            //System.out.println(count2);
        }
        List<String> columns = Arrays.asList(line2.split("\t", -1));
        if (columns.size() >= 6) {
            if (columns.get(2).equals("1") && !columns.get(6).equals("0")) {
                if (!groupsMap.containsKey(columns.get(4))) {
                    groupsMap.put(columns.get(4), new HashSet<String>());
                }
                groupsMap.get(columns.get(4)).add(columns.get(6));
            }
        }
    }
    System.out.println("Relationship groups loaded");
    Gson gson = new Gson();
    System.out.println("Reading JSON 1");
    File crossoverFile1 = new File("/Users/alo/Downloads/crossover_role_to_group.json");
    String contents = FileUtils.readFileToString(crossoverFile1, "utf-8");
    Type collectionType = new TypeToken<Collection<ControlResultLine>>() {
    }.getType();
    List<ControlResultLine> lineObject = gson.fromJson(contents, collectionType);
    Set<String> crossovers1 = new HashSet<String>();
    for (ControlResultLine loopResult : lineObject) {
        crossovers1.add(loopResult.conceptId);
    }
    System.out.println("Crossovers 1 loaded, " + lineObject.size() + " Objects");

    System.out.println("Reading JSON 2");
    File crossoverFile2 = new File("/Users/alo/Downloads/crossover_group_to_group.json");
    String contents2 = FileUtils.readFileToString(crossoverFile2, "utf-8");
    List<ControlResultLine> lineObject2 = gson.fromJson(contents2, collectionType);
    Set<String> crossovers2 = new HashSet<String>();
    for (ControlResultLine loopResult : lineObject2) {
        crossovers2.add(loopResult.conceptId);
    }
    System.out.println("Crossovers 2 loaded, " + lineObject2.size() + " Objects");

    Set<String> foundConcepts = new HashSet<String>();
    int count3 = 0;
    BufferedWriter writer = new BufferedWriter(
            new FileWriter(new File("ConceptsWithMoreThanThreeRoleGroups.csv")));
    ;
    for (String loopConcept : groupsMap.keySet()) {
        if (groupsMap.get(loopConcept).size() > 3) {
            writer.write(loopConcept);
            writer.newLine();
            foundConcepts.add(loopConcept);
            count3++;
        }
    }
    writer.close();
    System.out.println("Found " + foundConcepts.size() + " concepts");

    int countCrossover1 = 0;
    for (String loopConcept : foundConcepts) {
        if (crossovers1.contains(loopConcept)) {
            countCrossover1++;
        }
    }
    System.out.println(countCrossover1 + " are present in crossover_role_to_group");

    int countCrossover2 = 0;
    for (String loopConcept : foundConcepts) {
        if (crossovers2.contains(loopConcept)) {
            countCrossover2++;
        }
    }
    System.out.println(countCrossover2 + " are present in crossover_group_to_group");

    System.out.println("Done");
}

---

From source file:com.searchcode.app.App.java

public static void main(String[] args) {
    injector = Guice.createInjector(new InjectorConfig());
    int server_port = Helpers.tryParseInt(
            Properties.getProperties().getProperty(Values.SERVERPORT, Values.DEFAULTSERVERPORT),
            Values.DEFAULTSERVERPORT);/*from   ww w.j a  v a  2s .  c om*/
    boolean onlyLocalhost = Boolean
            .parseBoolean(Properties.getProperties().getProperty("only_localhost", "false"));

    // Database migrations happen before we start
    databaseMigrations();

    LOGGER.info("Starting searchcode server on port " + server_port);
    Spark.port(server_port);

    JobService js = injector.getInstance(JobService.class);
    Repo repo = injector.getInstance(Repo.class);
    Data data = injector.getInstance(Data.class);
    Api api = injector.getInstance(Api.class);

    ApiService apiService = injector.getInstance(ApiService.class);
    StatsService statsService = new StatsService();

    scl = Singleton.getSearchcodeLib(data);
    js.initialJobs();

    Gson gson = new Gson();

    Spark.staticFileLocation("/public");

    before((request, response) -> {
        if (onlyLocalhost) {
            if (!request.ip().equals("127.0.0.1")) {
                halt(204);
            }
        }
    });

    get("/", (req, res) -> {
        Map<String, Object> map = new HashMap<>();

        map.put("repoCount", repo.getRepoCount());

        if (req.queryParams().contains("q") && !req.queryParams("q").trim().equals("")) {
            String query = req.queryParams("q").trim();
            int page = 0;

            if (req.queryParams().contains("p")) {
                try {
                    page = Integer.parseInt(req.queryParams("p"));
                    page = page > 19 ? 19 : page;
                } catch (NumberFormatException ex) {
                    page = 0;
                }
            }

            List<String> reposList = new ArrayList<>();
            List<String> langsList = new ArrayList<>();
            List<String> ownsList = new ArrayList<>();

            if (req.queryParams().contains("repo")) {
                String[] repos = new String[0];
                repos = req.queryParamsValues("repo");

                if (repos.length != 0) {
                    reposList = Arrays.asList(repos);
                }
            }

            if (req.queryParams().contains("lan")) {
                String[] langs = new String[0];
                langs = req.queryParamsValues("lan");

                if (langs.length != 0) {
                    langsList = Arrays.asList(langs);
                }
            }

            if (req.queryParams().contains("own")) {
                String[] owns = new String[0];
                owns = req.queryParamsValues("own");

                if (owns.length != 0) {
                    ownsList = Arrays.asList(owns);
                }
            }

            map.put("searchValue", query);
            map.put("searchResultJson",
                    gson.toJson(new CodePreload(query, page, langsList, reposList, ownsList)));

            map.put("logoImage", getLogo());
            map.put("isCommunity", ISCOMMUNITY);
            return new ModelAndView(map, "search_test.ftl");
        }

        // Totally pointless vanity but lets rotate the image every week
        int photoId = getWeekOfMonth();

        if (photoId <= 0) {
            photoId = 3;
        }
        if (photoId > 4) {
            photoId = 2;
        }

        CodeSearcher cs = new CodeSearcher();

        map.put("photoId", photoId);
        map.put("numDocs", cs.getTotalNumberDocumentsIndexed());
        map.put("logoImage", getLogo());
        map.put("isCommunity", ISCOMMUNITY);
        return new ModelAndView(map, "index.ftl");
    }, new FreeMarkerEngine());

    get("/html/", (req, res) -> {
        CodeSearcher cs = new CodeSearcher();
        CodeMatcher cm = new CodeMatcher(data);
        Map<String, Object> map = new HashMap<>();

        map.put("repoCount", repo.getRepoCount());

        if (req.queryParams().contains("q")) {
            String query = req.queryParams("q").trim();
            String altquery = query.replaceAll("[^A-Za-z0-9 ]", " ").trim().replaceAll(" +", " ");
            int page = 0;

            if (req.queryParams().contains("p")) {
                try {
                    page = Integer.parseInt(req.queryParams("p"));
                    page = page > 19 ? 19 : page;
                } catch (NumberFormatException ex) {
                    page = 0;
                }
            }

            String[] repos = new String[0];
            String[] langs = new String[0];
            String reposFilter = "";
            String langsFilter = "";
            String reposQueryString = "";
            String langsQueryString = "";

            if (req.queryParams().contains("repo")) {
                repos = req.queryParamsValues("repo");

                if (repos.length != 0) {
                    List<String> reposList = Arrays.asList(repos).stream()
                            .map((s) -> "reponame:" + QueryParser.escape(s)).collect(Collectors.toList());

                    reposFilter = " && (" + StringUtils.join(reposList, " || ") + ")";

                    List<String> reposQueryList = Arrays.asList(repos).stream()
                            .map((s) -> "&repo=" + URLEncoder.encode(s)).collect(Collectors.toList());

                    reposQueryString = StringUtils.join(reposQueryList, "");
                }
            }

            if (req.queryParams().contains("lan")) {
                langs = req.queryParamsValues("lan");

                if (langs.length != 0) {
                    List<String> langsList = Arrays.asList(langs).stream()
                            .map((s) -> "languagename:" + QueryParser.escape(s)).collect(Collectors.toList());

                    langsFilter = " && (" + StringUtils.join(langsList, " || ") + ")";

                    List<String> langsQueryList = Arrays.asList(langs).stream()
                            .map((s) -> "&lan=" + URLEncoder.encode(s)).collect(Collectors.toList());

                    langsQueryString = StringUtils.join(langsQueryList, "");
                }
            }

            // split the query escape it and and it together
            String cleanQueryString = scl.formatQueryString(query);

            SearchResult searchResult = cs.search(cleanQueryString + reposFilter + langsFilter, page);
            searchResult.setCodeResultList(cm.formatResults(searchResult.getCodeResultList(), query, true));

            for (CodeFacetRepo f : searchResult.getRepoFacetResults()) {
                if (Arrays.asList(repos).contains(f.getRepoName())) {
                    f.setSelected(true);
                }
            }

            for (CodeFacetLanguage f : searchResult.getLanguageFacetResults()) {
                if (Arrays.asList(langs).contains(f.getLanguageName())) {
                    f.setSelected(true);
                }
            }

            map.put("searchValue", query);
            map.put("searchResult", searchResult);
            map.put("reposQueryString", reposQueryString);
            map.put("langsQueryString", langsQueryString);

            map.put("altQuery", altquery);

            map.put("isHtml", true);
            map.put("logoImage", getLogo());
            map.put("isCommunity", ISCOMMUNITY);
            return new ModelAndView(map, "searchresults.ftl");
        }

        // Totally pointless vanity but lets rotate the image every week
        int photoId = getWeekOfMonth();

        if (photoId <= 0) {
            photoId = 3;
        }
        if (photoId > 4) {
            photoId = 2;
        }

        map.put("photoId", photoId);
        map.put("numDocs", cs.getTotalNumberDocumentsIndexed());
        map.put("logoImage", getLogo());
        map.put("isCommunity", ISCOMMUNITY);
        return new ModelAndView(map, "index.ftl");
    }, new FreeMarkerEngine());

    /**
     * Allows one to write literal lucene search queries against the index
     * TODO This is still very much WIP
     */
    get("/literal/", (req, res) -> {
        CodeSearcher cs = new CodeSearcher();
        CodeMatcher cm = new CodeMatcher(data);
        Map<String, Object> map = new HashMap<>();

        map.put("repoCount", repo.getRepoCount());

        if (req.queryParams().contains("q")) {
            String query = req.queryParams("q").trim();

            int page = 0;

            if (req.queryParams().contains("p")) {
                try {
                    page = Integer.parseInt(req.queryParams("p"));
                    page = page > 19 ? 19 : page;
                } catch (NumberFormatException ex) {
                    page = 0;
                }
            }

            String altquery = query.replaceAll("[^A-Za-z0-9 ]", " ").trim().replaceAll(" +", " ");

            SearchResult searchResult = cs.search(query, page);
            searchResult.setCodeResultList(cm.formatResults(searchResult.getCodeResultList(), altquery, false));

            map.put("searchValue", query);
            map.put("searchResult", searchResult);
            map.put("reposQueryString", "");
            map.put("langsQueryString", "");

            map.put("altQuery", "");

            map.put("logoImage", getLogo());
            map.put("isCommunity", ISCOMMUNITY);
            return new ModelAndView(map, "searchresults.ftl");
        }

        map.put("numDocs", cs.getTotalNumberDocumentsIndexed());
        map.put("logoImage", getLogo());
        map.put("isCommunity", ISCOMMUNITY);
        return new ModelAndView(map, "index.ftl");
    }, new FreeMarkerEngine());

    /**
     * This is the endpoint used by the frontend.
     */
    get("/api/codesearch/", (req, res) -> {
        CodeSearcher cs = new CodeSearcher();
        CodeMatcher cm = new CodeMatcher(data);

        if (req.queryParams().contains("q") && req.queryParams("q").trim() != "") {
            String query = req.queryParams("q").trim();

            int page = 0;

            if (req.queryParams().contains("p")) {
                try {
                    page = Integer.parseInt(req.queryParams("p"));
                    page = page > 19 ? 19 : page;
                } catch (NumberFormatException ex) {
                    page = 0;
                }
            }

            String[] repos = new String[0];
            String[] langs = new String[0];
            String[] owners = new String[0];
            String reposFilter = "";
            String langsFilter = "";
            String ownersFilter = "";

            if (req.queryParams().contains("repo")) {
                repos = req.queryParamsValues("repo");

                if (repos.length != 0) {
                    List<String> reposList = Arrays.asList(repos).stream()
                            .map((s) -> "reponame:" + QueryParser.escape(s)).collect(Collectors.toList());

                    reposFilter = " && (" + StringUtils.join(reposList, " || ") + ")";
                }
            }

            if (req.queryParams().contains("lan")) {
                langs = req.queryParamsValues("lan");

                if (langs.length != 0) {
                    List<String> langsList = Arrays.asList(langs).stream()
                            .map((s) -> "languagename:" + QueryParser.escape(s)).collect(Collectors.toList());

                    langsFilter = " && (" + StringUtils.join(langsList, " || ") + ")";
                }
            }

            if (req.queryParams().contains("own")) {
                owners = req.queryParamsValues("own");

                if (owners.length != 0) {
                    List<String> ownersList = Arrays.asList(owners).stream()
                            .map((s) -> "codeowner:" + QueryParser.escape(s)).collect(Collectors.toList());

                    ownersFilter = " && (" + StringUtils.join(ownersList, " || ") + ")";
                }
            }

            // Need to pass in the filters into this query
            String cacheKey = query + page + reposFilter + langsFilter + ownersFilter;

            if (cache.containsKey(cacheKey)) {
                return cache.get(cacheKey);
            }

            // split the query escape it and and it together
            String cleanQueryString = scl.formatQueryString(query);

            SearchResult searchResult = cs.search(cleanQueryString + reposFilter + langsFilter + ownersFilter,
                    page);
            searchResult.setCodeResultList(cm.formatResults(searchResult.getCodeResultList(), query, true));

            searchResult.setQuery(query);

            for (String altQuery : scl.generateAltQueries(query)) {
                searchResult.addAltQuery(altQuery);
            }

            // Null out code as it isnt required and there is no point in bloating our ajax requests
            for (CodeResult codeSearchResult : searchResult.getCodeResultList()) {
                codeSearchResult.setCode(null);
            }

            cache.put(cacheKey, searchResult);
            return searchResult;
        }

        return null;
    }, new JsonTransformer());

    get("/api/repo/add/", "application/json", (request, response) -> {
        boolean apiEnabled = Boolean
                .parseBoolean(Properties.getProperties().getProperty("api_enabled", "false"));
        boolean apiAuth = Boolean
                .parseBoolean(Properties.getProperties().getProperty("api_key_authentication", "true"));

        if (!apiEnabled) {
            return new ApiResponse(false, "API not enabled");
        }

        String publicKey = request.queryParams("pub");
        String signedKey = request.queryParams("sig");
        String reponames = request.queryParams("reponame");
        String repourls = request.queryParams("repourl");
        String repotype = request.queryParams("repotype");
        String repousername = request.queryParams("repousername");
        String repopassword = request.queryParams("repopassword");
        String reposource = request.queryParams("reposource");
        String repobranch = request.queryParams("repobranch");

        if (reponames == null || reponames.trim().equals(Values.EMPTYSTRING)) {
            return new ApiResponse(false, "reponame is a required parameter");
        }

        if (repourls == null || repourls.trim().equals(Values.EMPTYSTRING)) {
            return new ApiResponse(false, "repourl is a required parameter");
        }

        if (repotype == null) {
            return new ApiResponse(false, "repotype is a required parameter");
        }

        if (repousername == null) {
            return new ApiResponse(false, "repousername is a required parameter");
        }

        if (repopassword == null) {
            return new ApiResponse(false, "repopassword is a required parameter");
        }

        if (reposource == null) {
            return new ApiResponse(false, "reposource is a required parameter");
        }

        if (repobranch == null) {
            return new ApiResponse(false, "repobranch is a required parameter");
        }

        if (apiAuth) {
            if (publicKey == null || publicKey.trim().equals(Values.EMPTYSTRING)) {
                return new ApiResponse(false, "pub is a required parameter");
            }

            if (signedKey == null || signedKey.trim().equals(Values.EMPTYSTRING)) {
                return new ApiResponse(false, "sig is a required parameter");
            }

            String toValidate = String.format(
                    "pub=%s&reponame=%s&repourl=%s&repotype=%s&repousername=%s&repopassword=%s&reposource=%s&repobranch=%s",
                    URLEncoder.encode(publicKey), URLEncoder.encode(reponames), URLEncoder.encode(repourls),
                    URLEncoder.encode(repotype), URLEncoder.encode(repousername),
                    URLEncoder.encode(repopassword), URLEncoder.encode(reposource),
                    URLEncoder.encode(repobranch));

            boolean validRequest = apiService.validateRequest(publicKey, signedKey, toValidate);

            if (!validRequest) {
                return new ApiResponse(false, "invalid signed url");
            }
        }

        // Clean
        if (repobranch == null || repobranch.trim().equals(Values.EMPTYSTRING)) {
            repobranch = "master";
        }

        repotype = repotype.trim().toLowerCase();
        if (!"git".equals(repotype) && !"svn".equals(repotype)) {
            repotype = "git";
        }

        RepoResult repoResult = repo.getRepoByName(reponames);

        if (repoResult != null) {
            return new ApiResponse(false, "repository name already exists");
        }

        repo.saveRepo(new RepoResult(-1, reponames, repotype, repourls, repousername, repopassword, reposource,
                repobranch));

        return new ApiResponse(true, "added repository successfully");
    }, new JsonTransformer());

    get("/api/repo/delete/", "application/json", (request, response) -> {
        boolean apiEnabled = Boolean
                .parseBoolean(Properties.getProperties().getProperty("api_enabled", "false"));
        boolean apiAuth = Boolean
                .parseBoolean(Properties.getProperties().getProperty("api_key_authentication", "true"));

        if (!apiEnabled) {
            return new ApiResponse(false, "API not enabled");
        }

        String publicKey = request.queryParams("pub");
        String signedKey = request.queryParams("sig");
        String reponames = request.queryParams("reponame");

        if (reponames == null || reponames.trim().equals(Values.EMPTYSTRING)) {
            return new ApiResponse(false, "reponame is a required parameter");
        }

        if (apiAuth) {
            if (publicKey == null || publicKey.trim().equals(Values.EMPTYSTRING)) {
                return new ApiResponse(false, "pub is a required parameter");
            }

            if (signedKey == null || signedKey.trim().equals(Values.EMPTYSTRING)) {
                return new ApiResponse(false, "sig is a required parameter");
            }

            String toValidate = String.format("pub=%s&reponame=%s", URLEncoder.encode(publicKey),
                    URLEncoder.encode(reponames));

            boolean validRequest = apiService.validateRequest(publicKey, signedKey, toValidate);

            if (!validRequest) {
                return new ApiResponse(false, "invalid signed url");
            }
        }

        RepoResult rr = repo.getRepoByName(reponames);
        if (rr == null) {
            return new ApiResponse(false, "repository already deleted");
        }

        Singleton.getUniqueDeleteRepoQueue().add(rr);

        return new ApiResponse(true, "repository queued for deletion");
    }, new JsonTransformer());

    get("/api/repo/list/", "application/json", (request, response) -> {
        boolean apiEnabled = Boolean
                .parseBoolean(Properties.getProperties().getProperty("api_enabled", "false"));
        boolean apiAuth = Boolean
                .parseBoolean(Properties.getProperties().getProperty("api_key_authentication", "true"));

        if (!apiEnabled) {
            return new ApiResponse(false, "API not enabled");
        }

        String publicKey = request.queryParams("pub");
        String signedKey = request.queryParams("sig");

        if (apiAuth) {
            if (publicKey == null || publicKey.trim().equals(Values.EMPTYSTRING)) {
                return new ApiResponse(false, "pub is a required parameter");
            }

            if (signedKey == null || signedKey.trim().equals(Values.EMPTYSTRING)) {
                return new ApiResponse(false, "sig is a required parameter");
            }

            String toValidate = String.format("pub=%s", URLEncoder.encode(publicKey));

            boolean validRequest = apiService.validateRequest(publicKey, signedKey, toValidate);

            if (!validRequest) {
                return new ApiResponse(false, "invalid signed url");
            }
        }

        List<RepoResult> repoResultList = repo.getAllRepo();

        return new RepoResultApiResponse(true, Values.EMPTYSTRING, repoResultList);
    }, new JsonTransformer());

    get("/admin/", (request, response) -> {
        if (getAuthenticatedUser(request) == null) {
            response.redirect("/login/");
            halt();
            return null;
        }

        CodeSearcher cs = new CodeSearcher();

        Map<String, Object> map = new HashMap<>();

        map.put("repoCount", repo.getRepoCount());
        map.put("numDocs", cs.getTotalNumberDocumentsIndexed());

        map.put("numSearches", statsService.getSearchCount());
        map.put("uptime", statsService.getUptime());

        // Put all properties here
        map.put(Values.SQLITEFILE,
                Properties.getProperties().getProperty(Values.SQLITEFILE, Values.DEFAULTSQLITEFILE));
        map.put(Values.SERVERPORT,
                Properties.getProperties().getProperty(Values.SERVERPORT, Values.DEFAULTSERVERPORT));
        map.put(Values.REPOSITORYLOCATION, Properties.getProperties().getProperty(Values.REPOSITORYLOCATION,
                Values.DEFAULTREPOSITORYLOCATION));
        map.put(Values.INDEXLOCATION,
                Properties.getProperties().getProperty(Values.INDEXLOCATION, Values.DEFAULTINDEXLOCATION));
        map.put(Values.FACETSLOCATION,
                Properties.getProperties().getProperty(Values.FACETSLOCATION, Values.DEFAULTFACETSLOCATION));
        map.put(Values.CHECKREPOCHANGES, Properties.getProperties().getProperty(Values.CHECKREPOCHANGES,
                Values.DEFAULTCHECKREPOCHANGES));
        map.put(Values.ONLYLOCALHOST,
                Properties.getProperties().getProperty(Values.ONLYLOCALHOST, Values.DEFAULTONLYLOCALHOST));
        map.put(Values.LOWMEMORY,
                Properties.getProperties().getProperty(Values.LOWMEMORY, Values.DEFAULTLOWMEMORY));
        map.put(Values.SPELLINGCORRECTORSIZE, Properties.getProperties()
                .getProperty(Values.SPELLINGCORRECTORSIZE, Values.DEFAULTSPELLINGCORRECTORSIZE));
        map.put(Values.USESYSTEMGIT,
                Properties.getProperties().getProperty(Values.USESYSTEMGIT, Values.DEFAULTUSESYSTEMGIT));
        map.put(Values.GITBINARYPATH,
                Properties.getProperties().getProperty(Values.GITBINARYPATH, Values.DEFAULTGITBINARYPATH));
        map.put(Values.APIENABLED,
                Properties.getProperties().getProperty(Values.APIENABLED, Values.DEFAULTAPIENABLED));
        map.put(Values.APIKEYAUTH,
                Properties.getProperties().getProperty(Values.APIKEYAUTH, Values.DEFAULTAPIKEYAUTH));
        map.put(Values.SVNBINARYPATH,
                Properties.getProperties().getProperty(Values.SVNBINARYPATH, Values.DEFAULTSVNBINARYPATH));
        map.put(Values.SVNENABLED,
                Properties.getProperties().getProperty(Values.SVNENABLED, Values.DEFAULTSVNENABLED));
        map.put(Values.MAXDOCUMENTQUEUESIZE, Properties.getProperties().getProperty(Values.MAXDOCUMENTQUEUESIZE,
                Values.DEFAULTMAXDOCUMENTQUEUESIZE));
        map.put(Values.MAXDOCUMENTQUEUELINESIZE, Properties.getProperties()
                .getProperty(Values.MAXDOCUMENTQUEUELINESIZE, Values.DEFAULTMAXDOCUMENTQUEUELINESIZE));
        map.put(Values.MAXFILELINEDEPTH, Properties.getProperties().getProperty(Values.MAXFILELINEDEPTH,
                Values.DEFAULTMAXFILELINEDEPTH));

        map.put("deletionQueue", Singleton.getUniqueDeleteRepoQueue().size());

        map.put("version", VERSION);

        map.put("logoImage", getLogo());
        map.put("isCommunity", ISCOMMUNITY);
        return new ModelAndView(map, "admin.ftl");
    }, new FreeMarkerEngine());

    get("/admin/repo/", (request, response) -> {
        if (getAuthenticatedUser(request) == null) {
            response.redirect("/login/");
            halt();
            return null;
        }

        int repoCount = repo.getRepoCount();
        String offSet = request.queryParams("offset");
        String searchQuery = request.queryParams("q");
        int indexOffset = 0;

        Map<String, Object> map = new HashMap<>();

        if (offSet != null) {
            try {
                indexOffset = Integer.parseInt(offSet);
                if (indexOffset > repoCount || indexOffset < 0) {
                    indexOffset = 0;
                }

            } catch (NumberFormatException ex) {
                indexOffset = 0;
            }
        }

        if (searchQuery != null) {
            map.put("repoResults", repo.searchRepo(searchQuery));
        } else {
            map.put("repoResults", repo.getPagedRepo(indexOffset, 100));
        }

        map.put("searchQuery", searchQuery);
        map.put("hasPrevious", indexOffset > 0);
        map.put("hasNext", (indexOffset + 100) < repoCount);
        map.put("previousOffset", "" + (indexOffset - 100));
        map.put("nextOffset", "" + (indexOffset + 100));

        map.put("logoImage", getLogo());
        map.put("isCommunity", ISCOMMUNITY);
        return new ModelAndView(map, "admin_repo.ftl");
    }, new FreeMarkerEngine());

    get("/admin/bulk/", (request, response) -> {
        if (getAuthenticatedUser(request) == null) {
            response.redirect("/login/");
            halt();
            return null;
        }

        Map<String, Object> map = new HashMap<>();

        map.put("logoImage", getLogo());
        map.put("isCommunity", ISCOMMUNITY);
        return new ModelAndView(map, "admin_bulk.ftl");
    }, new FreeMarkerEngine());

    get("/admin/api/", (request, response) -> {
        if (getAuthenticatedUser(request) == null) {
            response.redirect("/login/");
            halt();
            return null;
        }

        Map<String, Object> map = new HashMap<>();

        map.put("apiKeys", api.getAllApi());

        boolean apiEnabled = Boolean
                .parseBoolean(Properties.getProperties().getProperty("api_enabled", "false"));
        boolean apiAuth = Boolean
                .parseBoolean(Properties.getProperties().getProperty("api_key_authentication", "true"));

        map.put("apiAuthentication", apiEnabled && apiAuth);
        map.put("logoImage", getLogo());
        map.put("isCommunity", ISCOMMUNITY);
        return new ModelAndView(map, "admin_api.ftl");
    }, new FreeMarkerEngine());

    post("/admin/api/", (request, response) -> {
        if (getAuthenticatedUser(request) == null) {
            response.redirect("/login/");
            halt();
            return null;
        }

        apiService.createKeys();

        response.redirect("/admin/api/");
        halt();
        return null;
    }, new FreeMarkerEngine());

    get("/admin/api/delete/", "application/json", (request, response) -> {
        if (getAuthenticatedUser(request) == null || !request.queryParams().contains("publicKey")) {
            response.redirect("/login/");
            halt();
            return false;
        }

        String publicKey = request.queryParams("publicKey");
        apiService.deleteKey(publicKey);

        return true;
    }, new JsonTransformer());

    get("/admin/settings/", (request, response) -> {
        if (getAuthenticatedUser(request) == null) {
            response.redirect("/login/");
            halt();
            return null;
        }

        String[] highlighters = "agate,androidstudio,arta,ascetic,atelier-cave.dark,atelier-cave.light,atelier-dune.dark,atelier-dune.light,atelier-estuary.dark,atelier-estuary.light,atelier-forest.dark,atelier-forest.light,atelier-heath.dark,atelier-heath.light,atelier-lakeside.dark,atelier-lakeside.light,atelier-plateau.dark,atelier-plateau.light,atelier-savanna.dark,atelier-savanna.light,atelier-seaside.dark,atelier-seaside.light,atelier-sulphurpool.dark,atelier-sulphurpool.light,brown_paper,codepen-embed,color-brewer,dark,darkula,default,docco,far,foundation,github-gist,github,googlecode,grayscale,hopscotch,hybrid,idea,ir_black,kimbie.dark,kimbie.light,magula,mono-blue,monokai,monokai_sublime,obsidian,paraiso.dark,paraiso.light,pojoaque,railscasts,rainbow,school_book,solarized_dark,solarized_light,sunburst,tomorrow-night-blue,tomorrow-night-bright,tomorrow-night-eighties,tomorrow-night,tomorrow,vs,xcode,zenburn"
                .split(",");

        Map<String, Object> map = new HashMap<>();
        map.put("logoImage", getLogo());
        map.put("syntaxHighlighter", getSyntaxHighlighter());
        map.put("highlighters", highlighters);
        map.put("averageSalary", "" + (int) getAverageSalary());
        map.put("matchLines", "" + (int) getMatchLines());
        map.put("maxLineDepth", "" + (int) getMaxLineDepth());
        map.put("minifiedLength", "" + (int) getMinifiedLength());
        map.put("isCommunity", ISCOMMUNITY);

        return new ModelAndView(map, "admin_settings.ftl");
    }, new FreeMarkerEngine());

    get("/admin/reports/", (request, response) -> {
        if (getAuthenticatedUser(request) == null) {
            response.redirect("/login/");
            halt();
            return null;
        }

        Map<String, Object> map = new HashMap<>();
        map.put("logoImage", getLogo());
        map.put("isCommunity", ISCOMMUNITY);

        return new ModelAndView(map, "admin_reports.ftl");
    }, new FreeMarkerEngine());

    post("/admin/settings/", (request, response) -> {
        if (getAuthenticatedUser(request) == null) {
            response.redirect("/login/");
            halt();
            return null;
        }

        if (ISCOMMUNITY) {
            response.redirect("/admin/settings/");
            halt();
        }

        String logo = request.queryParams("logo").trim();
        String syntaxHighlighter = request.queryParams("syntaxhighligher");

        try {
            double averageSalary = Double.parseDouble(request.queryParams("averagesalary"));
            data.saveData(Values.AVERAGESALARY, "" + (int) averageSalary);
        } catch (NumberFormatException ex) {
            data.saveData(Values.AVERAGESALARY, Values.DEFAULTAVERAGESALARY);
        }

        try {
            double averageSalary = Double.parseDouble(request.queryParams("matchlines"));
            data.saveData(Values.MATCHLINES, "" + (int) averageSalary);
        } catch (NumberFormatException ex) {
            data.saveData(Values.MATCHLINES, Values.DEFAULTMATCHLINES);
        }

        try {
            double averageSalary = Double.parseDouble(request.queryParams("maxlinedepth"));
            data.saveData(Values.MAXLINEDEPTH, "" + (int) averageSalary);
        } catch (NumberFormatException ex) {
            data.saveData(Values.MAXLINEDEPTH, Values.DEFAULTMAXLINEDEPTH);
        }

        try {
            double minifiedlength = Double.parseDouble(request.queryParams("minifiedlength"));
            data.saveData(Values.MINIFIEDLENGTH, "" + (int) minifiedlength);
        } catch (NumberFormatException ex) {
            data.saveData(Values.MINIFIEDLENGTH, Values.DEFAULTMINIFIEDLENGTH);
        }

        data.saveData(Values.LOGO, logo);
        data.saveData(Values.SYNTAXHIGHLIGHTER, syntaxHighlighter);

        // Redo anything that requires updates at this point
        scl = Singleton.getSearchcodeLib(data);

        response.redirect("/admin/settings/");
        halt();
        return null;
    }, new FreeMarkerEngine());

    post("/admin/bulk/", (request, response) -> {
        if (getAuthenticatedUser(request) == null) {
            response.redirect("/login/");
            halt();
            return null;
        }

        String repos = request.queryParams("repos");
        String repolines[] = repos.split("\\r?\\n");

        for (String line : repolines) {
            String[] repoparams = line.split(",", -1);

            if (repoparams.length == 7) {

                String branch = repoparams[6].trim();
                if (branch.equals(Values.EMPTYSTRING)) {
                    branch = "master";
                }

                String scm = repoparams[1].trim().toLowerCase();
                if (scm.equals(Values.EMPTYSTRING)) {
                    scm = "git";
                }

                RepoResult rr = repo.getRepoByName(repoparams[0]);

                if (rr == null) {
                    repo.saveRepo(new RepoResult(-1, repoparams[0], scm, repoparams[2], repoparams[3],
                            repoparams[4], repoparams[5], branch));
                }
            }
        }

        response.redirect("/admin/bulk/");
        halt();
        return null;
    }, new FreeMarkerEngine());

    post("/admin/repo/", (request, response) -> {
        if (getAuthenticatedUser(request) == null) {
            response.redirect("/login/");
            halt();
            return null;
        }

        String[] reponames = request.queryParamsValues("reponame");
        String[] reposcms = request.queryParamsValues("reposcm");
        String[] repourls = request.queryParamsValues("repourl");
        String[] repousername = request.queryParamsValues("repousername");
        String[] repopassword = request.queryParamsValues("repopassword");
        String[] reposource = request.queryParamsValues("reposource");
        String[] repobranch = request.queryParamsValues("repobranch");

        for (int i = 0; i < reponames.length; i++) {
            if (reponames[i].trim().length() != 0) {

                String branch = repobranch[i].trim();
                if (branch.equals(Values.EMPTYSTRING)) {
                    branch = "master";
                }

                repo.saveRepo(new RepoResult(-1, reponames[i], reposcms[i], repourls[i], repousername[i],
                        repopassword[i], reposource[i], branch));
            }
        }

        response.redirect("/admin/repo/");
        halt();
        return null;
    }, new FreeMarkerEngine());

    get("/login/", (request, response) -> {
        if (getAuthenticatedUser(request) != null) {
            response.redirect("/admin/");
            halt();
            return null;
        }
        Map<String, Object> map = new HashMap<>();
        map.put("logoImage", getLogo());
        map.put("isCommunity", ISCOMMUNITY);
        return new ModelAndView(map, "login.ftl");
    }, new FreeMarkerEngine());

    post("/login/", (req, res) -> {
        if (req.queryParams().contains("password") && req.queryParams("password")
                .equals(com.searchcode.app.util.Properties.getProperties().getProperty("password"))) {
            addAuthenticatedUser(req);
            res.redirect("/admin/");
            halt();
        }
        Map<String, Object> map = new HashMap<>();
        map.put("logoImage", getLogo());
        map.put("isCommunity", ISCOMMUNITY);
        return new ModelAndView(map, "login.ftl");
    }, new FreeMarkerEngine());

    get("/logout/", (req, res) -> {
        removeAuthenticatedUser(req);
        res.redirect("/");
        return null;
    });

    get("/admin/delete/", "application/json", (request, response) -> {
        if (getAuthenticatedUser(request) == null || !request.queryParams().contains("repoName")) {
            response.redirect("/login/");
            halt();
            return false;
        }

        String repoName = request.queryParams("repoName");
        RepoResult rr = repo.getRepoByName(repoName);

        if (rr != null) {
            Singleton.getUniqueDeleteRepoQueue().add(rr);
        }

        return true;
    }, new JsonTransformer());

    get("/admin/checkversion/", "application/json", (request, response) -> {
        if (getAuthenticatedUser(request) == null) {
            response.redirect("/login/");
            halt();
            return false;
        }

        String version;
        try {
            version = IOUtils.toString(new URL("https://searchcode.com/product/version/")).replace("\"",
                    Values.EMPTYSTRING);
        } catch (IOException ex) {
            return "Unable to determine if running the latest version. Check https://searchcode.com/product/download/ for the latest release.";
        }

        if (App.VERSION.equals(version)) {
            return "Your searchcode server version " + version + " is the latest.";
        } else {
            return "Your searchcode server version " + App.VERSION
                    + " instance is out of date. The latest version is " + version + ".";
        }
    }, new JsonTransformer());

    get("/file/:codeid/:reponame/*", (request, response) -> {
        Map<String, Object> map = new HashMap<>();

        CodeSearcher cs = new CodeSearcher();
        Cocomo2 coco = new Cocomo2();

        StringBuilder code = new StringBuilder();

        String fileName = Values.EMPTYSTRING;
        if (request.splat().length != 0) {
            fileName = request.splat()[0];
        }

        CodeResult codeResult = cs.getByRepoFileName(request.params(":reponame"), fileName);

        if (codeResult == null) {
            int codeid = Integer.parseInt(request.params(":codeid"));
            codeResult = cs.getById(codeid);
        }

        if (codeResult == null) {
            response.redirect("/404/");
            halt();
        }

        List<String> codeLines = codeResult.code;
        for (int i = 0; i < codeLines.size(); i++) {
            code.append("<span id=\"" + (i + 1) + "\"></span>");
            code.append(StringEscapeUtils.escapeHtml4(codeLines.get(i)));
            code.append("\n");
        }

        boolean highlight = true;
        if (Integer.parseInt(codeResult.codeLines) > 1000) {
            highlight = false;
        }

        RepoResult repoResult = repo.getRepoByName(codeResult.repoName);

        if (repoResult != null) {
            map.put("source", repoResult.getSource());
        }

        map.put("fileName", codeResult.fileName);
        map.put("codePath", codeResult.codePath);
        map.put("codeLength", codeResult.codeLines);
        map.put("languageName", codeResult.languageName);
        map.put("md5Hash", codeResult.md5hash);
        map.put("repoName", codeResult.repoName);
        map.put("highlight", highlight);
        map.put("repoLocation", codeResult.getRepoLocation());

        map.put("codeValue", code.toString());
        map.put("highligher", getSyntaxHighlighter());
        map.put("codeOwner", codeResult.getCodeOwner());

        double estimatedEffort = coco.estimateEffort(scl.countFilteredLines(codeResult.getCode()));
        int estimatedCost = (int) coco.estimateCost(estimatedEffort, getAverageSalary());
        if (estimatedCost != 0 && !scl.languageCostIgnore(codeResult.getLanguageName())) {
            map.put("estimatedCost", estimatedCost);
        }

        map.put("logoImage", getLogo());
        map.put("isCommunity", ISCOMMUNITY);
        return new ModelAndView(map, "coderesult.ftl");
    }, new FreeMarkerEngine());

    /**
     * Deprecated should not be used
     * TODO delete this method
     */
    get("/codesearch/view/:codeid", (request, response) -> {
        Map<String, Object> map = new HashMap<>();

        int codeid = Integer.parseInt(request.params(":codeid"));
        CodeSearcher cs = new CodeSearcher();
        Cocomo2 coco = new Cocomo2();

        StringBuilder code = new StringBuilder();

        // escape all the lines and include deeplink for line number
        CodeResult codeResult = cs.getById(codeid);

        if (codeResult == null) {
            response.redirect("/404/");
            halt();
        }

        List<String> codeLines = codeResult.code;
        for (int i = 0; i < codeLines.size(); i++) {
            code.append("<span id=\"" + (i + 1) + "\"></span>");
            code.append(StringEscapeUtils.escapeHtml4(codeLines.get(i)));
            code.append("\n");
        }

        boolean highlight = true;
        if (Integer.parseInt(codeResult.codeLines) > 1000) {
            highlight = false;
        }

        RepoResult repoResult = repo.getRepoByName(codeResult.repoName);

        if (repoResult != null) {
            map.put("source", repoResult.getSource());
        }

        map.put("fileName", codeResult.fileName);
        map.put("codePath", codeResult.codePath);
        map.put("codeLength", codeResult.codeLines);
        map.put("languageName", codeResult.languageName);
        map.put("md5Hash", codeResult.md5hash);
        map.put("repoName", codeResult.repoName);
        map.put("highlight", highlight);
        map.put("repoLocation", codeResult.getRepoLocation());

        map.put("codeValue", code.toString());
        map.put("highligher", getSyntaxHighlighter());
        map.put("codeOwner", codeResult.getCodeOwner());

        double estimatedEffort = coco.estimateEffort(scl.countFilteredLines(codeResult.getCode()));
        int estimatedCost = (int) coco.estimateCost(estimatedEffort, getAverageSalary());
        if (estimatedCost != 0 && !scl.languageCostIgnore(codeResult.getLanguageName())) {
            map.put("estimatedCost", estimatedCost);
        }

        map.put("logoImage", getLogo());
        map.put("isCommunity", ISCOMMUNITY);
        return new ModelAndView(map, "coderesult.ftl");
    }, new FreeMarkerEngine());

    get("/documentation/", (request, response) -> {
        Map<String, Object> map = new HashMap<>();

        map.put("logoImage", getLogo());
        map.put("isCommunity", ISCOMMUNITY);
        return new ModelAndView(map, "documentation.ftl");
    }, new FreeMarkerEngine());

    get("/search_test/", (request, response) -> {
        Map<String, Object> map = new HashMap<>();

        map.put("logoImage", getLogo());
        map.put("isCommunity", ISCOMMUNITY);
        return new ModelAndView(map, "search_test.ftl");
    }, new FreeMarkerEngine());

    get("/404/", (request, response) -> {
        Map<String, Object> map = new HashMap<>();

        map.put("logoImage", getLogo());
        map.put("isCommunity", ISCOMMUNITY);
        return new ModelAndView(map, "404.ftl");

    }, new FreeMarkerEngine());

    /**
     * Test that was being used to display blame information
     */
    //        get("/test/:reponame/*", (request, response) -> {
    //            User user = injector.getInstance(User.class);
    //            user.Blame(request.params(":reponame"), request.splat()[0]);
    //            return "";
    //        }, new JsonTransformer());
}

---

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   ww w  . ja v  a  2 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();

}

---

From source file:Main.java

public static String jidToResourceId(final String fullId) {
    return fullId.split("/", 2)[1];
}

---

From source file:Main.java

public static String[] parseCatAndCity(String fullText) {
    String[] string = fullText.split("[,]", 2);
    return string;

}

---

From source file:Main.java

private static String[] delimSplit(String s, String del) {
    return s.split(del, -1);
}

---

• «
• 1
• 2
• »