Example usage for java.lang String equals

Introduction

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

Prototype

public boolean equals(Object anObject) 

Source Link

Document

Compares this string to the specified object.

Usage

From source file:FTPClientExample.java

public static void main(String[] args) throws UnknownHostException {
    boolean storeFile = false, binaryTransfer = false, error = false, listFiles = false, listNames = false,
            hidden = false;//www. j ava2  s. co  m
    boolean localActive = false, useEpsvWithIPv4 = false, feat = false, printHash = false;
    boolean mlst = false, mlsd = false;
    boolean lenient = false;
    long keepAliveTimeout = -1;
    int controlKeepAliveReplyTimeout = -1;
    int minParams = 5; // listings require 3 params
    String protocol = null; // SSL protocol
    String doCommand = null;
    String trustmgr = null;
    String proxyHost = null;
    int proxyPort = 80;
    String proxyUser = null;
    String proxyPassword = null;
    String username = null;
    String password = null;

    int base = 0;
    for (base = 0; base < args.length; base++) {
        if (args[base].equals("-s")) {
            storeFile = true;
        } else if (args[base].equals("-a")) {
            localActive = true;
        } else if (args[base].equals("-A")) {
            username = "anonymous";
            password = System.getProperty("user.name") + "@" + InetAddress.getLocalHost().getHostName();
        } else if (args[base].equals("-b")) {
            binaryTransfer = true;
        } else if (args[base].equals("-c")) {
            doCommand = args[++base];
            minParams = 3;
        } else if (args[base].equals("-d")) {
            mlsd = true;
            minParams = 3;
        } else if (args[base].equals("-e")) {
            useEpsvWithIPv4 = true;
        } else if (args[base].equals("-f")) {
            feat = true;
            minParams = 3;
        } else if (args[base].equals("-h")) {
            hidden = true;
        } else if (args[base].equals("-k")) {
            keepAliveTimeout = Long.parseLong(args[++base]);
        } else if (args[base].equals("-l")) {
            listFiles = true;
            minParams = 3;
        } else if (args[base].equals("-L")) {
            lenient = true;
        } else if (args[base].equals("-n")) {
            listNames = true;
            minParams = 3;
        } else if (args[base].equals("-p")) {
            protocol = args[++base];
        } else if (args[base].equals("-t")) {
            mlst = true;
            minParams = 3;
        } else if (args[base].equals("-w")) {
            controlKeepAliveReplyTimeout = Integer.parseInt(args[++base]);
        } else if (args[base].equals("-T")) {
            trustmgr = args[++base];
        } else if (args[base].equals("-PrH")) {
            proxyHost = args[++base];
            String parts[] = proxyHost.split(":");
            if (parts.length == 2) {
                proxyHost = parts[0];
                proxyPort = Integer.parseInt(parts[1]);
            }
        } else if (args[base].equals("-PrU")) {
            proxyUser = args[++base];
        } else if (args[base].equals("-PrP")) {
            proxyPassword = args[++base];
        } else if (args[base].equals("-#")) {
            printHash = true;
        } else {
            break;
        }
    }

    int remain = args.length - base;
    if (username != null) {
        minParams -= 2;
    }
    if (remain < minParams) // server, user, pass, remote, local [protocol]
    {
        System.err.println(USAGE);
        System.exit(1);
    }

    String server = args[base++];
    int port = 0;
    String parts[] = server.split(":");
    if (parts.length == 2) {
        server = parts[0];
        port = Integer.parseInt(parts[1]);
    }
    if (username == null) {
        username = args[base++];
        password = args[base++];
    }

    String remote = null;
    if (args.length - base > 0) {
        remote = args[base++];
    }

    String local = null;
    if (args.length - base > 0) {
        local = args[base++];
    }

    final FTPClient ftp;
    if (protocol == null) {
        if (proxyHost != null) {
            System.out.println("Using HTTP proxy server: " + proxyHost);
            ftp = new FTPHTTPClient(proxyHost, proxyPort, proxyUser, proxyPassword);
        } else {
            ftp = new FTPClient();
        }
    } else {
        FTPSClient ftps;
        if (protocol.equals("true")) {
            ftps = new FTPSClient(true);
        } else if (protocol.equals("false")) {
            ftps = new FTPSClient(false);
        } else {
            String prot[] = protocol.split(",");
            if (prot.length == 1) { // Just protocol
                ftps = new FTPSClient(protocol);
            } else { // protocol,true|false
                ftps = new FTPSClient(prot[0], Boolean.parseBoolean(prot[1]));
            }
        }
        ftp = ftps;
        if ("all".equals(trustmgr)) {
            ftps.setTrustManager(TrustManagerUtils.getAcceptAllTrustManager());
        } else if ("valid".equals(trustmgr)) {
            ftps.setTrustManager(TrustManagerUtils.getValidateServerCertificateTrustManager());
        } else if ("none".equals(trustmgr)) {
            ftps.setTrustManager(null);
        }
    }

    if (printHash) {
        ftp.setCopyStreamListener(createListener());
    }
    if (keepAliveTimeout >= 0) {
        ftp.setControlKeepAliveTimeout(keepAliveTimeout);
    }
    if (controlKeepAliveReplyTimeout >= 0) {
        ftp.setControlKeepAliveReplyTimeout(controlKeepAliveReplyTimeout);
    }
    ftp.setListHiddenFiles(hidden);

    // suppress login details
    ftp.addProtocolCommandListener(new PrintCommandListener(new PrintWriter(System.out), true));

    try {
        int reply;
        if (port > 0) {
            ftp.connect(server, port);
        } else {
            ftp.connect(server);
        }
        System.out.println("Connected to " + server + " on " + (port > 0 ? port : ftp.getDefaultPort()));

        // After connection attempt, you should check the reply code to verify
        // success.
        reply = ftp.getReplyCode();

        if (!FTPReply.isPositiveCompletion(reply)) {
            ftp.disconnect();
            System.err.println("FTP server refused connection.");
            System.exit(1);
        }
    } catch (IOException e) {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
        System.err.println("Could not connect to server.");
        e.printStackTrace();
        System.exit(1);
    }

    __main: try {
        if (!ftp.login(username, password)) {
            ftp.logout();
            error = true;
            break __main;
        }

        System.out.println("Remote system is " + ftp.getSystemType());

        if (binaryTransfer) {
            ftp.setFileType(FTP.BINARY_FILE_TYPE);
        } else {
            // in theory this should not be necessary as servers should default to ASCII
            // but they don't all do so - see NET-500
            ftp.setFileType(FTP.ASCII_FILE_TYPE);
        }

        // Use passive mode as default because most of us are
        // behind firewalls these days.
        if (localActive) {
            ftp.enterLocalActiveMode();
        } else {
            ftp.enterLocalPassiveMode();
        }

        ftp.setUseEPSVwithIPv4(useEpsvWithIPv4);

        if (storeFile) {
            InputStream input;

            input = new FileInputStream(local);

            ftp.storeFile(remote, input);

            input.close();
        } else if (listFiles) {
            if (lenient) {
                FTPClientConfig config = new FTPClientConfig();
                config.setLenientFutureDates(true);
                ftp.configure(config);
            }

            for (FTPFile f : ftp.listFiles(remote)) {
                System.out.println(f.getRawListing());
                System.out.println(f.toFormattedString());
            }
        } else if (mlsd) {
            for (FTPFile f : ftp.mlistDir(remote)) {
                System.out.println(f.getRawListing());
                System.out.println(f.toFormattedString());
            }
        } else if (mlst) {
            FTPFile f = ftp.mlistFile(remote);
            if (f != null) {
                System.out.println(f.toFormattedString());
            }
        } else if (listNames) {
            for (String s : ftp.listNames(remote)) {
                System.out.println(s);
            }
        } else if (feat) {
            // boolean feature check
            if (remote != null) { // See if the command is present
                if (ftp.hasFeature(remote)) {
                    System.out.println("Has feature: " + remote);
                } else {
                    if (FTPReply.isPositiveCompletion(ftp.getReplyCode())) {
                        System.out.println("FEAT " + remote + " was not detected");
                    } else {
                        System.out.println("Command failed: " + ftp.getReplyString());
                    }
                }

                // Strings feature check
                String[] features = ftp.featureValues(remote);
                if (features != null) {
                    for (String f : features) {
                        System.out.println("FEAT " + remote + "=" + f + ".");
                    }
                } else {
                    if (FTPReply.isPositiveCompletion(ftp.getReplyCode())) {
                        System.out.println("FEAT " + remote + " is not present");
                    } else {
                        System.out.println("Command failed: " + ftp.getReplyString());
                    }
                }
            } else {
                if (ftp.features()) {
                    //                        Command listener has already printed the output
                } else {
                    System.out.println("Failed: " + ftp.getReplyString());
                }
            }
        } else if (doCommand != null) {
            if (ftp.doCommand(doCommand, remote)) {
                //                  Command listener has already printed the output
                //                    for(String s : ftp.getReplyStrings()) {
                //                        System.out.println(s);
                //                    }
            } else {
                System.out.println("Failed: " + ftp.getReplyString());
            }
        } else {
            OutputStream output;

            output = new FileOutputStream(local);

            ftp.retrieveFile(remote, output);

            output.close();
        }

        ftp.noop(); // check that control connection is working OK

        ftp.logout();
    } catch (FTPConnectionClosedException e) {
        error = true;
        System.err.println("Server closed connection.");
        e.printStackTrace();
    } catch (IOException e) {
        error = true;
        e.printStackTrace();
    } finally {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
    }

    System.exit(error ? 1 : 0);
}

---

From source file:by.FTPClientExample.java

public static void main(String[] args) throws UnknownHostException {
    boolean storeFile = false, binaryTransfer = false, error = false, listFiles = false, listNames = false,
            hidden = false;/*from  www. j a v  a 2 s  .  com*/
    boolean localActive = false, useEpsvWithIPv4 = false, feat = false, printHash = false;
    boolean mlst = false, mlsd = false;
    boolean lenient = false;
    long keepAliveTimeout = -1;
    int controlKeepAliveReplyTimeout = -1;
    int minParams = 5; // listings require 3 params
    String protocol = null; // SSL protocol
    String doCommand = null;
    String trustmgr = null;
    String proxyHost = null;
    int proxyPort = 80;
    String proxyUser = null;
    String proxyPassword = null;
    String username = null;
    String password = null;

    int base = 0;
    for (base = 0; base < args.length; base++) {
        if (args[base].equals("-s")) {
            storeFile = true;
        } else if (args[base].equals("-a")) {
            localActive = true;
        } else if (args[base].equals("-A")) {
            username = "anonymous";
            password = System.getProperty("user.name") + "@" + InetAddress.getLocalHost().getHostName();
        } else if (args[base].equals("-b")) {
            binaryTransfer = true;
        } else if (args[base].equals("-c")) {
            doCommand = args[++base];
            minParams = 3;
        } else if (args[base].equals("-d")) {
            mlsd = true;
            minParams = 3;
        } else if (args[base].equals("-e")) {
            useEpsvWithIPv4 = true;
        } else if (args[base].equals("-f")) {
            feat = true;
            minParams = 3;
        } else if (args[base].equals("-h")) {
            hidden = true;
        } else if (args[base].equals("-k")) {
            keepAliveTimeout = Long.parseLong(args[++base]);
        } else if (args[base].equals("-l")) {
            listFiles = true;
            minParams = 3;
        } else if (args[base].equals("-L")) {
            lenient = true;
        } else if (args[base].equals("-n")) {
            listNames = true;
            minParams = 3;
        } else if (args[base].equals("-p")) {
            protocol = args[++base];
        } else if (args[base].equals("-t")) {
            mlst = true;
            minParams = 3;
        } else if (args[base].equals("-w")) {
            controlKeepAliveReplyTimeout = Integer.parseInt(args[++base]);
        } else if (args[base].equals("-T")) {
            trustmgr = args[++base];
        } else if (args[base].equals("-PrH")) {
            proxyHost = args[++base];
            String parts[] = proxyHost.split(":");
            if (parts.length == 2) {
                proxyHost = parts[0];
                proxyPort = Integer.parseInt(parts[1]);
            }
        } else if (args[base].equals("-PrU")) {
            proxyUser = args[++base];
        } else if (args[base].equals("-PrP")) {
            proxyPassword = args[++base];
        } else if (args[base].equals("-#")) {
            printHash = true;
        } else {
            break;
        }
    }

    int remain = args.length - base;
    if (username != null) {
        minParams -= 2;
    }
    if (remain < minParams) // server, user, pass, remote, local [protocol]
    {
        System.err.println(USAGE);
        System.exit(1);
    }

    String server = args[base++];
    int port = 0;
    String parts[] = server.split(":");
    if (parts.length == 2) {
        server = parts[0];
        port = Integer.parseInt(parts[1]);
    }
    if (username == null) {
        username = args[base++];
        password = args[base++];
    }

    String remote = null;
    if (args.length - base > 0) {
        remote = args[base++];
    }

    String local = null;
    if (args.length - base > 0) {
        local = args[base++];
    }

    final FTPClient ftp;
    if (protocol == null) {
        if (proxyHost != null) {
            System.out.println("Using HTTP proxy server: " + proxyHost);
            ftp = new FTPHTTPClient(proxyHost, proxyPort, proxyUser, proxyPassword);
        } else {
            ftp = new FTPClient();
        }
    } else {
        FTPSClient ftps;
        if (protocol.equals("true")) {
            ftps = new FTPSClient(true);
        } else if (protocol.equals("false")) {
            ftps = new FTPSClient(false);
        } else {
            String prot[] = protocol.split(",");
            if (prot.length == 1) { // Just protocol
                ftps = new FTPSClient(protocol);
            } else { // protocol,true|false
                ftps = new FTPSClient(prot[0], Boolean.parseBoolean(prot[1]));
            }
        }
        ftp = ftps;
        if ("all".equals(trustmgr)) {
            ftps.setTrustManager(TrustManagerUtils.getAcceptAllTrustManager());
        } else if ("valid".equals(trustmgr)) {
            ftps.setTrustManager(TrustManagerUtils.getValidateServerCertificateTrustManager());
        } else if ("none".equals(trustmgr)) {
            ftps.setTrustManager(null);
        }
    }

    if (printHash) {
        ftp.setCopyStreamListener(createListener());
    }
    if (keepAliveTimeout >= 0) {
        ftp.setControlKeepAliveTimeout(keepAliveTimeout);
    }
    if (controlKeepAliveReplyTimeout >= 0) {
        ftp.setControlKeepAliveReplyTimeout(controlKeepAliveReplyTimeout);
    }
    ftp.setListHiddenFiles(hidden);

    // suppress login details
    ftp.addProtocolCommandListener(new PrintCommandListener(new PrintWriter(System.out), true));

    try {
        int reply;
        if (port > 0) {
            System.out.println(server + ":" + port);
            ftp.connect(server, port);
        } else {
            ftp.connect(server);
        }
        System.out.println("Connected to " + server + " on " + (port > 0 ? port : ftp.getDefaultPort()));

        // After connection attempt, you should check the reply code to verify
        // success.
        reply = ftp.getReplyCode();

        if (!FTPReply.isPositiveCompletion(reply)) {
            ftp.disconnect();
            System.err.println("FTP server refused connection.");
            System.exit(1);
        }
    } catch (IOException e) {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
        System.err.println("Could not connect to server.");
        e.printStackTrace();
        System.exit(1);
    }

    __main: try {
        System.out.println("???" + username + "," + password);
        if (!ftp.login(username, password)) {
            ftp.logout();
            error = true;
            break __main;
        }

        System.out.println("Remote system is " + ftp.getSystemType());

        if (binaryTransfer) {
            ftp.setFileType(FTP.BINARY_FILE_TYPE);
        } else {
            // in theory this should not be necessary as servers should default to ASCII
            // but they don't all do so - see NET-500
            ftp.setFileType(FTP.ASCII_FILE_TYPE);
        }

        // Use passive mode as default because most of us are
        // behind firewalls these days.
        if (localActive) {
            ftp.enterLocalActiveMode();
        } else {
            ftp.enterLocalPassiveMode();
        }

        ftp.setUseEPSVwithIPv4(useEpsvWithIPv4);

        if (storeFile) {
            InputStream input;

            input = new FileInputStream(local);

            ftp.storeFile(remote, input);

            input.close();
        } else if (listFiles) {
            if (lenient) {
                FTPClientConfig config = new FTPClientConfig();
                config.setLenientFutureDates(true);
                ftp.configure(config);
            }

            for (FTPFile f : ftp.listFiles(remote)) {
                System.out.println(f.getRawListing());
                System.out.println(f.toFormattedString());
            }
        } else if (mlsd) {
            for (FTPFile f : ftp.mlistDir(remote)) {
                System.out.println(f.getRawListing());
                System.out.println(f.toFormattedString());
            }
        } else if (mlst) {
            FTPFile f = ftp.mlistFile(remote);
            if (f != null) {
                System.out.println(f.toFormattedString());
            }
        } else if (listNames) {
            for (String s : ftp.listNames(remote)) {
                System.out.println(s);
            }
        } else if (feat) {
            // boolean feature check
            if (remote != null) { // See if the command is present
                if (ftp.hasFeature(remote)) {
                    System.out.println("Has feature: " + remote);
                } else {
                    if (FTPReply.isPositiveCompletion(ftp.getReplyCode())) {
                        System.out.println("FEAT " + remote + " was not detected");
                    } else {
                        System.out.println("Command failed: " + ftp.getReplyString());
                    }
                }

                // Strings feature check
                String[] features = ftp.featureValues(remote);
                if (features != null) {
                    for (String f : features) {
                        System.out.println("FEAT " + remote + "=" + f + ".");
                    }
                } else {
                    if (FTPReply.isPositiveCompletion(ftp.getReplyCode())) {
                        System.out.println("FEAT " + remote + " is not present");
                    } else {
                        System.out.println("Command failed: " + ftp.getReplyString());
                    }
                }
            } else {
                if (ftp.features()) {
                    //                        Command listener has already printed the output
                } else {
                    System.out.println("Failed: " + ftp.getReplyString());
                }
            }
        } else if (doCommand != null) {
            if (ftp.doCommand(doCommand, remote)) {
                //                  Command listener has already printed the output
                //                    for(String s : ftp.getReplyStrings()) {
                //                        System.out.println(s);
                //                    }
            } else {
                System.out.println("Failed: " + ftp.getReplyString());
            }
        } else {
            OutputStream output;

            output = new FileOutputStream(local);

            ftp.retrieveFile(remote, output);

            output.close();
        }

        ftp.noop(); // check that control connection is working OK

        ftp.logout();
    } catch (FTPConnectionClosedException e) {
        error = true;
        System.err.println("Server closed connection.");
        e.printStackTrace();
    } catch (IOException e) {
        error = true;
        e.printStackTrace();
    } finally {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
    }

    System.exit(error ? 1 : 0);
}

---

From source file:ddc.commons.ftp.FTPClientExample.java

public static void main(String[] args) throws UnknownHostException {
    boolean storeFile = false, binaryTransfer = false, error = false, listFiles = false, listNames = false,
            hidden = false;//from w w w.j  a v a2s  .  co m
    boolean localActive = false, useEpsvWithIPv4 = false, feat = false, printHash = false;
    boolean mlst = false, mlsd = false;
    boolean lenient = false;
    long keepAliveTimeout = -1;
    int controlKeepAliveReplyTimeout = -1;
    int minParams = 5; // listings require 3 params
    String protocol = null; // SSL protocol
    String doCommand = null;
    String trustmgr = null;
    String proxyHost = null;
    int proxyPort = 80;
    String proxyUser = null;
    String proxyPassword = null;
    String username = null;
    String password = null;

    int base = 0;
    for (base = 0; base < args.length; base++) {
        if (args[base].equals("-s")) {
            storeFile = true;
        } else if (args[base].equals("-a")) {
            localActive = true;
        } else if (args[base].equals("-A")) {
            username = "anonymous";
            password = System.getProperty("user.name") + "@" + InetAddress.getLocalHost().getHostName();
        } else if (args[base].equals("-b")) {
            binaryTransfer = true;
        } else if (args[base].equals("-c")) {
            doCommand = args[++base];
            minParams = 3;
        } else if (args[base].equals("-d")) {
            mlsd = true;
            minParams = 3;
        } else if (args[base].equals("-e")) {
            useEpsvWithIPv4 = true;
        } else if (args[base].equals("-f")) {
            feat = true;
            minParams = 3;
        } else if (args[base].equals("-h")) {
            hidden = true;
        } else if (args[base].equals("-k")) {
            keepAliveTimeout = Long.parseLong(args[++base]);
        } else if (args[base].equals("-l")) {
            listFiles = true;
            minParams = 3;
        } else if (args[base].equals("-L")) {
            lenient = true;
        } else if (args[base].equals("-n")) {
            listNames = true;
            minParams = 3;
        } else if (args[base].equals("-p")) {
            protocol = args[++base];
        } else if (args[base].equals("-t")) {
            mlst = true;
            minParams = 3;
        } else if (args[base].equals("-w")) {
            controlKeepAliveReplyTimeout = Integer.parseInt(args[++base]);
        } else if (args[base].equals("-T")) {
            trustmgr = args[++base];
        } else if (args[base].equals("-PrH")) {
            proxyHost = args[++base];
            String parts[] = StringUtils.split(proxyHost, ':');
            if (parts.length == 2) {
                proxyHost = parts[0];
                proxyPort = Integer.parseInt(parts[1]);
            }
        } else if (args[base].equals("-PrU")) {
            proxyUser = args[++base];
        } else if (args[base].equals("-PrP")) {
            proxyPassword = args[++base];
        } else if (args[base].equals("-#")) {
            printHash = true;
        } else {
            break;
        }
    }

    int remain = args.length - base;
    if (username != null) {
        minParams -= 2;
    }
    if (remain < minParams) // server, user, pass, remote, local [protocol]
    {
        System.err.println(USAGE);
        System.exit(1);
    }

    String server = args[base++];
    int port = 0;
    String parts[] = server.split(":");
    if (parts.length == 2) {
        server = parts[0];
        port = Integer.parseInt(parts[1]);
    }
    if (username == null) {
        username = args[base++];
        password = args[base++];
    }

    String remote = null;
    if (args.length - base > 0) {
        remote = args[base++];
    }

    String local = null;
    if (args.length - base > 0) {
        local = args[base++];
    }

    final FTPClient ftp;
    if (protocol == null) {
        if (proxyHost != null) {
            System.out.println("Using HTTP proxy server: " + proxyHost);
            ftp = new FTPHTTPClient(proxyHost, proxyPort, proxyUser, proxyPassword);
        } else {
            ftp = new FTPClient();
        }
    } else {
        FTPSClient ftps;
        if (protocol.equals("true")) {
            ftps = new FTPSClient(true);
        } else if (protocol.equals("false")) {
            ftps = new FTPSClient(false);
        } else {
            String prot[] = protocol.split(",");
            if (prot.length == 1) { // Just protocol
                ftps = new FTPSClient(protocol);
            } else { // protocol,true|false
                ftps = new FTPSClient(prot[0], Boolean.parseBoolean(prot[1]));
            }
        }
        ftp = ftps;
        if ("all".equals(trustmgr)) {
            ftps.setTrustManager(TrustManagerUtils.getAcceptAllTrustManager());
        } else if ("valid".equals(trustmgr)) {
            ftps.setTrustManager(TrustManagerUtils.getValidateServerCertificateTrustManager());
        } else if ("none".equals(trustmgr)) {
            ftps.setTrustManager(null);
        }
    }

    if (printHash) {
        ftp.setCopyStreamListener(createListener());
    }
    if (keepAliveTimeout >= 0) {
        ftp.setControlKeepAliveTimeout(keepAliveTimeout);
    }
    if (controlKeepAliveReplyTimeout >= 0) {
        ftp.setControlKeepAliveReplyTimeout(controlKeepAliveReplyTimeout);
    }
    ftp.setListHiddenFiles(hidden);

    // suppress login details
    ftp.addProtocolCommandListener(new PrintCommandListener(new PrintWriter(System.out), true));

    try {
        int reply;
        if (port > 0) {
            ftp.connect(server, port);
        } else {
            ftp.connect(server);
        }
        System.out.println("Connected to " + server + " on " + (port > 0 ? port : ftp.getDefaultPort()));

        // After connection attempt, you should check the reply code to verify
        // success.
        reply = ftp.getReplyCode();

        if (!FTPReply.isPositiveCompletion(reply)) {
            ftp.disconnect();
            System.err.println("FTP server refused connection.");
            System.exit(1);
        }
    } catch (IOException e) {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
        System.err.println("Could not connect to server.");
        e.printStackTrace();
        System.exit(1);
    }

    __main: try {
        if (!ftp.login(username, password)) {
            ftp.logout();
            error = true;
            break __main;
        }

        System.out.println("Remote system is " + ftp.getSystemType());

        if (binaryTransfer) {
            ftp.setFileType(FTP.BINARY_FILE_TYPE);
        } else {
            // in theory this should not be necessary as servers should default to ASCII
            // but they don't all do so - see NET-500
            ftp.setFileType(FTP.ASCII_FILE_TYPE);
        }

        // Use passive mode as default because most of us are
        // behind firewalls these days.
        if (localActive) {
            ftp.enterLocalActiveMode();
        } else {
            ftp.enterLocalPassiveMode();
        }

        ftp.setUseEPSVwithIPv4(useEpsvWithIPv4);

        if (storeFile) {
            InputStream input;

            input = new FileInputStream(local);

            ftp.storeFile(remote, input);

            input.close();
        } else if (listFiles) {
            if (lenient) {
                FTPClientConfig config = new FTPClientConfig();
                config.setLenientFutureDates(true);
                ftp.configure(config);
            }

            for (FTPFile f : ftp.listFiles(remote)) {
                System.out.println(f.getRawListing());
                System.out.println(f.toFormattedString());
            }
        } else if (mlsd) {
            for (FTPFile f : ftp.mlistDir(remote)) {
                System.out.println(f.getRawListing());
                System.out.println(f.toFormattedString());
            }
        } else if (mlst) {
            FTPFile f = ftp.mlistFile(remote);
            if (f != null) {
                System.out.println(f.toFormattedString());
            }
        } else if (listNames) {
            for (String s : ftp.listNames(remote)) {
                System.out.println(s);
            }
        } else if (feat) {
            // boolean feature check
            if (remote != null) { // See if the command is present
                if (ftp.hasFeature(remote)) {
                    System.out.println("Has feature: " + remote);
                } else {
                    if (FTPReply.isPositiveCompletion(ftp.getReplyCode())) {
                        System.out.println("FEAT " + remote + " was not detected");
                    } else {
                        System.out.println("Command failed: " + ftp.getReplyString());
                    }
                }

                // Strings feature check
                String[] features = ftp.featureValues(remote);
                if (features != null) {
                    for (String f : features) {
                        System.out.println("FEAT " + remote + "=" + f + ".");
                    }
                } else {
                    if (FTPReply.isPositiveCompletion(ftp.getReplyCode())) {
                        System.out.println("FEAT " + remote + " is not present");
                    } else {
                        System.out.println("Command failed: " + ftp.getReplyString());
                    }
                }
            } else {
                if (ftp.features()) {
                    //                        Command listener has already printed the output
                } else {
                    System.out.println("Failed: " + ftp.getReplyString());
                }
            }
        } else if (doCommand != null) {
            if (ftp.doCommand(doCommand, remote)) {
                //                  Command listener has already printed the output
                //                    for(String s : ftp.getReplyStrings()) {
                //                        System.out.println(s);
                //                    }
            } else {
                System.out.println("Failed: " + ftp.getReplyString());
            }
        } else {
            OutputStream output;

            output = new FileOutputStream(local);

            ftp.retrieveFile(remote, output);

            output.close();
        }

        ftp.noop(); // check that control connection is working OK

        ftp.logout();
    } catch (FTPConnectionClosedException e) {
        error = true;
        System.err.println("Server closed connection.");
        e.printStackTrace();
    } catch (IOException e) {
        error = true;
        e.printStackTrace();
    } finally {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
    }

    System.exit(error ? 1 : 0);
}

---

From source file:eqtlmappingpipeline.util.ModuleEqtlGeuvadisReplication.java

/**
 * @param args the command line arguments
 *//*from   w w  w. j  av  a  2 s . c o m*/
public static void main(String[] args) throws IOException, LdCalculatorException {

    System.out.println(HEADER);
    System.out.println();
    System.out.flush(); //flush to make sure header is before errors
    try {
        Thread.sleep(25); //Allows flush to complete
    } catch (InterruptedException ex) {
    }

    CommandLineParser parser = new PosixParser();
    final CommandLine commandLine;
    try {
        commandLine = parser.parse(OPTIONS, args, true);
    } catch (ParseException ex) {
        System.err.println("Invalid command line arguments: " + ex.getMessage());
        System.err.println();
        new HelpFormatter().printHelp(" ", OPTIONS);
        System.exit(1);
        return;
    }

    final String[] genotypesBasePaths = commandLine.getOptionValues("g");
    final RandomAccessGenotypeDataReaderFormats genotypeDataType;
    final String replicationQtlFilePath = commandLine.getOptionValue("e");
    final String interactionQtlFilePath = commandLine.getOptionValue("i");
    final String outputFilePath = commandLine.getOptionValue("o");
    final double ldCutoff = Double.parseDouble(commandLine.getOptionValue("ld"));
    final int window = Integer.parseInt(commandLine.getOptionValue("w"));

    System.out.println("Genotype: " + Arrays.toString(genotypesBasePaths));
    System.out.println("Interaction file: " + interactionQtlFilePath);
    System.out.println("Replication file: " + replicationQtlFilePath);
    System.out.println("Output: " + outputFilePath);
    System.out.println("LD: " + ldCutoff);
    System.out.println("Window: " + window);

    try {
        if (commandLine.hasOption("G")) {
            genotypeDataType = RandomAccessGenotypeDataReaderFormats
                    .valueOf(commandLine.getOptionValue("G").toUpperCase());
        } else {
            if (genotypesBasePaths[0].endsWith(".vcf")) {
                System.err.println(
                        "Only vcf.gz is supported. Please see manual on how to do create a vcf.gz file.");
                System.exit(1);
                return;
            }
            try {
                genotypeDataType = RandomAccessGenotypeDataReaderFormats
                        .matchFormatToPath(genotypesBasePaths[0]);
            } catch (GenotypeDataException e) {
                System.err
                        .println("Unable to determine input 1 type based on specified path. Please specify -G");
                System.exit(1);
                return;
            }
        }
    } catch (IllegalArgumentException e) {
        System.err.println("Error parsing --genotypesFormat \"" + commandLine.getOptionValue("G")
                + "\" is not a valid input data format");
        System.exit(1);
        return;
    }

    final RandomAccessGenotypeData genotypeData;

    try {
        genotypeData = genotypeDataType.createFilteredGenotypeData(genotypesBasePaths, 100, null, null, null,
                0.8);
    } catch (TabixFileNotFoundException e) {
        LOGGER.fatal("Tabix file not found for input data at: " + e.getPath() + "\n"
                + "Please see README on how to create a tabix file");
        System.exit(1);
        return;
    } catch (IOException e) {
        LOGGER.fatal("Error reading input data: " + e.getMessage(), e);
        System.exit(1);
        return;
    } catch (IncompatibleMultiPartGenotypeDataException e) {
        LOGGER.fatal("Error combining the impute genotype data files: " + e.getMessage(), e);
        System.exit(1);
        return;
    } catch (GenotypeDataException e) {
        LOGGER.fatal("Error reading input data: " + e.getMessage(), e);
        System.exit(1);
        return;
    }

    ChrPosTreeMap<ArrayList<EQTL>> replicationQtls = new QTLTextFile(replicationQtlFilePath, false)
            .readQtlsAsTreeMap();

    int interactionSnpNotInGenotypeData = 0;
    int noReplicationQtlsInWindow = 0;
    int noReplicationQtlsInLd = 0;
    int multipleReplicationQtlsInLd = 0;
    int replicationTopSnpNotInGenotypeData = 0;

    final CSVWriter outputWriter = new CSVWriter(new FileWriter(new File(outputFilePath)), '\t', '\0');
    final String[] outputLine = new String[14];
    int c = 0;
    outputLine[c++] = "Chr";
    outputLine[c++] = "Pos";
    outputLine[c++] = "SNP";
    outputLine[c++] = "Gene";
    outputLine[c++] = "Module";
    outputLine[c++] = "DiscoveryZ";
    outputLine[c++] = "ReplicationZ";
    outputLine[c++] = "DiscoveryZCorrected";
    outputLine[c++] = "ReplicationZCorrected";
    outputLine[c++] = "DiscoveryAlleleAssessed";
    outputLine[c++] = "ReplicationAlleleAssessed";
    outputLine[c++] = "bestLd";
    outputLine[c++] = "bestLd_dist";
    outputLine[c++] = "nextLd";
    outputWriter.writeNext(outputLine);

    HashSet<String> notFound = new HashSet<>();

    CSVReader interactionQtlReader = new CSVReader(new FileReader(interactionQtlFilePath), '\t');
    interactionQtlReader.readNext();//skip header
    String[] interactionQtlLine;
    while ((interactionQtlLine = interactionQtlReader.readNext()) != null) {

        String snp = interactionQtlLine[1];
        String chr = interactionQtlLine[2];
        int pos = Integer.parseInt(interactionQtlLine[3]);
        String gene = interactionQtlLine[4];
        String alleleAssessed = interactionQtlLine[9];
        String module = interactionQtlLine[12];
        double discoveryZ = Double.parseDouble(interactionQtlLine[10]);

        GeneticVariant interactionQtlVariant = genotypeData.getSnpVariantByPos(chr, pos);

        if (interactionQtlVariant == null) {
            System.err.println("Interaction QTL SNP not found in genotype data: " + chr + ":" + pos);
            ++interactionSnpNotInGenotypeData;
            continue;
        }

        EQTL bestMatch = null;
        double bestMatchR2 = Double.NaN;
        Ld bestMatchLd = null;
        double nextBestR2 = Double.NaN;

        ArrayList<EQTL> sameSnpQtls = replicationQtls.get(chr, pos);

        if (sameSnpQtls != null) {
            for (EQTL sameSnpQtl : sameSnpQtls) {
                if (sameSnpQtl.getProbe().equals(gene)) {
                    bestMatch = sameSnpQtl;
                    bestMatchR2 = 1;
                }
            }
        }

        NavigableMap<Integer, ArrayList<EQTL>> potentionalReplicationQtls = replicationQtls.getChrRange(chr,
                pos - window, true, pos + window, true);

        for (ArrayList<EQTL> potentialReplicationQtls : potentionalReplicationQtls.values()) {

            for (EQTL potentialReplicationQtl : potentialReplicationQtls) {

                if (!potentialReplicationQtl.getProbe().equals(gene)) {
                    continue;
                }

                GeneticVariant potentialReplicationQtlVariant = genotypeData.getSnpVariantByPos(
                        potentialReplicationQtl.getRsChr().toString(), potentialReplicationQtl.getRsChrPos());

                if (potentialReplicationQtlVariant == null) {
                    notFound.add(potentialReplicationQtl.getRsChr().toString() + ":"
                            + potentialReplicationQtl.getRsChrPos());
                    ++replicationTopSnpNotInGenotypeData;
                    continue;
                }

                Ld ld = interactionQtlVariant.calculateLd(potentialReplicationQtlVariant);
                double r2 = ld.getR2();

                if (r2 > 1) {
                    r2 = 1;
                }

                if (bestMatch == null) {
                    bestMatch = potentialReplicationQtl;
                    bestMatchR2 = r2;
                    bestMatchLd = ld;
                } else if (r2 > bestMatchR2) {
                    bestMatch = potentialReplicationQtl;
                    nextBestR2 = bestMatchR2;
                    bestMatchR2 = r2;
                    bestMatchLd = ld;
                }

            }
        }

        double replicationZ = Double.NaN;
        double replicationZCorrected = Double.NaN;
        double discoveryZCorrected = Double.NaN;

        String replicationAlleleAssessed = null;

        if (bestMatch != null) {
            replicationZ = bestMatch.getZscore();
            replicationAlleleAssessed = bestMatch.getAlleleAssessed();

            if (pos != bestMatch.getRsChrPos()) {

                String commonHap = null;
                double commonHapFreq = -1;
                for (Map.Entry<String, Double> hapFreq : bestMatchLd.getHaplotypesFreq().entrySet()) {

                    double f = hapFreq.getValue();

                    if (f > commonHapFreq) {
                        commonHapFreq = f;
                        commonHap = hapFreq.getKey();
                    }

                }

                String[] commonHapAlleles = StringUtils.split(commonHap, '/');

                discoveryZCorrected = commonHapAlleles[0].equals(alleleAssessed) ? discoveryZ : discoveryZ * -1;
                replicationZCorrected = commonHapAlleles[1].equals(replicationAlleleAssessed) ? replicationZ
                        : replicationZ * -1;

            } else {

                discoveryZCorrected = discoveryZ;
                replicationZCorrected = alleleAssessed.equals(replicationAlleleAssessed) ? replicationZ
                        : replicationZ * -1;

            }

        }

        c = 0;
        outputLine[c++] = chr;
        outputLine[c++] = String.valueOf(pos);
        outputLine[c++] = snp;
        outputLine[c++] = gene;
        outputLine[c++] = module;
        outputLine[c++] = String.valueOf(discoveryZ);
        outputLine[c++] = bestMatch == null ? "NA" : String.valueOf(replicationZ);
        outputLine[c++] = bestMatch == null ? "NA" : String.valueOf(discoveryZCorrected);
        outputLine[c++] = bestMatch == null ? "NA" : String.valueOf(replicationZCorrected);
        outputLine[c++] = alleleAssessed;
        outputLine[c++] = bestMatch == null ? "NA" : String.valueOf(bestMatch.getAlleleAssessed());
        outputLine[c++] = String.valueOf(bestMatchR2);
        outputLine[c++] = bestMatch == null ? "NA" : String.valueOf(Math.abs(pos - bestMatch.getRsChrPos()));
        outputLine[c++] = String.valueOf(nextBestR2);
        outputWriter.writeNext(outputLine);

    }

    outputWriter.close();

    for (String e : notFound) {
        System.err.println("Not found: " + e);
    }

    System.out.println("interactionSnpNotInGenotypeData: " + interactionSnpNotInGenotypeData);
    System.out.println("noReplicationQtlsInWindow: " + noReplicationQtlsInWindow);
    System.out.println("noReplicationQtlsInLd: " + noReplicationQtlsInLd);
    System.out.println("multipleReplicationQtlsInLd: " + multipleReplicationQtlsInLd);
    System.out.println("replicationTopSnpNotInGenotypeData: " + replicationTopSnpNotInGenotypeData);

}

---

From source file:eqtlmappingpipeline.util.ModuleEqtlNeutrophilReplication.java

/**
 * @param args the command line arguments
 *//*w w w. j  a  v  a  2  s .c o m*/
public static void main(String[] args) throws IOException, LdCalculatorException {

    System.out.println(HEADER);
    System.out.println();
    System.out.flush(); //flush to make sure header is before errors
    try {
        Thread.sleep(25); //Allows flush to complete
    } catch (InterruptedException ex) {
    }

    CommandLineParser parser = new PosixParser();
    final CommandLine commandLine;
    try {
        commandLine = parser.parse(OPTIONS, args, true);
    } catch (ParseException ex) {
        System.err.println("Invalid command line arguments: " + ex.getMessage());
        System.err.println();
        new HelpFormatter().printHelp(" ", OPTIONS);
        System.exit(1);
        return;
    }

    final String[] genotypesBasePaths = commandLine.getOptionValues("g");
    final RandomAccessGenotypeDataReaderFormats genotypeDataType;
    final String replicationQtlFilePath = commandLine.getOptionValue("e");
    final String interactionQtlFilePath = commandLine.getOptionValue("i");
    final String outputFilePath = commandLine.getOptionValue("o");
    final double ldCutoff = Double.parseDouble(commandLine.getOptionValue("ld"));
    final int window = Integer.parseInt(commandLine.getOptionValue("w"));

    System.out.println("Genotype: " + Arrays.toString(genotypesBasePaths));
    System.out.println("Interaction file: " + interactionQtlFilePath);
    System.out.println("Replication file: " + replicationQtlFilePath);
    System.out.println("Output: " + outputFilePath);
    System.out.println("LD: " + ldCutoff);
    System.out.println("Window: " + window);

    try {
        if (commandLine.hasOption("G")) {
            genotypeDataType = RandomAccessGenotypeDataReaderFormats
                    .valueOf(commandLine.getOptionValue("G").toUpperCase());
        } else {
            if (genotypesBasePaths[0].endsWith(".vcf")) {
                System.err.println(
                        "Only vcf.gz is supported. Please see manual on how to do create a vcf.gz file.");
                System.exit(1);
                return;
            }
            try {
                genotypeDataType = RandomAccessGenotypeDataReaderFormats
                        .matchFormatToPath(genotypesBasePaths[0]);
            } catch (GenotypeDataException e) {
                System.err
                        .println("Unable to determine input 1 type based on specified path. Please specify -G");
                System.exit(1);
                return;
            }
        }
    } catch (IllegalArgumentException e) {
        System.err.println("Error parsing --genotypesFormat \"" + commandLine.getOptionValue("G")
                + "\" is not a valid input data format");
        System.exit(1);
        return;
    }

    final RandomAccessGenotypeData genotypeData;

    try {
        genotypeData = genotypeDataType.createFilteredGenotypeData(genotypesBasePaths, 100, null, null, null,
                0.8);
    } catch (TabixFileNotFoundException e) {
        LOGGER.fatal("Tabix file not found for input data at: " + e.getPath() + "\n"
                + "Please see README on how to create a tabix file");
        System.exit(1);
        return;
    } catch (IOException e) {
        LOGGER.fatal("Error reading input data: " + e.getMessage(), e);
        System.exit(1);
        return;
    } catch (IncompatibleMultiPartGenotypeDataException e) {
        LOGGER.fatal("Error combining the impute genotype data files: " + e.getMessage(), e);
        System.exit(1);
        return;
    } catch (GenotypeDataException e) {
        LOGGER.fatal("Error reading input data: " + e.getMessage(), e);
        System.exit(1);
        return;
    }

    ChrPosTreeMap<ArrayList<ReplicationQtl>> replicationQtls = new ChrPosTreeMap<>();

    CSVReader replicationQtlReader = new CSVReader(new FileReader(replicationQtlFilePath), '\t');
    replicationQtlReader.readNext();//skip header
    String[] replicationLine;
    while ((replicationLine = replicationQtlReader.readNext()) != null) {

        try {

            GeneticVariant variant = genotypeData.getSnpVariantByPos(replicationLine[REPLICATION_SNP_CHR_COL],
                    Integer.parseInt(replicationLine[REPLICATION_SNP_POS_COL]));
            if (variant == null) {
                continue;
            }

            ReplicationQtl replicationQtl = new ReplicationQtl(replicationLine[REPLICATION_SNP_CHR_COL],
                    Integer.parseInt(replicationLine[REPLICATION_SNP_POS_COL]),
                    replicationLine[REPLICATION_GENE_COL],
                    Double.parseDouble(replicationLine[REPLICATION_BETA_COL]),
                    variant.getAlternativeAlleles().get(0).getAlleleAsString());
            ArrayList<ReplicationQtl> posReplicationQtls = replicationQtls.get(replicationQtl.getChr(),
                    replicationQtl.getPos());
            if (posReplicationQtls == null) {
                posReplicationQtls = new ArrayList<>();
                replicationQtls.put(replicationQtl.getChr(), replicationQtl.getPos(), posReplicationQtls);
            }
            posReplicationQtls.add(replicationQtl);

        } catch (Exception e) {
            System.out.println(Arrays.toString(replicationLine));
            throw e;
        }
    }

    int interactionSnpNotInGenotypeData = 0;
    int noReplicationQtlsInWindow = 0;
    int noReplicationQtlsInLd = 0;
    int multipleReplicationQtlsInLd = 0;
    int replicationTopSnpNotInGenotypeData = 0;

    final CSVWriter outputWriter = new CSVWriter(new FileWriter(new File(outputFilePath)), '\t', '\0');
    final String[] outputLine = new String[14];
    int c = 0;
    outputLine[c++] = "Chr";
    outputLine[c++] = "Pos";
    outputLine[c++] = "SNP";
    outputLine[c++] = "Gene";
    outputLine[c++] = "Module";
    outputLine[c++] = "DiscoveryZ";
    outputLine[c++] = "ReplicationZ";
    outputLine[c++] = "DiscoveryZCorrected";
    outputLine[c++] = "ReplicationZCorrected";
    outputLine[c++] = "DiscoveryAlleleAssessed";
    outputLine[c++] = "ReplicationAlleleAssessed";
    outputLine[c++] = "bestLd";
    outputLine[c++] = "bestLd_dist";
    outputLine[c++] = "nextLd";
    outputWriter.writeNext(outputLine);

    HashSet<String> notFound = new HashSet<>();

    CSVReader interactionQtlReader = new CSVReader(new FileReader(interactionQtlFilePath), '\t');
    interactionQtlReader.readNext();//skip header
    String[] interactionQtlLine;
    while ((interactionQtlLine = interactionQtlReader.readNext()) != null) {

        String snp = interactionQtlLine[1];
        String chr = interactionQtlLine[2];
        int pos = Integer.parseInt(interactionQtlLine[3]);
        String gene = interactionQtlLine[4];
        String alleleAssessed = interactionQtlLine[9];
        String module = interactionQtlLine[12];
        double discoveryZ = Double.parseDouble(interactionQtlLine[10]);

        GeneticVariant interactionQtlVariant = genotypeData.getSnpVariantByPos(chr, pos);

        if (interactionQtlVariant == null) {
            System.err.println("Interaction QTL SNP not found in genotype data: " + chr + ":" + pos);
            ++interactionSnpNotInGenotypeData;
            continue;
        }

        ReplicationQtl bestMatch = null;
        double bestMatchR2 = Double.NaN;
        Ld bestMatchLd = null;
        double nextBestR2 = Double.NaN;

        ArrayList<ReplicationQtl> sameSnpQtls = replicationQtls.get(chr, pos);

        if (sameSnpQtls != null) {
            for (ReplicationQtl sameSnpQtl : sameSnpQtls) {
                if (sameSnpQtl.getGene().equals(gene)) {
                    bestMatch = sameSnpQtl;
                    bestMatchR2 = 1;
                }
            }
        }

        NavigableMap<Integer, ArrayList<ReplicationQtl>> potentionalReplicationQtls = replicationQtls
                .getChrRange(chr, pos - window, true, pos + window, true);

        for (ArrayList<ReplicationQtl> potentialReplicationQtls : potentionalReplicationQtls.values()) {

            for (ReplicationQtl potentialReplicationQtl : potentialReplicationQtls) {

                if (!potentialReplicationQtl.getGene().equals(gene)) {
                    continue;
                }

                GeneticVariant potentialReplicationQtlVariant = genotypeData
                        .getSnpVariantByPos(potentialReplicationQtl.getChr(), potentialReplicationQtl.getPos());

                if (potentialReplicationQtlVariant == null) {
                    notFound.add(potentialReplicationQtl.getChr() + ":" + potentialReplicationQtl.getPos());
                    ++replicationTopSnpNotInGenotypeData;
                    continue;
                }

                Ld ld = interactionQtlVariant.calculateLd(potentialReplicationQtlVariant);
                double r2 = ld.getR2();

                if (r2 > 1) {
                    r2 = 1;
                }

                if (bestMatch == null) {
                    bestMatch = potentialReplicationQtl;
                    bestMatchR2 = r2;
                    bestMatchLd = ld;
                } else if (r2 > bestMatchR2) {
                    bestMatch = potentialReplicationQtl;
                    nextBestR2 = bestMatchR2;
                    bestMatchR2 = r2;
                    bestMatchLd = ld;
                }

            }
        }

        double replicationZ = Double.NaN;
        double replicationZCorrected = Double.NaN;
        double discoveryZCorrected = Double.NaN;

        String replicationAlleleAssessed = null;

        if (bestMatch != null) {
            replicationZ = bestMatch.getBeta();
            replicationAlleleAssessed = bestMatch.getAssessedAllele();

            if (pos != bestMatch.getPos()) {

                String commonHap = null;
                double commonHapFreq = -1;
                for (Map.Entry<String, Double> hapFreq : bestMatchLd.getHaplotypesFreq().entrySet()) {

                    double f = hapFreq.getValue();

                    if (f > commonHapFreq) {
                        commonHapFreq = f;
                        commonHap = hapFreq.getKey();
                    }

                }

                String[] commonHapAlleles = StringUtils.split(commonHap, '/');

                discoveryZCorrected = commonHapAlleles[0].equals(alleleAssessed) ? discoveryZ : discoveryZ * -1;
                replicationZCorrected = commonHapAlleles[1].equals(replicationAlleleAssessed) ? replicationZ
                        : replicationZ * -1;

            } else {

                discoveryZCorrected = discoveryZ;
                replicationZCorrected = alleleAssessed.equals(replicationAlleleAssessed) ? replicationZ
                        : replicationZ * -1;

            }

        }

        c = 0;
        outputLine[c++] = chr;
        outputLine[c++] = String.valueOf(pos);
        outputLine[c++] = snp;
        outputLine[c++] = gene;
        outputLine[c++] = module;
        outputLine[c++] = String.valueOf(discoveryZ);
        outputLine[c++] = bestMatch == null ? "NA" : String.valueOf(replicationZ);
        outputLine[c++] = bestMatch == null ? "NA" : String.valueOf(discoveryZCorrected);
        outputLine[c++] = bestMatch == null ? "NA" : String.valueOf(replicationZCorrected);
        outputLine[c++] = alleleAssessed;
        outputLine[c++] = bestMatch == null ? "NA" : String.valueOf(bestMatch.getAssessedAllele());
        outputLine[c++] = String.valueOf(bestMatchR2);
        outputLine[c++] = bestMatch == null ? "NA" : String.valueOf(Math.abs(pos - bestMatch.getPos()));
        outputLine[c++] = String.valueOf(nextBestR2);
        outputWriter.writeNext(outputLine);

    }

    outputWriter.close();

    for (String e : notFound) {
        System.err.println("Not found: " + e);
    }

    System.out.println("interactionSnpNotInGenotypeData: " + interactionSnpNotInGenotypeData);
    System.out.println("noReplicationQtlsInWindow: " + noReplicationQtlsInWindow);
    System.out.println("noReplicationQtlsInLd: " + noReplicationQtlsInLd);
    System.out.println("multipleReplicationQtlsInLd: " + multipleReplicationQtlsInLd);
    System.out.println("replicationTopSnpNotInGenotypeData: " + replicationTopSnpNotInGenotypeData);

}

---

From source file:herddb.cli.HerdDBCLI.java

public static void main(String... args) throws IOException {
    try {// ww  w  .java 2  s. com
        DefaultParser parser = new DefaultParser();
        Options options = new Options();
        options.addOption("x", "url", true, "JDBC URL");
        options.addOption("u", "username", true, "JDBC Username");
        options.addOption("pwd", "password", true, "JDBC Password");
        options.addOption("q", "query", true, "Execute inline query");
        options.addOption("v", "verbose", false, "Verbose output");
        options.addOption("a", "async", false, "Use (experimental) executeBatchAsync for sending DML");
        options.addOption("s", "schema", true, "Default tablespace (SQL schema)");
        options.addOption("fi", "filter", true, "SQL filter mode: all|ddl|dml");
        options.addOption("f", "file", true, "SQL Script to execute (statement separated by 'GO' lines)");
        options.addOption("at", "autotransaction", false,
                "Execute scripts in autocommit=false mode and commit automatically");
        options.addOption("atbs", "autotransactionbatchsize", true, "Batch size for 'autotransaction' mode");
        options.addOption("g", "script", true, "Groovy Script to execute");
        options.addOption("i", "ignoreerrors", false, "Ignore SQL Errors during file execution");
        options.addOption("sc", "sqlconsole", false, "Execute SQL console in interactive mode");
        options.addOption("fmd", "mysql", false,
                "Intruct the parser that the script is coming from a MySQL Dump");
        options.addOption("rwst", "rewritestatements", false, "Rewrite all statements to use JDBC parameters");
        options.addOption("b", "backup", false, "Backup one or more tablespaces (selected with --schema)");
        options.addOption("r", "restore", false, "Restore tablespace");
        options.addOption("nl", "newleader", true, "Leader for new restored tablespace");
        options.addOption("ns", "newschema", true, "Name for new restored tablespace");
        options.addOption("tsm", "tablespacemapper", true,
                "Path to groovy script with a custom functin to map table names to tablespaces");
        options.addOption("dfs", "dumpfetchsize", true,
                "Fetch size for dump operations. Defaults to chunks of 100000 records");
        options.addOption("n", "nodeid", true, "Node id");
        options.addOption("t", "table", true, "Table name");
        options.addOption("p", "param", true, "Parameter name");
        options.addOption("val", "values", true, "Parameter values");
        options.addOption("lts", "list-tablespaces", false, "List available tablespaces");
        options.addOption("ln", "list-nodes", false, "List available nodes");
        options.addOption("sts", "show-tablespace", false,
                "Show full informations about a tablespace (needs -s option)");
        options.addOption("lt", "list-tables", false, "List tablespace tables (needs -s option)");
        options.addOption("st", "show-table", false,
                "Show full informations about a table (needs -s and -t options)");

        options.addOption("ar", "add-replica", false,
                "Add a replica to the tablespace (needs -s and -r options)");
        options.addOption("rr", "remove-replica", false,
                "Remove a replica from the tablespace (needs -s and -r options)");
        options.addOption("adt", "create-tablespace", false, "Create a tablespace (needs -ns and -nl options)");
        options.addOption("at", "alter-tablespace", false,
                "Alter a tablespace (needs -s, -param and --values options)");

        options.addOption("d", "describe", false, "Checks and describes a raw file");
        options.addOption("ft", "filetype", true,
                "Checks and describes a raw file (valid options are txlog, datapage, tablecheckpoint, indexcheckpoint, tablesmetadata");
        options.addOption("mdf", "metadatafile", true,
                "Tables metadata file, required for 'datapage' filetype");
        options.addOption("tsui", "tablespaceuuid", true, "Tablespace UUID, used for describing raw files");

        org.apache.commons.cli.CommandLine commandLine;
        try {
            commandLine = parser.parse(options, args);
        } catch (ParseException error) {
            println("Syntax error: " + error);
            failAndPrintHelp(options);
            return;
        }
        if (args.length == 0) {
            failAndPrintHelp(options);
            return;
        }

        String schema = commandLine.getOptionValue("schema", TableSpace.DEFAULT);
        String tablespaceuuid = commandLine.getOptionValue("tablespaceuuid", "");
        final boolean verbose = commandLine.hasOption("verbose");
        final boolean async = commandLine.hasOption("async");
        final String filter = commandLine.getOptionValue("filter", "all");
        if (!verbose) {
            LogManager.getLogManager().reset();
        }
        String file = commandLine.getOptionValue("file", "");
        String tablesmetadatafile = commandLine.getOptionValue("metadatafile", "");
        String table = commandLine.getOptionValue("table", "");
        boolean describe = commandLine.hasOption("describe");
        String filetype = commandLine.getOptionValue("filetype", "");
        if (describe) {
            try {
                if (file.isEmpty()) {
                    throw new IllegalArgumentException("file option is required");
                }
                describeRawFile(tablespaceuuid, table, tablesmetadatafile, file, filetype);
            } catch (Exception error) {
                if (verbose) {
                    error.printStackTrace();
                } else {
                    println("error:" + error);
                }
                exitCode = 1;
            }
            return;
        }
        String url = commandLine.getOptionValue("url", "jdbc:herddb:server:localhost:7000");
        String username = commandLine.getOptionValue("username",
                ClientConfiguration.PROPERTY_CLIENT_USERNAME_DEFAULT);
        String password = commandLine.getOptionValue("password",
                ClientConfiguration.PROPERTY_CLIENT_PASSWORD_DEFAULT);
        String query = commandLine.getOptionValue("query", "");

        boolean backup = commandLine.hasOption("backup");
        boolean restore = commandLine.hasOption("restore");
        String newschema = commandLine.getOptionValue("newschema", "");
        String leader = commandLine.getOptionValue("newleader", "");
        String script = commandLine.getOptionValue("script", "");
        String tablespacemapperfile = commandLine.getOptionValue("tablespacemapper", "");
        int dumpfetchsize = Integer.parseInt(commandLine.getOptionValue("dumpfetchsize", 100000 + ""));
        final boolean ignoreerrors = commandLine.hasOption("ignoreerrors");
        boolean sqlconsole = commandLine.hasOption("sqlconsole");
        final boolean frommysqldump = commandLine.hasOption("mysql");
        final boolean rewritestatements = commandLine.hasOption("rewritestatements")
                || !tablespacemapperfile.isEmpty() || frommysqldump;
        boolean autotransaction = commandLine.hasOption("autotransaction") || frommysqldump;
        int autotransactionbatchsize = Integer
                .parseInt(commandLine.getOptionValue("autotransactionbatchsize", 100000 + ""));
        if (!autotransaction) {
            autotransactionbatchsize = 0;
        }

        String nodeId = commandLine.getOptionValue("nodeid", "");
        String param = commandLine.getOptionValue("param", "");
        String values = commandLine.getOptionValue("values", "");

        boolean listTablespaces = commandLine.hasOption("list-tablespaces");
        boolean listNodes = commandLine.hasOption("list-nodes");
        boolean showTablespace = commandLine.hasOption("show-tablespace");
        boolean listTables = commandLine.hasOption("list-tables");
        boolean showTable = commandLine.hasOption("show-table");
        if (showTable) {
            if (table.equals("")) {
                println("Specify the table (-t <table>)");
                exitCode = 1;
                System.exit(exitCode);
            }
        }

        boolean createTablespace = commandLine.hasOption("create-tablespace");
        if (createTablespace) {
            if (newschema.equals("")) {
                println("Specify the tablespace name (--newschema <schema>)");
                exitCode = 1;
                System.exit(exitCode);
            }
            if (leader.equals("")) {
                println("Specify the leader node (--newleader <nodeid>)");
                exitCode = 1;
                System.exit(exitCode);
            }
        }
        boolean alterTablespace = commandLine.hasOption("alter-tablespace");
        if (alterTablespace) {
            if (commandLine.getOptionValue("schema", null) == null) {
                println("Cowardly refusing to assume the default schema in an alter command. Explicitly use \"-s "
                        + TableSpace.DEFAULT + "\" instead");
                exitCode = 1;
                System.exit(exitCode);
            }
            if (param.equals("")) {
                println("Specify the parameter (--param <par>)");
                exitCode = 1;
                System.exit(exitCode);
            }
            if (values.equals("")) {
                println("Specify values (--values <vals>)");
                exitCode = 1;
                System.exit(exitCode);
            }

        }
        boolean addReplica = commandLine.hasOption("add-replica");
        if (addReplica) {
            if (commandLine.getOptionValue("schema", null) == null) {
                println("Cowardly refusing to assume the default schema in an alter command. Explicitly use \"-s "
                        + TableSpace.DEFAULT + "\" instead");
                exitCode = 1;
                System.exit(exitCode);
            }
            if (nodeId.equals("")) {
                println("Specify the node (-n <nodeid>)");
                exitCode = 1;
                System.exit(exitCode);
            }
        }
        boolean removeReplica = commandLine.hasOption("remove-replica");
        if (removeReplica) {
            if (commandLine.getOptionValue("schema", null) == null) {
                println("Cowardly refusing to assume the default schema in an alter command. Explicitly use \"-s "
                        + TableSpace.DEFAULT + "\" instead");
                exitCode = 1;
                System.exit(exitCode);
            }
            if (nodeId.equals("")) {
                println("Specify the node (-n <nodeid>)");
                exitCode = 1;
                System.exit(exitCode);
            }
        }

        TableSpaceMapper tableSpaceMapper = buildTableSpaceMapper(tablespacemapperfile);
        try (HerdDBDataSource datasource = new HerdDBDataSource()) {
            datasource.setUrl(url);
            datasource.setUsername(username);
            datasource.setPassword(password);

            try (Connection connection = datasource.getConnection();
                    Statement statement = connection.createStatement()) {
                connection.setSchema(schema);
                if (sqlconsole) {
                    runSqlConsole(connection, statement, PRETTY_PRINT);
                } else if (backup) {
                    performBackup(statement, schema, file, options, connection, dumpfetchsize);
                } else if (restore) {
                    performRestore(file, leader, newschema, options, statement, connection);
                } else if (!query.isEmpty()) {
                    executeStatement(verbose, ignoreerrors, false, false, query, statement, tableSpaceMapper,
                            false, PRETTY_PRINT);
                } else if (!file.isEmpty()) {
                    executeSqlFile(autotransactionbatchsize, connection, file, verbose, async, ignoreerrors,
                            frommysqldump, rewritestatements, statement, tableSpaceMapper, PRETTY_PRINT, filter,
                            datasource);
                } else if (!script.isEmpty()) {
                    executeScript(connection, datasource, statement, script);
                } else if (listTablespaces) {
                    printTableSpaces(verbose, ignoreerrors, statement, tableSpaceMapper);
                } else if (listNodes) {
                    printNodes(verbose, ignoreerrors, statement, tableSpaceMapper);
                } else if (showTablespace) {
                    printTableSpaceInfos(verbose, ignoreerrors, statement, tableSpaceMapper, schema);
                } else if (listTables) {
                    listTables(verbose, ignoreerrors, statement, tableSpaceMapper, schema);
                } else if (showTable) {
                    printTableInfos(verbose, ignoreerrors, statement, tableSpaceMapper, schema, table);
                } else if (addReplica) {
                    changeReplica(verbose, ignoreerrors, statement, tableSpaceMapper, schema, nodeId,
                            ChangeReplicaAction.ADD);
                } else if (removeReplica) {
                    changeReplica(verbose, ignoreerrors, statement, tableSpaceMapper, schema, nodeId,
                            ChangeReplicaAction.REMOVE);
                } else if (createTablespace) {
                    createTablespace(verbose, ignoreerrors, statement, tableSpaceMapper, newschema, leader);
                } else if (alterTablespace) {
                    alterTablespace(verbose, ignoreerrors, statement, tableSpaceMapper, schema, param, values);
                } else {
                    failAndPrintHelp(options);
                    return;
                }
            }
            exitCode = 0;
        } catch (Exception error) {
            if (verbose) {
                error.printStackTrace();
            } else {
                println("error:" + error);
            }
            exitCode = 1;
        }
    } finally {
        System.exit(exitCode);
    }
}

---

From source file:edu.nyupoly.cs6903.ag3671.FTPClientExample.java

public static void main(String[] args) throws UnknownHostException, Exception {
    // MY CODE/*  w ww  .  j  ava2  s .  c  o m*/
    if (crypto(Collections.unmodifiableList(Arrays.asList(args)))) {
        return;
    }
    ;
    // MY CODE -- END

    boolean storeFile = false, binaryTransfer = true, error = false, listFiles = false, listNames = false,
            hidden = false;
    boolean localActive = false, useEpsvWithIPv4 = false, feat = false, printHash = false;
    boolean mlst = false, mlsd = false;
    boolean lenient = false;
    long keepAliveTimeout = -1;
    int controlKeepAliveReplyTimeout = -1;
    int minParams = 5; // listings require 3 params
    String protocol = null; // SSL protocol
    String doCommand = null;
    String trustmgr = null;
    String proxyHost = null;
    int proxyPort = 80;
    String proxyUser = null;
    String proxyPassword = null;
    String username = null;
    String password = null;

    int base = 0;
    for (base = 0; base < args.length; base++) {
        if (args[base].equals("-s")) {
            storeFile = true;
        } else if (args[base].equals("-a")) {
            localActive = true;
        } else if (args[base].equals("-A")) {
            username = "anonymous";
            password = System.getProperty("user.name") + "@" + InetAddress.getLocalHost().getHostName();
        }
        // Always use binary transfer 
        //            else if (args[base].equals("-b")) {
        //                binaryTransfer = true;
        //            }
        else if (args[base].equals("-c")) {
            doCommand = args[++base];
            minParams = 3;
        } else if (args[base].equals("-d")) {
            mlsd = true;
            minParams = 3;
        } else if (args[base].equals("-e")) {
            useEpsvWithIPv4 = true;
        } else if (args[base].equals("-f")) {
            feat = true;
            minParams = 3;
        } else if (args[base].equals("-h")) {
            hidden = true;
        } else if (args[base].equals("-k")) {
            keepAliveTimeout = Long.parseLong(args[++base]);
        } else if (args[base].equals("-l")) {
            listFiles = true;
            minParams = 3;
        } else if (args[base].equals("-L")) {
            lenient = true;
        } else if (args[base].equals("-n")) {
            listNames = true;
            minParams = 3;
        } else if (args[base].equals("-p")) {
            protocol = args[++base];
        } else if (args[base].equals("-t")) {
            mlst = true;
            minParams = 3;
        } else if (args[base].equals("-w")) {
            controlKeepAliveReplyTimeout = Integer.parseInt(args[++base]);
        } else if (args[base].equals("-T")) {
            trustmgr = args[++base];
        } else if (args[base].equals("-PrH")) {
            proxyHost = args[++base];
            String parts[] = proxyHost.split(":");
            if (parts.length == 2) {
                proxyHost = parts[0];
                proxyPort = Integer.parseInt(parts[1]);
            }
        } else if (args[base].equals("-PrU")) {
            proxyUser = args[++base];
        } else if (args[base].equals("-PrP")) {
            proxyPassword = args[++base];
        } else if (args[base].equals("-#")) {
            printHash = true;
        } else {
            break;
        }
    }

    int remain = args.length - base;
    if (username != null) {
        minParams -= 2;
    }
    if (remain < minParams) // server, user, pass, remote, local [protocol]
    {
        System.err.println(USAGE);
        System.exit(1);
    }

    String server = args[base++];
    int port = 0;
    String parts[] = server.split(":");
    if (parts.length == 2) {
        server = parts[0];
        port = Integer.parseInt(parts[1]);
    }
    if (username == null) {
        username = args[base++];
        password = args[base++];
    }

    String remote = null;
    if (args.length - base > 0) {
        remote = args[base++];
    }

    String local = null;
    if (args.length - base > 0) {
        local = args[base++];
    }

    final FTPClient ftp;
    if (protocol == null) {
        if (proxyHost != null) {
            System.out.println("Using HTTP proxy server: " + proxyHost);
            ftp = new FTPHTTPClient(proxyHost, proxyPort, proxyUser, proxyPassword);
        } else {
            ftp = new FTPClient();
        }
    } else {
        FTPSClient ftps;
        if (protocol.equals("true")) {
            ftps = new FTPSClient(true);
        } else if (protocol.equals("false")) {
            ftps = new FTPSClient(false);
        } else {
            String prot[] = protocol.split(",");
            if (prot.length == 1) { // Just protocol
                ftps = new FTPSClient(protocol);
            } else { // protocol,true|false
                ftps = new FTPSClient(prot[0], Boolean.parseBoolean(prot[1]));
            }
        }
        ftp = ftps;
        if ("all".equals(trustmgr)) {
            ftps.setTrustManager(TrustManagerUtils.getAcceptAllTrustManager());
        } else if ("valid".equals(trustmgr)) {
            ftps.setTrustManager(TrustManagerUtils.getValidateServerCertificateTrustManager());
        } else if ("none".equals(trustmgr)) {
            ftps.setTrustManager(null);
        }
    }

    if (printHash) {
        ftp.setCopyStreamListener(createListener());
    }
    if (keepAliveTimeout >= 0) {
        ftp.setControlKeepAliveTimeout(keepAliveTimeout);
    }
    if (controlKeepAliveReplyTimeout >= 0) {
        ftp.setControlKeepAliveReplyTimeout(controlKeepAliveReplyTimeout);
    }
    ftp.setListHiddenFiles(hidden);

    // suppress login details
    ftp.addProtocolCommandListener(new PrintCommandListener(new PrintWriter(System.out), true));

    try {
        int reply;
        if (port > 0) {
            ftp.connect(server, port);
        } else {
            ftp.connect(server);
        }
        System.out.println("Connected to " + server + " on " + (port > 0 ? port : ftp.getDefaultPort()));

        // After connection attempt, you should check the reply code to verify
        // success.
        reply = ftp.getReplyCode();

        if (!FTPReply.isPositiveCompletion(reply)) {
            ftp.disconnect();
            System.err.println("FTP server refused connection.");
            System.exit(1);
        }
    } catch (IOException e) {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
        System.err.println("Could not connect to server.");
        e.printStackTrace();
        System.exit(1);
    }

    __main: try {
        if (!ftp.login(username, password)) {
            ftp.logout();
            error = true;
            break __main;
        }

        System.out.println("Remote system is " + ftp.getSystemType());

        if (binaryTransfer) {
            ftp.setFileType(FTP.BINARY_FILE_TYPE);
        } else {
            // in theory this should not be necessary as servers should default to ASCII
            // but they don't all do so - see NET-500
            ftp.setFileType(FTP.ASCII_FILE_TYPE);
        }

        // Use passive mode as default because most of us are
        // behind firewalls these days.
        if (localActive) {
            ftp.enterLocalActiveMode();
        } else {
            ftp.enterLocalPassiveMode();
        }

        ftp.setUseEPSVwithIPv4(useEpsvWithIPv4);

        if (storeFile) {
            InputStream input;

            input = new FileInputStream(local);
            // MY CODE
            byte[] bytes = IOUtils.toByteArray(input);
            InputStream encrypted = new ByteArrayInputStream(cryptor.encrypt(bytes));
            // MY CODE -- END
            ftp.storeFile(remote, encrypted);

            input.close();
        } else if (listFiles) {
            if (lenient) {
                FTPClientConfig config = new FTPClientConfig();
                config.setLenientFutureDates(true);
                ftp.configure(config);
            }

            for (FTPFile f : ftp.listFiles(remote)) {
                System.out.println(f.getRawListing());
                System.out.println(f.toFormattedString());
            }
        } else if (mlsd) {
            for (FTPFile f : ftp.mlistDir(remote)) {
                System.out.println(f.getRawListing());
                System.out.println(f.toFormattedString());
            }
        } else if (mlst) {
            FTPFile f = ftp.mlistFile(remote);
            if (f != null) {
                System.out.println(f.toFormattedString());
            }
        } else if (listNames) {
            for (String s : ftp.listNames(remote)) {
                System.out.println(s);
            }
        } else if (feat) {
            // boolean feature check
            if (remote != null) { // See if the command is present
                if (ftp.hasFeature(remote)) {
                    System.out.println("Has feature: " + remote);
                } else {
                    if (FTPReply.isPositiveCompletion(ftp.getReplyCode())) {
                        System.out.println("FEAT " + remote + " was not detected");
                    } else {
                        System.out.println("Command failed: " + ftp.getReplyString());
                    }
                }

                // Strings feature check
                String[] features = ftp.featureValues(remote);
                if (features != null) {
                    for (String f : features) {
                        System.out.println("FEAT " + remote + "=" + f + ".");
                    }
                } else {
                    if (FTPReply.isPositiveCompletion(ftp.getReplyCode())) {
                        System.out.println("FEAT " + remote + " is not present");
                    } else {
                        System.out.println("Command failed: " + ftp.getReplyString());
                    }
                }
            } else {
                if (ftp.features()) {
                    //                        Command listener has already printed the output
                } else {
                    System.out.println("Failed: " + ftp.getReplyString());
                }
            }
        } else if (doCommand != null) {
            if (ftp.doCommand(doCommand, remote)) {
                //                  Command listener has already printed the output
                //                    for(String s : ftp.getReplyStrings()) {
                //                        System.out.println(s);
                //                    }
            } else {
                System.out.println("Failed: " + ftp.getReplyString());
            }
        } else {
            OutputStream output;

            output = new FileOutputStream(local);

            // MY CODE
            ByteArrayOutputStream remoteFile = new ByteArrayOutputStream();
            //InputStream byteIn = new ByteArrayInputStream(buf);
            ftp.retrieveFile(remote, remoteFile);
            remoteFile.flush();
            Optional<byte[]> opt = cryptor.decrypt(remoteFile.toByteArray());
            if (opt.isPresent()) {
                output.write(opt.get());
            }
            remoteFile.close();
            // MY CODE -- END
            output.close();
        }

        ftp.noop(); // check that control connection is working OK

        ftp.logout();
    } catch (FTPConnectionClosedException e) {
        error = true;
        System.err.println("Server closed connection.");
        e.printStackTrace();
    } catch (IOException e) {
        error = true;
        e.printStackTrace();
    } finally {
        if (ftp.isConnected()) {
            try {
                ftp.disconnect();
            } catch (IOException f) {
                // do nothing
            }
        }
    }

    System.exit(error ? 1 : 0);
}

---

From source file:eqtlmappingpipeline.util.ModuleEqtWestraReplication.java

/**
 * @param args the command line arguments
 *///from   w ww  . java  2 s. co  m
public static void main(String[] args) throws IOException, LdCalculatorException {

    System.out.println(HEADER);
    System.out.println();
    System.out.flush(); //flush to make sure header is before errors
    try {
        Thread.sleep(25); //Allows flush to complete
    } catch (InterruptedException ex) {
    }

    CommandLineParser parser = new PosixParser();
    final CommandLine commandLine;
    try {
        commandLine = parser.parse(OPTIONS, args, true);
    } catch (ParseException ex) {
        System.err.println("Invalid command line arguments: " + ex.getMessage());
        System.err.println();
        new HelpFormatter().printHelp(" ", OPTIONS);
        System.exit(1);
        return;
    }

    final String[] genotypesBasePaths = commandLine.getOptionValues("g");
    final RandomAccessGenotypeDataReaderFormats genotypeDataType;
    final String replicationQtlFilePath = commandLine.getOptionValue("e");
    final String interactionQtlFilePath = commandLine.getOptionValue("i");
    final String outputFilePath = commandLine.getOptionValue("o");
    final double ldCutoff = Double.parseDouble(commandLine.getOptionValue("ld"));
    final int window = Integer.parseInt(commandLine.getOptionValue("w"));

    System.out.println("Genotype: " + Arrays.toString(genotypesBasePaths));
    System.out.println("Interaction file: " + interactionQtlFilePath);
    System.out.println("Replication file: " + replicationQtlFilePath);
    System.out.println("Output: " + outputFilePath);
    System.out.println("LD: " + ldCutoff);
    System.out.println("Window: " + window);

    try {
        if (commandLine.hasOption("G")) {
            genotypeDataType = RandomAccessGenotypeDataReaderFormats
                    .valueOf(commandLine.getOptionValue("G").toUpperCase());
        } else {
            if (genotypesBasePaths[0].endsWith(".vcf")) {
                System.err.println(
                        "Only vcf.gz is supported. Please see manual on how to do create a vcf.gz file.");
                System.exit(1);
                return;
            }
            try {
                genotypeDataType = RandomAccessGenotypeDataReaderFormats
                        .matchFormatToPath(genotypesBasePaths[0]);
            } catch (GenotypeDataException e) {
                System.err
                        .println("Unable to determine input 1 type based on specified path. Please specify -G");
                System.exit(1);
                return;
            }
        }
    } catch (IllegalArgumentException e) {
        System.err.println("Error parsing --genotypesFormat \"" + commandLine.getOptionValue("G")
                + "\" is not a valid input data format");
        System.exit(1);
        return;
    }

    final RandomAccessGenotypeData genotypeData;

    try {
        genotypeData = genotypeDataType.createFilteredGenotypeData(genotypesBasePaths, 100, null, null, null,
                0.8);
    } catch (TabixFileNotFoundException e) {
        LOGGER.fatal("Tabix file not found for input data at: " + e.getPath() + "\n"
                + "Please see README on how to create a tabix file");
        System.exit(1);
        return;
    } catch (IOException e) {
        LOGGER.fatal("Error reading input data: " + e.getMessage(), e);
        System.exit(1);
        return;
    } catch (IncompatibleMultiPartGenotypeDataException e) {
        LOGGER.fatal("Error combining the impute genotype data files: " + e.getMessage(), e);
        System.exit(1);
        return;
    } catch (GenotypeDataException e) {
        LOGGER.fatal("Error reading input data: " + e.getMessage(), e);
        System.exit(1);
        return;
    }

    ChrPosTreeMap<ArrayList<ReplicationQtl>> replicationQtls = new ChrPosTreeMap<>();

    CSVReader replicationQtlReader = new CSVReader(new FileReader(replicationQtlFilePath), '\t');
    String[] replicationHeader = replicationQtlReader.readNext();
    String[] replicationLine;
    while ((replicationLine = replicationQtlReader.readNext()) != null) {

        try {

            GeneticVariant variant = genotypeData.getSnpVariantByPos(replicationLine[REPLICATION_SNP_CHR_COL],
                    Integer.parseInt(replicationLine[REPLICATION_SNP_POS_COL]));
            if (variant == null) {
                continue;
            }

            Alleles variantAlleles = variant.getVariantAlleles();
            String[] replicationAllelesString = StringUtils.split(replicationLine[REPLICATION_ALLELES_COL],
                    '/');

            Alleles replicationAlleles = Alleles.createBasedOnString(replicationAllelesString[0],
                    replicationAllelesString[1]);
            Allele assessedAlleleReplication = Allele.create(replicationLine[REPLICATION_ALLELE_ASSESSED_COL]);

            boolean isAmbigous = replicationAlleles.isAtOrGcSnp();

            if (!variantAlleles.equals(replicationAlleles)) {
                if (variantAlleles.equals(replicationAlleles.getComplement())) {
                    assessedAlleleReplication = assessedAlleleReplication.getComplement();
                } else {
                    continue;
                }
            }

            ReplicationQtl replicationQtl = new ReplicationQtl(replicationLine[REPLICATION_SNP_CHR_COL],
                    Integer.parseInt(replicationLine[REPLICATION_SNP_POS_COL]),
                    replicationLine[REPLICATION_GENE_COL],
                    Double.parseDouble(replicationLine[REPLICATION_BETA_COL]),
                    assessedAlleleReplication.getAlleleAsString(), replicationLine, isAmbigous);
            ArrayList<ReplicationQtl> posReplicationQtls = replicationQtls.get(replicationQtl.getChr(),
                    replicationQtl.getPos());
            if (posReplicationQtls == null) {
                posReplicationQtls = new ArrayList<>();
                replicationQtls.put(replicationQtl.getChr(), replicationQtl.getPos(), posReplicationQtls);
            }
            posReplicationQtls.add(replicationQtl);

        } catch (Exception e) {
            System.out.println(Arrays.toString(replicationLine));
            throw e;
        }
    }

    int interactionSnpNotInGenotypeData = 0;
    int noReplicationQtlsInWindow = 0;
    int noReplicationQtlsInLd = 0;
    int multipleReplicationQtlsInLd = 0;
    int replicationTopSnpNotInGenotypeData = 0;

    final CSVWriter outputWriter = new CSVWriter(new FileWriter(new File(outputFilePath)), '\t', '\0');
    final String[] outputLine = new String[15 + EXTRA_COL_FROM_REPLICATION.length];
    int c = 0;
    outputLine[c++] = "Chr";
    outputLine[c++] = "Pos";
    outputLine[c++] = "SNP";
    outputLine[c++] = "Gene";
    outputLine[c++] = "Module";
    outputLine[c++] = "DiscoveryZ";
    outputLine[c++] = "ReplicationZ";
    outputLine[c++] = "DiscoveryZCorrected";
    outputLine[c++] = "ReplicationZCorrected";
    outputLine[c++] = "DiscoveryAlleleAssessed";
    outputLine[c++] = "ReplicationAlleleAssessed";
    outputLine[c++] = "bestLd";
    outputLine[c++] = "bestLd_dist";
    outputLine[c++] = "nextLd";
    outputLine[c++] = "replicationAmbigous";
    for (int i = 0; i < EXTRA_COL_FROM_REPLICATION.length; ++i) {
        outputLine[c++] = replicationHeader[EXTRA_COL_FROM_REPLICATION[i]];
    }
    outputWriter.writeNext(outputLine);

    HashSet<String> notFound = new HashSet<>();

    CSVReader interactionQtlReader = new CSVReader(new FileReader(interactionQtlFilePath), '\t');
    interactionQtlReader.readNext();//skip header
    String[] interactionQtlLine;
    while ((interactionQtlLine = interactionQtlReader.readNext()) != null) {

        String snp = interactionQtlLine[1];
        String chr = interactionQtlLine[2];
        int pos = Integer.parseInt(interactionQtlLine[3]);
        String gene = interactionQtlLine[4];
        String alleleAssessed = interactionQtlLine[9];
        String module = interactionQtlLine[12];
        double discoveryZ = Double.parseDouble(interactionQtlLine[10]);

        GeneticVariant interactionQtlVariant = genotypeData.getSnpVariantByPos(chr, pos);

        if (interactionQtlVariant == null) {
            System.err.println("Interaction QTL SNP not found in genotype data: " + chr + ":" + pos);
            ++interactionSnpNotInGenotypeData;
            continue;
        }

        ReplicationQtl bestMatch = null;
        double bestMatchR2 = Double.NaN;
        Ld bestMatchLd = null;
        double nextBestR2 = Double.NaN;

        ArrayList<ReplicationQtl> sameSnpQtls = replicationQtls.get(chr, pos);

        if (sameSnpQtls != null) {
            for (ReplicationQtl sameSnpQtl : sameSnpQtls) {
                if (sameSnpQtl.getGene().equals(gene)) {
                    bestMatch = sameSnpQtl;
                    bestMatchR2 = 1;
                }
            }
        }

        NavigableMap<Integer, ArrayList<ReplicationQtl>> potentionalReplicationQtls = replicationQtls
                .getChrRange(chr, pos - window, true, pos + window, true);

        for (ArrayList<ReplicationQtl> potentialReplicationQtls : potentionalReplicationQtls.values()) {

            for (ReplicationQtl potentialReplicationQtl : potentialReplicationQtls) {

                if (!potentialReplicationQtl.getGene().equals(gene)) {
                    continue;
                }

                GeneticVariant potentialReplicationQtlVariant = genotypeData
                        .getSnpVariantByPos(potentialReplicationQtl.getChr(), potentialReplicationQtl.getPos());

                if (potentialReplicationQtlVariant == null) {
                    notFound.add(potentialReplicationQtl.getChr() + ":" + potentialReplicationQtl.getPos());
                    ++replicationTopSnpNotInGenotypeData;
                    continue;
                }

                Ld ld = interactionQtlVariant.calculateLd(potentialReplicationQtlVariant);
                double r2 = ld.getR2();

                if (r2 > 1) {
                    r2 = 1;
                }

                if (bestMatch == null) {
                    bestMatch = potentialReplicationQtl;
                    bestMatchR2 = r2;
                    bestMatchLd = ld;
                } else if (r2 > bestMatchR2) {
                    bestMatch = potentialReplicationQtl;
                    nextBestR2 = bestMatchR2;
                    bestMatchR2 = r2;
                    bestMatchLd = ld;
                }

            }
        }

        double replicationZ = Double.NaN;
        double replicationZCorrected = Double.NaN;
        double discoveryZCorrected = Double.NaN;

        String replicationAlleleAssessed = null;

        if (bestMatch != null) {
            replicationZ = bestMatch.getBeta();
            replicationAlleleAssessed = bestMatch.getAssessedAllele();

            if (pos != bestMatch.getPos()) {

                String commonHap = null;
                double commonHapFreq = -1;
                for (Map.Entry<String, Double> hapFreq : bestMatchLd.getHaplotypesFreq().entrySet()) {

                    double f = hapFreq.getValue();

                    if (f > commonHapFreq) {
                        commonHapFreq = f;
                        commonHap = hapFreq.getKey();
                    }

                }

                String[] commonHapAlleles = StringUtils.split(commonHap, '/');

                discoveryZCorrected = commonHapAlleles[0].equals(alleleAssessed) ? discoveryZ : discoveryZ * -1;
                replicationZCorrected = commonHapAlleles[1].equals(replicationAlleleAssessed) ? replicationZ
                        : replicationZ * -1;

            } else {

                discoveryZCorrected = discoveryZ;
                replicationZCorrected = alleleAssessed.equals(replicationAlleleAssessed) ? replicationZ
                        : replicationZ * -1;
                //replicationZCorrected = alleleAssessed.equals(replicationAlleleAssessed) || alleleAssessed.equals(String.valueOf(Utils.getComplementNucleotide(replicationAlleleAssessed.charAt(0)))) ? replicationZ : replicationZ * -1;

            }

        }

        c = 0;
        outputLine[c++] = chr;
        outputLine[c++] = String.valueOf(pos);
        outputLine[c++] = snp;
        outputLine[c++] = gene;
        outputLine[c++] = module;
        outputLine[c++] = String.valueOf(discoveryZ);
        outputLine[c++] = bestMatch == null ? "NA" : String.valueOf(replicationZ);
        outputLine[c++] = bestMatch == null ? "NA" : String.valueOf(discoveryZCorrected);
        outputLine[c++] = bestMatch == null ? "NA" : String.valueOf(replicationZCorrected);
        outputLine[c++] = alleleAssessed;
        outputLine[c++] = bestMatch == null ? "NA" : String.valueOf(bestMatch.getAssessedAllele());
        outputLine[c++] = String.valueOf(bestMatchR2);
        outputLine[c++] = bestMatch == null ? "NA" : String.valueOf(Math.abs(pos - bestMatch.getPos()));
        outputLine[c++] = String.valueOf(nextBestR2);
        outputLine[c++] = bestMatch == null ? "NA" : String.valueOf(bestMatch.isIsAmbigous());

        if (bestMatch == null) {
            for (int i = 0; i < EXTRA_COL_FROM_REPLICATION.length; ++i) {
                outputLine[c++] = "NA";
            }
        } else {
            for (int i = 0; i < EXTRA_COL_FROM_REPLICATION.length; ++i) {
                outputLine[c++] = bestMatch.getLine()[EXTRA_COL_FROM_REPLICATION[i]];
            }
        }

        outputWriter.writeNext(outputLine);

    }

    outputWriter.close();

    for (String e : notFound) {
        System.err.println("Not found: " + e);
    }

    System.out.println("interactionSnpNotInGenotypeData: " + interactionSnpNotInGenotypeData);
    System.out.println("noReplicationQtlsInWindow: " + noReplicationQtlsInWindow);
    System.out.println("noReplicationQtlsInLd: " + noReplicationQtlsInLd);
    System.out.println("multipleReplicationQtlsInLd: " + multipleReplicationQtlsInLd);
    System.out.println("replicationTopSnpNotInGenotypeData: " + replicationTopSnpNotInGenotypeData);

}

---

From source file:erigo.filepump.FilePump.java

public static void main(String[] argsI) {

    boolean local_bShowGUI = true;

    String initial_outputFolder = ".";
    double initial_filesPerSec = 1.0;
    int initial_totNumFiles = 1000;
    String initial_mode_str = "local";
    String initial_ftpHost;/*w w  w  .ja  v  a  2s .  c o  m*/
    String initial_ftpUser;
    String initial_ftpPassword;

    //
    // Parse command line arguments
    //
    // We use the Apche Commons CLI library to handle command line
    // arguments. See https://commons.apache.org/proper/commons-cli/usage.html
    // for examples, although note that we use the more up-to-date form
    // (Option.builder) to create Option objects.
    //
    // 1. Setup command line options
    //
    Options options = new Options();
    // Example of a Boolean option (i.e., only the flag, no argument goes with it)
    options.addOption("h", "help", false, "Print this message.");
    // The following example is for: -outputfolder <folder>    Location of output files
    Option outputFolderOption = Option.builder("outputfolder").argName("folder").hasArg()
            .desc("Location of output files; this folder must exist (it will not be created); default = \""
                    + initial_outputFolder + "\".")
            .build();
    options.addOption(outputFolderOption);
    Option filesPerSecOption = Option.builder("fps").argName("filespersec").hasArg()
            .desc("Desired file rate, files/sec; default = " + initial_filesPerSec + ".").build();
    options.addOption(filesPerSecOption);
    Option totNumFilesOption = Option.builder("totnum").argName("num").hasArg().desc(
            "Total number of output files; use -1 for unlimited number; default = " + initial_totNumFiles + ".")
            .build();
    options.addOption(totNumFilesOption);
    Option outputModeOption = Option.builder("mode").argName("mode").hasArg()
            .desc("Specifies output interface, one of <local|ftp|sftp>; default = " + initial_mode_str + ".")
            .build();
    options.addOption(outputModeOption);
    Option ftpHostOption = Option.builder("ftphost").argName("host").hasArg()
            .desc("Host name, for FTP or SFTP.").build();
    options.addOption(ftpHostOption);
    Option ftpUsernameOption = Option.builder("ftpuser").argName("user").hasArg()
            .desc("Username, for FTP or SFTP.").build();
    options.addOption(ftpUsernameOption);
    Option ftpPasswordOption = Option.builder("ftppass").argName("password").hasArg()
            .desc("Password, for FTP or SFTP.").build();
    options.addOption(ftpPasswordOption);
    Option autoRunOption = new Option("x", "Automatically run at startup.");
    options.addOption(autoRunOption);
    //
    // 2. Parse command line options
    //
    CommandLineParser parser = new DefaultParser();
    CommandLine line = null;
    try {
        line = parser.parse(options, argsI);
    } catch (ParseException exp) {
        // oops, something went wrong
        System.err.println("Command line argument parsing failed: " + exp.getMessage());
        return;
    }
    //
    // 3. Retrieve the command line values
    //
    if (line.hasOption("help")) {
        // Display help message and quit
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp("FilePump", options);
        return;
    }
    if (line.hasOption("x")) {
        local_bShowGUI = false;
    }
    // Where to write the files to
    initial_outputFolder = line.getOptionValue("outputfolder", initial_outputFolder);
    // How many files per second the pump should output
    try {
        initial_filesPerSec = Double.parseDouble(line.getOptionValue("fps", "" + initial_filesPerSec));
    } catch (NumberFormatException nfe) {
        System.err.println("\nError parsing \"fps\" (it should be a floating point value):\n" + nfe);
        return;
    }
    // Total number of files to write out; -1 indicates unlimited
    try {
        initial_totNumFiles = Integer.parseInt(line.getOptionValue("totnum", "" + initial_totNumFiles));
    } catch (NumberFormatException nfe) {
        System.err.println("\nError parsing \"totnum\" (it should be an integer):\n" + nfe);
        return;
    }
    // Specifies how files will be written out
    initial_mode_str = line.getOptionValue("mode", initial_mode_str);
    if (!initial_mode_str.equals("local") && !initial_mode_str.equals("ftp")
            && !initial_mode_str.equals("sftp")) {
        System.err.println(new String("\nUnrecognized mode, \"" + initial_mode_str + "\""));
        return;
    }
    // FTP hostname
    initial_ftpHost = line.getOptionValue("ftphost", "");
    // FTP username
    initial_ftpUser = line.getOptionValue("ftpuser", "");
    // FTP password
    initial_ftpPassword = line.getOptionValue("ftppass", "");

    // Create the FilePump object
    new FilePump(local_bShowGUI, initial_outputFolder, initial_filesPerSec, initial_totNumFiles,
            initial_mode_str, initial_ftpHost, initial_ftpUser, initial_ftpPassword);

}

---

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;/*w  w w. j a va2 s  .c  om*/

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

}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• »